Example #1
0
 public RCResponseReceivedEventArgs(int txChID, RC_CODES_Enum rcCmdID, double pTime_sec, double snr_db, double value, double azimuth)
 {
     TxChID       = txChID;
     RCCmdID      = rcCmdID;
     PropTime_sec = pTime_sec;
     SNR_db       = snr_db;
     Value        = value;
     Azimuth      = azimuth;
 }
Example #2
0
        private void PerformRCRequest()
        {
            if (isRCAutoQuery)
            {
                autoQueryIdx = (autoQueryIdx + 1) % autoQueryCodes.Length;
                RC_CODES_Enum queryID = autoQueryCodes[autoQueryIdx];

                Thread.Sleep(500);

                if (port.RCRequestQuery(rcRxChannelID, rcTxChannelID, queryID))
                {
                    OnTransactionStart();
                }
            }
        }
Example #3
0
        private void RC_ASYNC_IN_Parse(object[] parameters)
        {
            try
            {
                // IC_D2H_RC_ASYNC_IN     $PUWV5,rcCmdID,snr,[azimuth]
                RC_CODES_Enum rcCmdID = (RC_CODES_Enum)(int)parameters[0];
                double        snr     = doubleNullChecker(parameters[1]);
                double        azimuth = doubleNullChecker(parameters[2]);

                RCAsyncInReceived.Rise(this, new RCAsyncInReceivedEventArgs(rcCmdID, snr, azimuth));
            }
            catch (Exception ex)
            {
                OnInfoEvent(ex);
            }
        }
Example #4
0
        private void RC_TIMEOUT_Parse(object[] parameters)
        {
            try
            {
                // IC_D2H_RC_TIMEOUT      $PUWV4,txChID,rcCmdID
                int           txChID  = (int)parameters[0];
                RC_CODES_Enum rcCmdID = (RC_CODES_Enum)(int)parameters[1];

                IsWaitingRemote = false;

                RCTimeoutReceived.Rise(this, new RCTimeoutReceivedEventArgs(txChID, rcCmdID));
            }
            catch (Exception ex)
            {
                OnInfoEvent(ex);
            }
        }
Example #5
0
        public bool RCRequestQuery(int txChID, int rxChID, RC_CODES_Enum cmdID)
        {
            if (!IsWaitingRemote)
            {
                var msg = NMEAParser.BuildProprietarySentence(ManufacturerCodes.UWV, "2", new object[]
                {
                    txChID,
                    rxChID,
                    (int)cmdID
                });

                return(TrySend(msg, ICs.IC_H2D_RC_REQUEST));
            }
            else
            {
                OnInfoEvent("Unable to perform a remote request due to waiting for previous");
                return(false);
            }
        }
Example #6
0
        private void CM_HEARD(object[] parameters)
        {
            // $PUWVL,b_id,b_lat,b_lon,b_toa_s,data_ID,dataValue,msr_dB
            try
            {
                int           b_id      = intNullChecker(parameters[0]);
                double        b_lat     = doubleNullChecker(parameters[1]);
                double        b_lon     = doubleNullChecker(parameters[2]);
                double        b_toa_s   = doubleNullChecker(parameters[3]);
                RC_CODES_Enum dataID    = (RC_CODES_Enum)intNullChecker(parameters[4]);
                double        dataValue = doubleNullChecker(parameters[5]);
                double        msr_dB    = doubleNullChecker(parameters[6]);

                throw new NotImplementedException();
            }
            catch (Exception ex)
            {
                OnInfoEvent(ex);
            }
        }
Example #7
0
        private void RC_RESPONSE_Parse(object[] parameters)
        {
            try
            {
                // IC_D2H_RC_RESPONSE     $PUWV3,txChID,rcCmdID,propTime_seс,snr,[value],[azimuth]
                int           txChID  = (int)parameters[0];
                RC_CODES_Enum rcCmdID = (RC_CODES_Enum)(int)parameters[1];
                double        pTime   = (double)parameters[2];
                double        snr     = (double)parameters[3];
                double        value   = doubleNullChecker(parameters[4]);
                double        azimuth = doubleNullChecker(parameters[5]);

                IsWaitingRemote = false;

                RCResponseReceived.Rise(this, new RCResponseReceivedEventArgs(txChID, rcCmdID, pTime, snr, value, azimuth));
            }
            catch (Exception ex)
            {
                OnInfoEvent(ex);
            }
        }
Example #8
0
 public RCTimeoutReceivedEventArgs(int txChID, RC_CODES_Enum rcCmdID)
 {
     TxChID  = txChID;
     RCCmdID = rcCmdID;
 }
Example #9
0
 public RCAsyncInReceivedEventArgs(RC_CODES_Enum rcCmdID, double snr_db, double azimuth)
 {
     RCCmdID = rcCmdID;
     SNR_db  = snr_db;
     Azimuth = azimuth;
 }
Example #10
0
 public RCAsyncInReceivedEventArgs(RC_CODES_Enum rcCmdID, double snr_db)
     : this(rcCmdID, snr_db, double.NaN)
 {
 }
Example #11
0
 public RCResponseReceivedEventArgs(int txChID, RC_CODES_Enum rcCmdID, double pTime_sec, double snr_db, double value)
     : this(txChID, rcCmdID, pTime_sec, snr_db, value, double.NaN)
 {
 }
Example #12
0
        private void inPort_NewNMEAMessage(object sender, NewNMEAMessageEventArgs e)
        {
            NMEASentence parsedSentence = null;
            bool         isParsed       = false;

            logger.Write(string.Format("{0} >> {1}", inPort.PortName, e.Message));

            try
            {
                parsedSentence = NMEAParser.Parse(e.Message);
                isParsed       = true;
            }
            catch (Exception ex)
            {
                ProcessException(ex, false);
            }

            if (isParsed && (parsedSentence is NMEAProprietarySentence))
            {
                NMEAProprietarySentence pResult = (parsedSentence as NMEAProprietarySentence);
                if ((pResult.Manufacturer == ManufacturerCodes.VLB) &&
                    (pResult.SentenceIDString == "L"))
                {
                    // $PVLBL,ownLat,ownLon,ownDepth,ownBatV,targetDataID,targetDataValue,propagationTime,MSR
                    double        ownLat  = doubleNullChecker(pResult.parameters[0]);
                    double        ownLon  = doubleNullChecker(pResult.parameters[1]);
                    double        ownDpt  = doubleNullChecker(pResult.parameters[2]);
                    double        ownBatV = doubleNullChecker(pResult.parameters[3]);
                    RC_CODES_Enum dataID  = (RC_CODES_Enum)Enum.ToObject(typeof(RC_CODES_Enum), intNullChecker(pResult.parameters[4]));
                    double        dataVal = doubleNullChecker(pResult.parameters[5]);
                    double        pTime   = doubleNullChecker(pResult.parameters[6]);
                    double        msr     = doubleNullChecker(pResult.parameters[7]);

                    if ((!double.IsNaN(ownLat)) && (!double.IsNaN(ownLon)))
                    {
                        ownLatitude.Value  = ownLat;
                        ownLongitude.Value = ownLon;

                        if (!is_g_updated)
                        {
                            g            = UCNLPhysics.PHX.PHX_GravityConstant_Calc(ownLat);
                            is_g_updated = true;
                            logger.Write(string.Format(CultureInfo.InvariantCulture, "Gravity constant updated: {0:F04} m/s^2", g));
                        }
                    }

                    if (!double.IsNaN(ownDpt))
                    {
                        ownDepth.Value = ownDpt;
                    }

                    if (!double.IsNaN(ownBatV))
                    {
                        ownBatteryVoltage.Value = ownBatV;
                    }

                    if (!double.IsNaN(pTime))
                    {
                        targetPTime.Value = pTime;
                    }

                    if (!double.IsNaN(msr))
                    {
                        targetMSR.Value = msr;
                    }

                    if (!double.IsNaN(dataVal))
                    {
                        if (dataID == RC_CODES_Enum.RC_DPT_GET)
                        {
                            targetDepth.Value = dataVal;
                        }
                        else if (dataID == RC_CODES_Enum.RC_TMP_GET)
                        {
                            targetTemperature.Value = dataVal;
                            TryUpdateSoundSpeed();
                        }
                        else if (dataID == RC_CODES_Enum.RC_BAT_V_GET)
                        {
                            targetBatVoltage.Value = dataVal;
                        }
                    }

                    if (!double.IsNaN(ownLat) && !double.IsNaN(ownLon) && !double.IsNaN(ownDpt))
                    {
                        if (!double.IsNaN(pTime) &&
                            targetDepth.IsInitializedAndNotObsolete)
                        {
                            vlblCore.TargetDepth = targetDepth.Value;
                            vlblCore.AddMeasurement(new VLBLTOAMeasurement(ownLat, ownLon, ownDpt, pTime * soundSpeedMps));

                            UpdateTrack("Measurements", new GeoPoint3D(ownLat, ownLon, ownDpt));
                        }
                        else
                        {
                            UpdateTrack("Rover", new GeoPoint3D(ownLat, ownLon, ownDpt));
                        }
                    }
                }
            }
        }