public void init()
        {
            if (initialized)
            {
                return;
            }

            och = new ObservingConditions("ASCOM.OCH.ObservingConditions");
            if (tl == null)
            {
                tl = new TraceLogger("", "Wise40.SafeToOpen");
            }
            name              = "Wise40 SafeToOpen";
            driverID          = Const.wiseSafeToOperateDriverID;
            driverDescription = string.Format("ASCOM Wise40.SafeToOpen v{0}", version.ToString());

            if (_profile == null)
            {
                _profile = new Profile()
                {
                    DeviceType = "SafetyMonitor"
                };
            }

            humiditySensor          = new HumiditySensor(this);
            windSensor              = new WindSensor(this);
            sunSensor               = new SunSensor(this);
            cloudsSensor            = new CloudsSensor(this);
            rainSensor              = new RainSensor(this);
            humanInterventionSensor = new HumanInterventionSensor(this);
            _sensors = new List <Sensor>()
            {
                windSensor,
                cloudsSensor,
                rainSensor,
                humiditySensor,
                sunSensor,
                humanInterventionSensor
            };

            tl.Enabled = debugger.Tracing;
            tl.LogMessage("SafetyMonitor", "Starting initialisation");

            _connected = false;

            novas31    = new NOVAS31();
            astroutils = new AstroUtils();
            ascomutils = new Util();

            siteLatitude  = ascomutils.DMSToDegrees("30:35:50.43");
            siteLongitude = ascomutils.DMSToDegrees("34:45:43.86");
            siteElevation = 882.9;
            novas31.MakeOnSurface(siteLatitude, siteLongitude, siteElevation, 0.0, 0.0, ref onSurface);
            novas31.MakeObject(0, Convert.ToInt16(Body.Sun), "Sun", new CatEntry3(), ref Sun);

            ReadProfile(); // Read device configuration from the ASCOM Profile store
            initialized = true;

            tl.LogMessage("SafetyMonitor", "Completed initialisation");
        }
Exemple #2
0
        public T CreateDeviceInstance <T>(DeviceConfiguration configuration) where T : IDevice
        {
            Type deviceType = typeof(T);

            switch (deviceType.Name)
            {
            case nameof(FilterWheel):
                IDevice device = new FilterWheel(configuration, _clientTransactionIdGenerator);
                return((T)device);

            case nameof(SafetyMonitor):
                IDevice safetyMonitor = new SafetyMonitor(configuration, _clientTransactionIdGenerator);
                return((T)safetyMonitor);

            case nameof(Dome):
                IDevice dome = new Dome(configuration, _clientTransactionIdGenerator);
                return((T)dome);

            case nameof(Camera):
                IDevice camera = new Camera(configuration, _clientTransactionIdGenerator);
                return((T)camera);

            case nameof(Focuser):
                IDevice focuser = new Focuser(configuration, _clientTransactionIdGenerator);
                return((T)focuser);

            case nameof(ObservingConditions):
                IDevice observingConditions = new ObservingConditions(configuration, _clientTransactionIdGenerator);
                return((T)observingConditions);

            case nameof(Rotator):
                IDevice rotator = new Rotator(configuration, _clientTransactionIdGenerator);
                return((T)rotator);

            case nameof(Switch):
                IDevice @switch = new Switch(configuration, _clientTransactionIdGenerator);
                return((T)@switch);

            case nameof(Telescope):
                IDevice telescope = new Telescope(configuration, _clientTransactionIdGenerator);
                return((T)telescope);

            default:
                throw new InvalidOperationException($"Type {deviceType.Name} is not supported");
            }
        }
Exemple #3
0
        private void RefreshWeather()
        {
            if (groupBoxWeather.Visible)
            {
                try
                {
                    ObservingConditions oc = wisesite.observingConditions;

                    groupBoxWeather.Text = string.Format(" {0} v{1} ", oc.Name, oc.DriverVersion);
                    labelAgeValue.Text   = ((int)Math.Round(oc.TimeSinceLastUpdate(""), 2)).ToString() + "sec";

                    double d = oc.CloudCover;
                    if (d == 0.0)
                    {
                        labelCloudCoverValue.Text = "Clear";
                    }
                    else if (d == 50.0)
                    {
                        labelCloudCoverValue.Text = "Cloudy";
                    }
                    else if (d == 90.0)
                    {
                        labelCloudCoverValue.Text = "VeryCloudy";
                    }
                    else
                    {
                        labelCloudCoverValue.Text = "Unknown";
                    }

                    labelDewPointValue.Text  = oc.DewPoint.ToString() + "°C";
                    labelSkyTempValue.Text   = oc.SkyTemperature.ToString() + "°C";
                    labelTempValue.Text      = oc.Temperature.ToString() + "°C";
                    labelHumidityValue.Text  = oc.Humidity.ToString() + "%";
                    labelPressureValue.Text  = oc.Pressure.ToString() + "mB";
                    labelRainRateValue.Text  = (oc.RainRate > 0.0) ? "Wet" : "Dry";
                    labelWindSpeedValue.Text = oc.WindSpeed.ToString() + "m/s";
                    labelWindDirValue.Text   = oc.WindDirection.ToString() + "°";
                }
                catch (ASCOM.PropertyNotImplementedException e)
                {
                    debugger.WriteLine(Debugger.DebugLevel.DebugLogic, "OC: exception: {0}", e.Message);
                }
            }
        }
        private void Connect()
        {
            if (!String.IsNullOrEmpty(observingConditionsID))
            {
                try
                {
                    oObservingConditions = new ObservingConditions(observingConditionsID)
                    {
                        Connected = true
                    };
                }
                catch (Exception ex)
                {
                    String msg = ex.Message;
                    if (ex.InnerException != null)
                    {
                        msg += " - " + ex.InnerException.Message;
                    }
                    MessageBox.Show(string.Format("Connect failed with error {0}", msg));
                }
            }

            if (!String.IsNullOrEmpty(safetyMonitorID))
            {
                try
                {
                    oSafetyMonitor = new SafetyMonitor(safetyMonitorID)
                    {
                        Connected = true
                    };
                }
                catch (Exception ex)
                {
                    String msg = ex.Message;
                    if (ex.InnerException != null)
                    {
                        msg += " - " + ex.InnerException.Message;
                    }
                    MessageBox.Show(string.Format("Connect failed with error {0}", msg));
                }
            }
        }
Exemple #5
0
        public async Task RefreshAsync_SendValidRequest()
        {
            //Arrange
            string       commandName       = "refresh";
            IRestRequest sentRequest       = null;
            var          commandSenderMock = new Mock <ICommandSender>();

            commandSenderMock
            .Setup(x => x.ExecuteRequestAsync <CommandResponse>(It.IsAny <string>(), It.IsAny <RestRequest>()))
            .Callback((string baseUrl, IRestRequest request) => sentRequest = request)
            .Returns(Task.FromResult(new CommandResponse()));
            var observingConditions = new ObservingConditions(_deviceConfiguration, commandSenderMock.Object);

            //Act
            await observingConditions.RefreshAsync();

            //Assert
            Assert.Equal(Method.PUT, sentRequest.Method);
            AssertCommonParameters(sentRequest.Parameters, _deviceConfiguration, commandName);
        }
Exemple #6
0
        public void GetWindSpeed_SendValidRequest()
        {
            //Arrange
            string       commandName       = "windspeed";
            IRestRequest sentRequest       = null;
            var          commandSenderMock = new Mock <ICommandSender>();

            commandSenderMock
            .Setup(x => x.ExecuteRequest <DoubleResponse>(It.IsAny <string>(), It.IsAny <RestRequest>()))
            .Callback((string baseUrl, IRestRequest request) => sentRequest = request)
            .Returns(new DoubleResponse(1.0));
            var observingConditions = new ObservingConditions(_deviceConfiguration, commandSenderMock.Object);

            //Act
            observingConditions.GetWindSpeed();

            //Assert
            Assert.Equal(Method.GET, sentRequest.Method);
            AssertCommonParameters(sentRequest.Parameters, _deviceConfiguration, commandName);
        }
 private void Button_Click(object sender, RoutedEventArgs e)
 {
     if (oObservingConditions != null && oObservingConditions.Connected)
     {
         return;
     }
     try
     {
         observingConditionsID = ObservingConditions.Choose(observingConditionsID);
         oProfile.WriteValue(profileID, "observingsConditionID", observingConditionsID);
     }
     catch (Exception ex)
     {
         String msg = ex.Message;
         if (ex.InnerException != null)
         {
             msg += " - " + ex.InnerException.Message;
         }
         MessageBox.Show(string.Format("Choose failed with error {0}", msg));
     }
 }
Exemple #8
0
        public async Task GetTimeSinceLastUpdateAsync_SendValidRequest()
        {
            //Arrange
            string commandName             = "timesincelastupdate";
            string sensorNameParameterName = "SensorName";
            ObservingConditionSensorName sensorNameParameterValue = ObservingConditionSensorName.WindSpeed;
            IRestRequest sentRequest       = null;
            var          commandSenderMock = new Mock <ICommandSender>();

            commandSenderMock
            .Setup(x => x.ExecuteRequestAsync <DoubleResponse>(It.IsAny <string>(), It.IsAny <RestRequest>()))
            .Callback((string baseUrl, IRestRequest request) => sentRequest = request)
            .Returns(Task.FromResult(new DoubleResponse(1.0)));
            var observingConditions = new ObservingConditions(_deviceConfiguration, commandSenderMock.Object);

            //Act
            await observingConditions.GetTimeSinceLastUpdateAsync(sensorNameParameterValue);

            //Assert
            Assert.Equal(Method.GET, sentRequest.Method);
            AssertCommonParameters(sentRequest.Parameters, _deviceConfiguration, commandName);
            AssertParameter(sentRequest.Parameters, sensorNameParameterName, sensorNameParameterValue);
        }
Exemple #9
0
        public void GetSensorDescription_SendValidRequest()
        {
            //Arrange
            string commandName             = "sensordescription";
            string sensorNameParameterName = "SensorName";
            ObservingConditionSensorName sensorNameParameterValue = ObservingConditionSensorName.WindSpeed;
            IRestRequest sentRequest       = null;
            var          commandSenderMock = new Mock <ICommandSender>();

            commandSenderMock
            .Setup(x => x.ExecuteRequest <StringResponse>(It.IsAny <string>(), It.IsAny <RestRequest>()))
            .Callback((string baseUrl, IRestRequest request) => sentRequest = request)
            .Returns(new StringResponse("test"));
            var observingConditions = new ObservingConditions(_deviceConfiguration, commandSenderMock.Object);

            //Act
            observingConditions.GetSensorDescription(sensorNameParameterValue);

            //Assert
            Assert.Equal(Method.GET, sentRequest.Method);
            AssertCommonParameters(sentRequest.Parameters, _deviceConfiguration, commandName);
            AssertParameter(sentRequest.Parameters, sensorNameParameterName, sensorNameParameterValue);
        }
Exemple #10
0
        public void SetAveragePeriod_SendValidRequest()
        {
            //Arrange
            string       commandName          = "averageperiod";
            string       periodParameterName  = "AveragePeriod";
            double       periodParameterValue = 2;
            IRestRequest sentRequest          = null;
            var          commandSenderMock    = new Mock <ICommandSender>();

            commandSenderMock
            .Setup(x => x.ExecuteRequest <CommandResponse>(It.IsAny <string>(), It.IsAny <RestRequest>()))
            .Callback((string baseUrl, IRestRequest request) => sentRequest = request)
            .Returns(new CommandResponse());
            var observingConditions = new ObservingConditions(_deviceConfiguration, commandSenderMock.Object);

            //Act
            observingConditions.SetAveragePeriod(periodParameterValue);

            //Assert
            Assert.Equal(Method.PUT, sentRequest.Method);
            AssertCommonParameters(sentRequest.Parameters, _deviceConfiguration, commandName);
            AssertParameter(sentRequest.Parameters, periodParameterName, periodParameterValue);
        }
Exemple #11
0
        public static void initOCH()
        {
            if (och_initialized)
            {
                return;
            }

            try
            {
                och           = new ObservingConditions("ASCOM.OCH.ObservingConditions");
                och.Connected = true;
                lastOCFetch   = DateTime.Now;
            }
            catch (Exception ex)
            {
                #region debug
                debugger.WriteLine(Debugger.DebugLevel.DebugLogic, "Could not connect to OCH: {0}", ex.Message);
                #endregion
                och = null;
            }

            och_initialized = true;
        }
        public void RefreshDisplay()
        {
            //if (!panelControls.Visible)
            //    return;

            DateTime now = DateTime.Now;
            DateTime utc = now.ToUniversalTime();

            ASCOM.Utilities.Util u = new Utilities.Util();

            labelDate.Text          = utc.ToLongDateString();
            labelLTValue.Text       = now.TimeOfDay.ToString(@"hh\hmm\mss\.f\s");
            labelUTValue.Text       = utc.TimeOfDay.ToString(@"hh\hmm\mss\.f\s");
            labelSiderealValue.Text = wisesite.LocalSiderealTime.ToString();

            labelRightAscensionValue.Text = Angle.FromHours(wisetele.RightAscension).ToNiceString();
            labelDeclinationValue.Text    = Angle.FromDegrees(wisetele.Declination).ToNiceString();
            labelHourAngleValue.Text      = Angle.FromHours(wisetele.HourAngle, Angle.Type.HA).ToNiceString();

            labelNewRA.Text         = "";
            labelNewRARadians.Text  = Angle.FromHours(wisetele.RightAscension).Radians.ToString();
            labelNewDec.Text        = "";
            labelNewDecRadians.Text = Angle.FromDegrees(wisetele.Declination).Radians.ToString();

            labelAltitudeValue.Text = Angle.FromDegrees(wisetele.Altitude).ToNiceString();
            labelAzimuthValue.Text  = Angle.FromDegrees(wisetele.Azimuth).ToNiceString();

            labelHAEncValue.Text  = wisetele.HAEncoder.Value.ToString();
            labelDecEncValue.Text = wisetele.DecEncoder.Value.ToString();

            axisValue.Text = wisetele.HAEncoder.AxisValue.ToString();
            wormValue.Text = wisetele.HAEncoder.WormValue.ToString();

            string why;

            if (wisesite.computerControl == null)
            {
                labelTelescopeComputerControl.ForeColor = Color.Yellow;
                why = "Cannot read the computer control switch!";
            }
            else if (wisesite.computerControl.IsSafe)
            {
                labelTelescopeComputerControl.ForeColor = Color.Green;
                why = "Computer control is enabled.";
            }
            else
            {
                labelTelescopeComputerControl.ForeColor = Color.Red;
                why = why = "Computer control switch is OFF!";
            }
            toolTip.SetToolTip(labelTelescopeComputerControl, why);

            if (wisesite.safeToOpen == null)
            {
                labelTelescopeSafeToOpen.ForeColor = Color.Yellow;
                why = "Cannot connect to the safeToOpen driver!";
            }
            else if (wisesite.safeToOpen.IsSafe)
            {
                labelTelescopeSafeToOpen.ForeColor = Color.Green;
                why = "Conditions are safe to open the dome.";
            }
            else
            {
                labelTelescopeSafeToOpen.ForeColor = Color.Red;
                why = wisesite.safeToOpen.CommandString("unsafeReasons", false);
            }
            toolTip.SetToolTip(labelTelescopeSafeToOpen, why);

            if (wisesite.safeToImage == null)
            {
                labelTelescopeSafeToImage.ForeColor = Color.Yellow;
                why = "Cannot connect to the safeToImage driver!";
            }
            else if (wisesite.safeToImage.IsSafe)
            {
                labelTelescopeSafeToImage.ForeColor = Color.Green;
                why = "Conditions are safe to image.";
            }
            else
            {
                labelTelescopeSafeToImage.ForeColor = Color.Red;
                why = wisesite.safeToImage.CommandString("unsafeReasons", false);
            }
            toolTip.SetToolTip(labelTelescopeSafeToImage, why);

            checkBoxPrimaryIsActive.Checked   = wisetele.AxisIsMoving(TelescopeAxes.axisPrimary);
            checkBoxSecondaryIsActive.Checked = wisetele.AxisIsMoving(TelescopeAxes.axisSecondary);
            string activeSlewers = wisetele.slewers.ToString();

            checkBoxSlewingIsActive.Text     = (activeSlewers == string.Empty) ? "Slewing" : "Slewing (" + activeSlewers + ")";
            checkBoxSlewingIsActive.Checked  = wisetele.Slewing;
            checkBoxTrackingIsActive.Checked = wisetele.Tracking;

            WiseVirtualMotor m;

            m = null;
            if (wisetele.WestMotor.isOn)
            {
                m = wisetele.WestMotor;
            }
            else if (wisetele.EastMotor.isOn)
            {
                m = wisetele.EastMotor;
            }

            checkBoxPrimaryIsActive.Text = "Primary";
            if (m != null)
            {
                checkBoxPrimaryIsActive.Text += ": " + m.Name.Remove(m.Name.IndexOf('M')) + "@" +
                                                WiseTele.RateName(m.currentRate).Replace("rate", "");
            }

            m = null;
            if (wisetele.NorthMotor.isOn)
            {
                m = wisetele.NorthMotor;
            }
            else if (wisetele.SouthMotor.isOn)
            {
                m = wisetele.SouthMotor;
            }


            checkBoxSecondaryIsActive.Text = "Secondary";
            if (m != null)
            {
                checkBoxSecondaryIsActive.Text += ": " + m.Name.Remove(m.Name.IndexOf('M')) + "@" +
                                                  WiseTele.RateName(m.currentRate).Replace("rate", "");
            }

            checkBoxTrack.Checked = wisetele.Tracking;

            if (scopeBackgroundMover != null && scopeBackgroundMover.IsBusy)
            {
                TextBoxLog.Text = "Working ...";
            }

            if (resultsAvailable)
            {
                TextBoxLog.Clear();
                if (results.Count == 0)
                {
                    TextBoxLog.Text = "Cancelled by user!";
                }
                else
                {
                    TelescopeAxes axis = results[0].axis;

                    for (int i = 0; i < results.Count; i++)
                    {
                        TextBoxLog.Text += string.Format("[{0}]: ({2})\r\n{1}",
                                                         i, results[i].ToString(), results[i].cancelled ? "cancelled" : "completed");
                    }
                }
                resultsAvailable = false;
            }

            if (panelDome.Visible)
            {
                labelDomeAzimuthValue.Text       = domeSlaveDriver.Azimuth;
                labelDomeStatusValue.Text        = domeSlaveDriver.Status;
                labelDomeShutterStatusValue.Text = domeSlaveDriver.ShutterStatus;
                checkBoxVent.Checked             = WiseDome.Instance.Vent;
            }

            if (groupBoxWeather.Visible)
            {
                if (!wisesite.observingConditions.Connected)
                {
                    string nc = "???";

                    labelAgeValue.Text        = nc;
                    labelCloudCoverValue.Text = nc;
                    labelCloudCoverValue.Text = nc;
                    labelDewPointValue.Text   = nc;
                    labelSkyTempValue.Text    = nc;
                    labelTempValue.Text       = nc;
                    labelHumidityValue.Text   = nc;
                    labelPressureValue.Text   = nc;
                    labelRainRateValue.Text   = nc;
                    labelWindSpeedValue.Text  = nc;
                    labelWindDirValue.Text    = nc;
                }
                else
                {
                    try
                    {
                        ObservingConditions oc = wisesite.observingConditions;

                        labelAgeValue.Text = ((int)Math.Round(oc.TimeSinceLastUpdate(""), 2)).ToString() + "sec";

                        double d = oc.CloudCover;
                        if (d == 0.0)
                        {
                            labelCloudCoverValue.Text = "Clear";
                        }
                        else if (d == 50.0)
                        {
                            labelCloudCoverValue.Text = "Cloudy";
                        }
                        else if (d == 90.0)
                        {
                            labelCloudCoverValue.Text = "VeryCloudy";
                        }
                        else
                        {
                            labelCloudCoverValue.Text = "Unknown";
                        }

                        labelDewPointValue.Text  = oc.DewPoint.ToString() + "°C";
                        labelSkyTempValue.Text   = oc.SkyTemperature.ToString() + "°C";
                        labelTempValue.Text      = oc.Temperature.ToString() + "°C";
                        labelHumidityValue.Text  = oc.Humidity.ToString() + "%";
                        labelPressureValue.Text  = oc.Pressure.ToString() + "mB";
                        labelRainRateValue.Text  = (oc.RainRate > 0.0) ? "Wet" : "Dry";
                        labelWindSpeedValue.Text = oc.WindSpeed.ToString() + "m/s";
                        labelWindDirValue.Text   = oc.WindDirection.ToString() + "°";
                    }
                    catch (PropertyNotImplementedException e)
                    {
                        debugger.WriteLine(Debugger.DebugLevel.DebugLogic, "OC: exception: {0}", e.Message);
                    }
                }
            }

            if (panelFocuser.Visible)
            {
                labelFocusCurrentValue.Text = wisefocuser.position.ToString();;
            }
        }