PolarisScanner.h

#pragma once
#if !OPTECH_RT_API
#include <IPlsControlCallback.h>
#include "GPSInterface/Headers/GPSSensor.h"
#include "Hardware/Headers/Scanner3D.h"
#include "Hardware/Headers/Connection.h"
#include "Widgets/Headers/PhysicalCameraView.h"
#include "Design/Headers/PolarPointFilter.h"
#include "Base/Headers/Time.h"
#include "Base/Headers/TimeSpan.h"
#include "Base/Headers/Pointer.hpp"
#include "Base/Headers/Thread.h"
#include "Base/Headers/INIInterface.h"
#include <Rt_Types.h>
class ScannerDriver;
namespace OPTECH_POLARIS_API
{
    class IPolarisControl;
}
namespace NDEVR
{
    class FileRequest;
    class DesignObjectLookup;
    class Log;
    class OptechMotor;
    class Battery;
    class OptechScannerConnection;
    class OptechRangeSensor;
    class OptechScannerPositionSensor;
    class SocketIOChannel;
    class OptechBase;
 
    

    class PolarisScanner : public OPTECH_POLARIS_API::IPlsControlCallback, public Scanner3D, public INIInterface
    {
        enum PowerSource
        {
              e_plugged_in  
            , e_battery_1   
            , e_battery_2   
        };
    public:
        PolarisScanner(Connection* connection, DesignObjectLookup* manager, ProgressInfo* log, QObject* parent = nullptr);
        virtual ~PolarisScanner();
        virtual TimeSpan getScanTime(const ScanSetupSettings& settings) const override;
        virtual String scannerType() const override;
        virtual void standardUpdate();
        virtual Motor* headMotor(uint01 axis) const override;
        virtual void startScan(const ScanSetupSettings& settings) override;
        virtual void stopScan() override;
        virtual void pauseScan() override;
        virtual void resumeScan() override;
        virtual void createScanner() override;
        virtual bool isValid() const override;
        virtual bool canDeploy() const override { return false; };
        void updateCamera();
        virtual void recordPoint(bool record_to_cloud = true, bool record_to_mesh = true) override;
        void startScanProcess();
        virtual void orientHead(const Vector<3, Angle>& head_orientation) override;
        virtual bool supportsContinuousScan() const override { return false; }
        virtual bool executeManualCommand(const String& command) override;
        virtual bool scanModeSupported(ScanMode scan_mode) const override;
        virtual Bounds<2, Angle> scanBounds() const;
        void requestDisconnect(bool disconnect) { m_request_disconnect = disconnect; }
        virtual void setScannerState(ScannerState scanner_state) override;
        virtual PositionSensor* positionSensor() const override;
        virtual RangeSensor* rangeSensor() const override { return m_range_sensor; }
        ScannerState scannerState() const override;
        Bounds<2, Angle> maxScanBounds(ScanMode mode) const override;
        virtual Connection* connection() const override { return m_connection; };
        [[nodiscard]] virtual Buffer<Battery*> batteries() const;
        [[nodiscard]] virtual Buffer<TemperatureSensor*> temperatureSensors() const;
        [[nodiscard]] virtual OrientationSensor* orientationSensor() const;
        [[nodiscard]] virtual TimeSpan scanTimeRemaining() const;
        [[nodiscard]] virtual fltp04 getScanPercent() const;
        int processPoints(std::vector<Optech::RtLidar::LidarPoint>& lidarPointsArray);
        int processPoints(Optech::RtLidar::LidarPoint* points, uint04 size);
        static OPTECH_POLARIS_API::SPlsScanROI Convert(const ScanSetupSettings& setting);
    protected:
        void updateModel();
        void recordPoint(const PolarScanRecord<fltp04>& record, bool record_to_cloud = true, bool record_to_mesh = true) override;
        virtual FileRequest scanModelFile() const override;
        virtual Matrix<fltp08> scanModelFileTransform() const;
        virtual void update() override;
        void parkDevice() override;
        TimeSpan updateInterval() const override;
        Matrix<fltp08> laserTransform(const Vector<3, Angle>& head_angle) const override;
        virtual Matrix<fltp08> scanTransform() const;
        virtual INIFactory getINI() override;
        void disconnect();
    protected:
        //virtual void AddClientCallback(IPls) override;

        virtual void OnCommConnected(unsigned int ip, unsigned int port) override;
        virtual void OnCommDrop(unsigned int ip, unsigned int port) override;
        virtual void OnCommError(unsigned int ip, unsigned int port) override;
        virtual void OnCommZeroLength(unsigned int ip, unsigned int port) override;
 
        //Gets SCADA and SBL (Single Board Lidar) FPGA firmware versions
        //Rev8
        //              Parameter   Type    Notes
        //              sbl_ver   : uint   - sbl fpga firmware build version
        //              os_ver    : string - linux OS build version
        //              scada_ver : string - scada firmware build version
        //              obui_ver    : string -  OBUI build version
        /*Rev9
        Parameter   Type    Notes
        sbl_fpga_ver    : uint  SBL FPGA firmware version (*.mcs file)
        linux_os_ver    : string    Linux OS build version (kernel and root file system)
        sbl_driver_ver: uint    SBL Linux driver kernel module (sbldrv.ko file)
        scada_sw_ver    : string    SCADA embedded control software version (polaris file)
        uiapi_ver       : string    on-board API version (libuiapi.so file)
        obui_ver        : string    on-board UI build version (Polaris.jar file)
        */
        //virtual void OnGetSoftwareVersions(const unsigned int sblBuildNumber, const SPlsString ver[3]) override;
        virtual void OnGetSoftwareVersions(const OPTECH_POLARIS_API::PlsSoftwareVersion* softwareVersion) override;
 
        // Gets system serial number
        virtual void OnGetSystemSerial(const int serial_num) override;
 
        // Gets Processor system time, 
        // feedback: time in 16 bytes, Windows SYSTEMTIME data structure
        virtual void OnGetSystemTime(const SYSTEMTIME time) override;
 
        // Sets Processor system time and save to hardware clock
        // feedback: status int 0  – successful, -1 – error
        virtual void OnSetSystemTime(const int status) override {};
 
        // Updates SCADA firmware. The new file(s) must be in 
        // /home/polaris/public directory in order for the update to occur
        // feedback: status int 0  – successful, -1 – error
        virtual void OnUpdateSoftwareAndFirmware(const int status) override;
 
        // Updates linux OS related files
        // feedback: status int 0  – successful, -1 – error
        virtual void OnUpdateCalAndConfig(const int status) override {};
 
        // Queries current system state
        // feedback: state, int, system state: 0 – idle, 1 –  survey, 2 - paused   
        virtual void OnGetSystemState(const int system_state) override;
 
        // Gets battery constant data. feedback:
        // max_error   int         maximum error         
        // fcp         int         full charge capacity
        // ccount      int         cycle count
        // manu        int         manufacture date
        // sn          int         serial number
        virtual void OnGetBatteryStatic(const OPTECH_POLARIS_API::SPlsBatteryConst batter_static) override;
 
        // Gets battery dynamic data like temperature, voltage, current, capacity and remaining
        // feedback:
        // temp        int         temperature
        // volt        int         voltage
        // curr        int         current
        // cap         int         remaining capacity
        // ave         int         average time to empty
        virtual void OnGetBatteryDynamic(const OPTECH_POLARIS_API::SPlsBatteryDynamic battery_dynamic) override;
 
        // Gets disk's total and free spaces
        // feedback:
        // total_capacity   float         disk total capacity in Mbytes
        // free_space       float         disk remaining/available space in Mbytes
        virtual void OnGetDiskInfo(const float capacity, const float free_space) override;
 
        // Get instrument Model Number
        // feedback:
        // modelNumber  int   model number : 0-unknown, 1-TLS-250, 2-TLS-750, 3-TLS1600
        virtual void OnGetModelNumber(const int modelNumber) override;
 
        virtual void OnSetExternalCameraTrigger(const int status) override;

        // feedback: position, int, position in encoder counts
        virtual void OnGetPanPosition(const float pan) override;
        // feedback: status int 0  – successful, -1 – error
        virtual void OnSetPanPosition(const int status) override;

        // Starts camera image acquisition.
        // feedback: status int 0  – successful, -1 – error
        virtual void OnStartCamera(const int status) override;
 
        // Stop camera live video
        // feedback: status int 0  – successful, -1 – error
        virtual void OnStopCamera(const int status) override;

        // feedback:
        // gdop         double      Geometric Dilution Of Precision
        // pdop         double      Position Dilution Of Precision
        // gps_sat      int         number of GPS satellites
        // glonass_sat  int         number of GLONASS satellites
        virtual void OnGetGpsStatus(const OPTECH_POLARIS_API::SPlsGpsStatus gps_status) override;
 
        // Get GPS position (ECEF).
        // feedback:
        // x_coord         double         x coordinate
        // y_coord         double         y coordinate
        // z_coord         double         z coordinate
        virtual void OnGetGpsPositionECEF(const OPTECH_POLARIS_API::SPlsPositionD gps_position) override;
 
        // Gets GPS position (geodetic)
        // feedback:
        // latitude        string         latitude
        // longitude       string         longitude
        // altitude        string         altitude
        virtual void OnGetGpsPositionGeodetic(const OPTECH_POLARIS_API::SPlsPosGeodeticF) override;
 
        // Gets current compass reading
        // heading   float   compass value , 0 - 360
        // x         int     x raw reading
        // y         int     y raw reading
        // z         int     z raw reading
        virtual void OnGetCompass(const OPTECH_POLARIS_API::SPlsCompass compass_read) override;
 
        // Gets current inclinometer reading
        // x_incli         int    x inclinometer reading in counts
        // y_incli         int    y inclinometer reading in counts
        // temperature     int    temperature sensor reading in counts
        virtual void OnGetInclinometer(const OPTECH_POLARIS_API::SPlsInclinometer incli_read) override;
 
        // Gets wireless radio mode whether on or off
        // feedback:
        // mode: int, 0  – disabled (radio off)     1 –  enabled (radio on)  -1 - unknown
        virtual void OnGetWirelessRadioMode(const int wireless_mode) override {};
 
        // Enables or disables wireless radio, 0 – disable 1 – enable wireless
        // feedback: status int 0  – successful, -1 – error
        virtual void OnSetWirelessRadioMode(const int status) override {};
 
        // Gets Ethernet mode whether DHCP client or server
        // feedback: mode, int, 0 – DHCP server  1 – DHCP client
        virtual void OnGetEthernetMode(const int eth_mode) override {};
 
        //Sets Ethernet as DHCP server or DHCP client, 0 – DHCP server, 1 – DHCP client
        // feedback: setting status, int, 0 – successful, -1 – error
        virtual void OnSetEthernetMode(const int status) override {};
 
        //Gets the rasterized view of a scan
        // feedback: image, byte array, raster view of scan in jpeg format 
        virtual void OnGetScanRasterView(const unsigned char* rasterData, const int dataBufferSize) override;
 
        //Gets the rasterized view of all the scans in the survey
        // feedback: image, byte array, raster view of scan in jpeg format 
        // virtual void OnGetSurveyRasterView(const unsigned char* image_buf, const int bufSize) override; //  removed as the control API must not implement this message
 
        //Gets a single camera image associated with a scan. 
        // index, int, image index
        // feedback: image, byte array, actual image in jpg format
        virtual void OnGetScanCameraImage(const int image_index, const unsigned char* image_buf, const int bufSize) override {};
 
        //Gets a list of surveys in the current project context
        // feedback: nitems, int, total number of items in the list
        // list string concatenated names of stored surveys 
        // feedback:
        // num_names, number of names in the array
        // array_names, string array, names of surveys. each string is 260 bytes.
        virtual void OnListSurveys(const int num_names, const OPTECH_POLARIS_API::SPlsFileName* array_names) override {};
 
        //Deletes all files (image, scan data, etc) associated with a survey 
        // feedback: status int 0  – successful, -1 – error
        virtual void OnDeleteSurvey(const int status) override {};
 
        //to copy survey data to an external USB storage.
        // feedback: status int 0  – successful, -1 – error
        virtual void OnExportSurvey(const int status) override {};
 
        //to add a new scan task with the specified parameters
        // feedback: status int 0  – successful, -1 – error
        virtual void OnAddScanRoi(const int roiIndex, const int status) override {};
 
        // Sets a flag to indicate whether camera image(s) from the internal, 
        // external or both cameras should be collected for the current survey
        // feedback: status int 0  – successful, -1 – error
        virtual void OnSetSurveyCamFlag(const int status) override;
 
        // estimates scan time based on selected scan parameters
        // feedback: estimate survey time in seconds, zero if there is no ROI
        virtual void OnGetSurveyTimeEstimate(const int seconds) override;
 
        // Sets occupy point for a survey
        // feedback: status int 0  – successful, -1 – error
        virtual void OnSetSurveyOccupyPoint(const int status) override {};
 
        // Gets survey detail information contained in the metadata.
        // feedback: meta data, byte array, contents of survey.xml file
        virtual void OnGetSurveyMetadata(const unsigned char* meta_data, const unsigned int dataSize) override;
 
        virtual void OnSetScannerSpeed(const int status) override;
        virtual void OnSetScanParameters(const int roiIndex, const int status) override;
        virtual void OnGetScannerSpeed(const int scannerSpeed) override;
        virtual void OnGetLaserTemperatures(const int status, const float boosterTemp, const float prepumpTemp, const float seedTemp, const float caseTemp) override;
        virtual void OnGetScannerType(const int scannerType) override;
 
        // Starts survey
        // feedback: status int 0  – successful, -1 – error
        virtual void OnSurveyStart(const int status) override;
 
        // will terminate a survey in progress
        // feedback: status int 0  – successful, -1 – error
        virtual void OnSurveyStop(const int status) override;
 
        // Pauses a survey in progress
        // feedback: status int 0  – successful, -1 – error
        virtual void OnSurveyPause(const int status) override;
 
        // Resumes a paused survey
        // feedback: status int 0  – successful, -1 – error
        virtual void OnSurveyResume(const int status) override;
 
        // To query current scan index during survey
        // feedback: index, int, current scan index greater or equal to 1 if in Survey state or
        // -1 if system is not in Survey state
        virtual void OnGetScanIndex(const int scan_index) override {};
 
        // Lists all stored scan presets by name
        // feedback:
        // num_names, number of names in the array
        // array_names, string array, names of targets. each string is 260 bytes.
        virtual void OnListScanPresets(const int num_names, const OPTECH_POLARIS_API::SPlsFileName* array_names) override {};
 
        // Gets scan parameters associated with the specified scan preset name.
        // pan_start    int horizontal field of view, start of pan position in encoder counts
        // pan_stop     int horizontal field of view, end of pan position in encoder counts
        // galvo_start  int vertical field of view, start of galvo position in encoder counts
        // galvo_stop   int vertical field of view, end of galvo position in encoder counts
        // galvo_speed  int galvo scanner speed in Hz
        // pan_speed    int pan base speed in Hz (tbd)
        // prf          int laser prf in KHz
        // attenuator   int attenuator position, 0 – no attenuator, 1 – use attenuator 1, 2 – use attenuator 2
        // int_cam_flag int flag to indicate if camera image from the internal camera is collected with the scan   0 – without image     1 – with image
        // ext_cam_flag int flag to indicate if camera image from the external camera is collected with the scan    0 – without image     1 – with image
        virtual void OnGetScanPreset(char* xml_file/*const SPlsScanPreset*/, const int file_size) override {};
 
 
        // Creates a new survey directory for storing survey files such as 
        // scan data, gps data, camera images, etc
        // feedback: status int 0  – successful, -1 – error
        virtual void OnAddNewSurvey(const int status) override {};


        virtual void OnListProject(const int num_names, const OPTECH_POLARIS_API::SPlsFileName* array_names) override {};
 
        // Imports external camera configuration file. filename, <camera_name>.xml
        // feedback: status int 0  – successful, -1 – error
        virtual void OnExternalCameraConfigImport(const int status) override {};
 
        // Sets project current context so all subsequent messages that require a project name 
        // are within this context.
        // feedback: status int 0 – complete -1 – error
        virtual void OnSetProjectContext(const int status) override;
 
        // Gets project current context  
        // feedback: status int 0 – complete -1 – error
        virtual void OnGetProjectContext(const OPTECH_POLARIS_API::SPlsFileName* projectContextName) override {};
 
        // Sets plan current context so all subsequent messages that require a plan name 
        // are within this context
        // status int 0 – success -1 – plan does not exist
        // virtual void OnSetPlanContext(const int status) override; // must be removed since it is not in the SCADA ICD rev 9.2.
 
        // lists stored plans by name
        // nitems, int, total number of plans in the list
        // array_names, string array, names of plans. each string is 260 bytes.
        virtual void OnListPlans(const int num_names, const OPTECH_POLARIS_API::SPlsFileName* array_names) override {};
 
        // Gets plan status
        // feedback:status int 0 – not started 1 – started but incomplete 2 - complete
        virtual void OnGetPlanStatus(const int status) override {};
 
        // Executes a plan
        // feedback: status int 0 – success -1 - error
        virtual void OnPlanStart(const int status) override {};
 
        // Imports a plan
        // feedback: status int 0 – success -1 - error
        virtual void OnPlanFileImport(const int status) override {};
 
        // Exports a plan, copies plan from internal disk storage and saves it to external USB storage.
        // feedback: status int 0 – success -1 - error
        virtual void OnPlanExport(const int status) override {};
 
        // Gets a list of stations from a plan
        // num_names, number of items in the list
        // array_names, string array, names of stations. each string is 260 bytes.
        virtual void OnGetPlanStations(const int num_names, const OPTECH_POLARIS_API::SPlsFileName* array_names) override;
 
        // Gets station status
        // status int 0 – complete 1 – incomplete
        virtual void OnGetPlanStationStatus(const int status) override {};
 
        // Gets a list of backsight/resection targets from an occupy station in a plan
        // num_names, number of items in the list
        //array_names, string array, names of targets. each string is 260 bytes.
        virtual void OnListPlanStationTargets(const int num_names, const OPTECH_POLARIS_API::SPlsFileName* array_names) override;
 
        // Creates a new backsight/resection target to associate with an occupy station
        // feedback: status int 0 – success -1 - error
        // virtual void OnSetPlanStationTarget(const int status) override; // No longer used since Scada ICD 9.2
 
        // Lists all stored coordinates by name
        // num_names, number of items in the list
        // array_names, string array, names of stored coordinates. each string is 260 bytes
        virtual void OnListCoordinates(const int num_names, const OPTECH_POLARIS_API::SPlsFileName* array_names) override;
 
        // Gets coordinates value associated with the specified coordinate’s name for the current project context. 
        // northing, double northing value
        // easting,  double easting value
        // up,       double up value
        virtual void OnGetCoordinates(const OPTECH_POLARIS_API::SPlsCoordinates coordinates) override;
 
        // Adds new coordinates
        // feedback: status int 0 – success -1 - error
        virtual void OnAddCoordinates(const int status) override {};
 
        // Get Ethernet and wireless IP address.
        //feedback: eth_addr, string, Ethernet IP address
        //          wls_addr, string, wireless IP address
        virtual void OnGetIPAddress(const char* eth_addr, const char* wls_addr) override {};
 
        // OPOL-893
        virtual void OnAddCustomFovScanRoi(const int status) override {};
 
        // to force disconnection of remote controller
        // feedback: status int 0 – success -1 - error
        // virtual void OnDisconnectRemoteCtrl(const int status) override; // must be removed as the control API must not implement this message
 
        // Get system power source. System power source could be 
        // from external power supply, battery 1 or battery 2
        // feedback: source, int, 0 – external power  supply,  1 – battery 1,    2 – battery 2
        //           volts, float, external power supply voltage in volts
        //                or zero if powered from battery
        virtual void OnGetPowerSource(const int source, const float volts) override;
 
        // Synchronize system time with GPS time
        // feedback: status int 0 – success -1 - error
        virtual void OnSyncSystemTimeWithGPS(const int status) override {};
 
        // update ICD r6
        // to get list of stored external camera configuration files by name
        // feedback:
        // num_names, number of items in the array
        // array_cfg_names, string, names of stored coordinates
        virtual void OnListExtCamCfgFile(const int num_names, const OPTECH_POLARIS_API::SPlsFileName* array_cfg_names) override {};
 
        // to delete the specified camera configuration file 
        virtual void OnDeleteExtCamCfgFile(const int status) override {};
        // to delete all added ROI’s
        virtual void OnClearSurvey(const int status) override {};
        // to delete plan file in the current project context
        // feedback: status int 0 – success -1 - error
        virtual void OnDeletePlan(const int status) override;
 
        // to Calculate estimated survey data size of all the added ROI’s
        // feedback: 
        // file_size, float, size in megabytes
        virtual void OnGetSurveySizeEstimate(const float file_size) override;
        // to copy all files (image, scan data, etc) associated with a project to 
        // an external USB storage device
        virtual void OnExportProj(const int status) override;
        // to delete all files (image, scan data, etc) associated with a project
        virtual void OnDeleteProj(const int status) override;
 
        virtual void OnGetProjectInfo(const float size, const int nSurveys) override;
        virtual void OnPresetImport(const int status) override;
        virtual void OnGetPlanStationGeorefType(const int type) override;
        virtual void OnPlanReset(const int status) override;
        virtual void OnExportCalAndConfigFile(const int status) override;
 
        // Changes SCADA operating mode between Normal mode and Engineering mode. Normal mode is 
        // for customer use while Engineering mode is for internal use
        // feedback: status int 0 – success -1 - error
        virtual void OnChangeOperatingMode(const int status) override;
 
        // control messages set 2
        // Gets list of stations in a plan 
        // feedback: list string concatenated names of stations within proximity of current GPS position
        virtual void OnListNearbyStations(const int num_names, const OPTECH_POLARIS_API::SPlsFileName* array_names) override;
 
        // Calculates relative location of a backsight/resection target
        // easting  double easting value
        // northing double northing value
        // up       double up value
        virtual void OnCalcTargetRelLocation(const int validFlag, const double range, const double panAngle, const double galvoAngle) override;
 
        // Calculates target centroid
        // feedback:
        // target centroid local X, Y, Z position, in meters
        // relative x, y position of centroid inside target scan bounds, expressed as a fraction
        virtual void OnCalcTargetCentroid(const OPTECH_POLARIS_API::SPlsPositionD centroid, const float rx, const float ry) override;
 
        // Calculates true heading by backsighting
        // home position heading in degrees in global coordinate frame
        // valid_flag - Added as Rev8 : 0 = data not valid, 1 = data is valid
        virtual void OnCalcBacksight(const int valid_flag, const float heading) override;
 
        // PositionAndOrientation feedback
        // instrument reference X, Y, Z position
        // roll, pitch, heading instrument orientation roll in degrees
        // stddev, float, standard deviation
        // residual, float list of residual, one for each target
        virtual void OnCalcResection(
            const OPTECH_POLARIS_API::SPlsPositionD position,
            const OPTECH_POLARIS_API::SPlsAttitudeF attitude,
            const float stddev,
            std::vector<float> residual
 
        ) override;
        virtual void OnAddTarget(const int status) override;
 
        // retro targets list
        // x1, x2, float, retro target horizontal bounding box position in degrees
        // y1, y2, float, retro target vertical bounding box position in degrees
        virtual void OnFindRetroTarget(OPTECH_POLARIS_API::SPlsRetroTargetPosn retro, std::vector<OPTECH_POLARIS_API::SPlsRetroTargetData> targetData) override;
 
        // centroid_local_pos, double, target centroid local position, in meters
        // rx   float   relative position of centroid inside target scan bounds, expressed as a fraction
        // ry   float   relative position of centroid inside target scan bounds, expressed as a fraction
        virtual void OnCalcManualCentroid(const OPTECH_POLARIS_API::SPlsPositionD centroid_local_pos, const float rx, const float ry) override;
 
        // control message set 3. Messages used by Engineering OI (internal test utility).
        // Queries current attenuator setting
        // feedback: attenuator int attenuator setting: 0 – no attenuator, 1 – use, 2 – use attenuator 2
         // virtual void OnGetAttenuator(const int attenuator) override; no longer exists in SCADA ICD rev 9.2
 
        // Set attenuator setting, 0 – no attenuator, 1 – use attenuator1, 2 – use attenuator2
        // feedback: status int 0 – success - 1 – error
        virtual void OnSetAttenuator(const int status) override;

        //virtual void OnSetScanHFov(const int status) override;

        //virtual void OnSetScanVFov(const int status) override;

        //virtual void OnSetScanDensity(const int status) override;
 
        // Changes Laser PRF, meanwhile changes range mode to short, medium or long
        // unit in KHz
        // feedback: status int 0 – success -1 - error
        virtual void OnSetLaserPRF(const int status) override;
 
        // Enable or disable laser so it starts/stops firing
        // feedback: status int 0 – success -1 - error
        virtual void OnSetLaserOn(const int status) override;
 
        // Sets tilt (elevation stage) current position, unit in encoder counts
        // feedback: status int 0 – success -1 - error
        // virtual void OnSetTiltPosition(const int status) override; // Not used since Scada ICD 9.2
 
        // Gets galvo and tilt's current positions
        // feedback: position int position in encoder counts
        virtual void OnGetGalvoPosition(const int galvo_position) override;
 
        // Sets galvo desired position
        // feedback: position int position in encoder counts
        virtual void OnSetGalvoPosition(const int status) override;

        // feedback: status int 0 – success - 1 – error
        virtual void OnSetPowerSource(const int status) override;
 
        // Save raw data.
        // status: 0 - success, -1 - error
        virtual void OnSaveRawData(const int status) override;
 
        // Data messages
        // err_code, int, error code
        // msg_id, int, the message caused the error
        // or zero if occurred on the system
        virtual void OnDatErrorMessage(const int err_code, const int msg_id, const int int_err_code) override;
 
        //msg_code, int, message code
        virtual void OnDatGeneralMessage(const int msg_code) override;
 
        // tasks, int, total number of tasks to be performed, a task can be an ROI scan or camera image capture
        // current_task, int, current task being performed
        // current_progress, float progress of current task (0 to 100 %)
        virtual void OnDatSurveyProgress(const int tasks, const int current_task, const float current_progress, const __int64 survey_size) override;
 
        // scan index, int, current scan index being scanned
        virtual void OnDatStartScan(const int scan_index) override;
 
        // scan index, int, current scan index being scanned
        virtual void OnDatEndScan(const int scan_index) override;
 
        // data, byte array, lidar data
        virtual void OnDatScan(const unsigned char* data_buf, const int data_size) override;
 
        // data, byte array, lidar data header
        virtual void OnDatScanHeader(const unsigned char* rawHeaderBuffer, const int bufferSize) override;
 
        // data, byte array, lidar data header
        virtual void OnDatPpsRecord(const unsigned char* rawPpsBuffer, const int bufferSize) override;
 
        // data, byte array, lidar data header
        virtual void OnDatNmeaRecord(const unsigned char* rawNmeaBuffer, const int bufferSize) override;
 
        // cam_img, byte array, camera image data in JPEG format
        virtual void OnDatCamera(const int cam_number, const unsigned char* img_buf, const int data_size) override;
 
        // flag, int, 0 – extcamera.dat, 1 – intcamera.dat, 2 – serial.dat, 3 – tbd
        // contents, byte array, contents of the file indicated in the flag parameter
        virtual void OnDatDatafile(const int flag, const unsigned char* data_buf, const int data_size) override;
 
 
        //Notified any alerts during processing. This function could be invoked from multiple threads simultaneously,
        //thus client needs to make their implementation thread safe.
        virtual void Alert(std::string alert) override;
 
        int waitForCommand(TimeSpan timeout = TimeSpan(30.0));
    private:
        void initConnection();
        OPTECH_POLARIS_API::IPolarisControl* m_polaris_control;
        Motor* m_scope = nullptr;
        Motor* m_head = nullptr;
        Connection* m_connection = nullptr;
        OptechScannerPositionSensor* m_position_sensor = nullptr;
        RangeSensor* m_range_sensor = nullptr;
        TemperatureSensor* m_booster_temp = nullptr;
        TemperatureSensor* m_prepump_temp = nullptr;
        TemperatureSensor* m_seed_temp = nullptr;
        TemperatureSensor* m_case_temp = nullptr;
        Battery* m_battery_1 = nullptr;
        Battery* m_battery_2 = nullptr;
        Battery* m_power_source = nullptr;
        GPSSensor* m_gps_sensor;
        OrientationSensor* m_orientation_sensor = nullptr; 
        OPTECH_POLARIS_API::SPlsScanROI m_survey_parameters;
        Time m_last_standard_refresh;
        Time m_last_scan_update_time;
        TimeSpan m_scan_time_estimate = Constant<TimeSpan>::NaN;
        fltp04 m_scan_progress = Constant<fltp04>::NaN;
        sint04 m_last_return = Constant<sint04>::NaN;
        bool m_is_initializing_scan = false;
        bool m_is_valid = false;
        bool m_is_init = false;
        bool m_use_internal_camera = false;
        bool m_use_external_camera = false;
        TimeSpan m_external_camera_interval = TimeSpan(1.0);
        PowerSource m_current_power_source;
    };
}
#endif