Example #1
0
 private void CheckASCOMPlatformVersion(object obj)
 {
     try {
         var version = ASCOMInteraction.GetPlatformVersion();
         if ((version.Major < 6) || (version.Major == 6 && version.Minor < 4))
         {
             Notification.ShowWarning(Locale.Loc.Instance["LblASCOMPlatformOutdated"]);
         }
     } catch (Exception) {
     }
 }
Example #2
0
        public override void GetEquipment()
        {
            Devices.Clear();

            Devices.Add(new DummyDevice(Locale.Loc.Instance["LblNoFocuser"]));

            try {
                foreach (IFocuser focuser in ASCOMInteraction.GetFocusers(profileService))
                {
                    Devices.Add(focuser);
                }
            } catch (Exception ex) {
                Logger.Error(ex);
            }

            Devices.Add(new UltimatePowerboxV2(profileService));

            DetermineSelectedDevice(profileService.ActiveProfile.FocuserSettings.Id);
        }
Example #3
0
        public override void GetEquipment()
        {
            Devices.Clear();

            Devices.Add(new DummyDevice(Locale.Loc.Instance["LblNoRotator"]));

            try {
                foreach (IRotator rotator in ASCOMInteraction.GetRotators(profileService))
                {
                    Devices.Add(rotator);
                }
            } catch (Exception ex) {
                Logger.Error(ex);
            }

            Devices.Add(new ManualRotator(profileService));

            DetermineSelectedDevice(profileService.ActiveProfile.RotatorSettings.Id);
        }
Example #4
0
        public override void GetEquipment()
        {
            Devices.Clear();

            Devices.Add(new DummyDevice(Locale.Loc.Instance["LblWeatherNoSource"]));

            try {
                foreach (IWeatherData obsdev in ASCOMInteraction.GetWeatherDataSources(profileService))
                {
                    Devices.Add(obsdev);
                }
            } catch (Exception ex) {
                Logger.Error(ex);
            }

            Devices.Add(new OpenWeatherMap(this.profileService));
            Devices.Add(new UltimatePowerboxV2(profileService));

            DetermineSelectedDevice(profileService.ActiveProfile.WeatherDataSettings.Id);
        }
Example #5
0
        public override void GetEquipment()
        {
            Devices.Clear();

            Devices.Add(new DummyDevice(Locale.Loc.Instance["LblNoSwitch"]));

            /* ASCOM */
            try {
                foreach (ISwitchHub ascomSwitch in ASCOMInteraction.GetSwitches(profileService))
                {
                    Devices.Add(ascomSwitch);
                }
            } catch (Exception ex) {
                Logger.Error(ex);
            }

            /* PrimaLuceLab EAGLE */
            Devices.Add(new Eagle(profileService));

            /* Pegasus Astro Ultimate Powerbox V2 */
            Devices.Add(new UltimatePowerBoxV2(profileService));

            DetermineSelectedDevice(profileService.ActiveProfile.SwitchSettings.Id);
        }
Example #6
0
        public override void GetEquipment()
        {
            Devices.Clear();

            Devices.Add(new DummyDevice(Locale.Loc.Instance["LblNoFilterwheel"]));

            /*
             * FLI
             */
            try {
                Logger.Trace("Adding FLI filter wheels");
                List <string> fwheels = FLIFilterWheels.GetFilterWheels();

                if (fwheels.Count > 0)
                {
                    foreach (var entry in fwheels)
                    {
                        var fwheel = new FLIFilterWheel(entry, profileService);

                        if (!string.IsNullOrEmpty(fwheel.Name))
                        {
                            Logger.Debug($"Adding FLI Filter Wheel {fwheel.Id} (as {fwheel.Name})");
                            Devices.Add(fwheel);
                        }
                    }
                }
            } catch (Exception ex) {
                Logger.Error(ex);
            }

            /*
             * QHY - Integrated or 4-pin connected filter wheels only
             */
            try {
                Logger.Trace("Adding QHY integrated/4-pin filter wheels");
                List <string> fwheels = QHYFilterWheels.GetFilterWheels();

                if (fwheels.Count > 0)
                {
                    foreach (var entry in fwheels)
                    {
                        var fwheel = new QHYFilterWheel(entry, profileService);

                        if (!string.IsNullOrEmpty(fwheel.Name))
                        {
                            Logger.Debug($"Adding QHY Filter Wheel {fwheel.Id} (as {fwheel.Name})");
                            Devices.Add(fwheel);
                        }
                    }
                }
            } catch (Exception ex) {
                Logger.Error(ex);
            }

            /*
             * ASCOM devices
             */
            try {
                foreach (IFilterWheel fw in ASCOMInteraction.GetFilterWheels(profileService))
                {
                    Devices.Add(fw);
                }
            } catch (Exception ex) {
                Logger.Error(ex);
            }

            Devices.Add(new ManualFilterWheel(this.profileService));

            DetermineSelectedDevice(profileService.ActiveProfile.FilterWheelSettings.Id);
        }
Example #7
0
        public override void GetEquipment()
        {
            Devices.Clear();

            Devices.Add(new Model.DummyDevice(Locale.Loc.Instance["LblNoCamera"]));

            /* ASI */
            try {
                Logger.Trace("Adding ASI Cameras");
                for (int i = 0; i < ASICameras.Count; i++)
                {
                    var cam = ASICameras.GetCamera(i, profileService);
                    if (!string.IsNullOrEmpty(cam.Name))
                    {
                        Logger.Trace(string.Format("Adding {0}", cam.Name));
                        Devices.Add(cam);
                    }
                }
            } catch (Exception ex) {
                Logger.Error(ex);
            }

            /* Altair */
            try {
                Logger.Trace("Adding Altair Cameras");
                foreach (var instance in Altair.AltairCam.EnumV2())
                {
                    var cam = new AltairCamera(instance, profileService);
                    Devices.Add(cam);
                }
            } catch (Exception ex) {
                Logger.Error(ex);
            }

            /* Atik */
            try {
                Logger.Trace("Adding Atik Cameras");
                var atikDevices = AtikCameraDll.GetDevicesCount();
                Logger.Trace($"Cameras found: {atikDevices}");
                if (atikDevices > 0)
                {
                    for (int i = 0; i < atikDevices; i++)
                    {
                        var cam = new AtikCamera(i, profileService);
                        Devices.Add(cam);
                    }
                }
            } catch (Exception ex) {
                Logger.Error(ex);
            }

            /* FLI */
            try {
                Logger.Trace("Adding FLI Cameras");
                List <string> cameras = FLICameras.GetCameras();

                if (cameras.Count > 0)
                {
                    foreach (var entry in cameras)
                    {
                        var camera = new FLICamera(entry, profileService);

                        if (!string.IsNullOrEmpty(camera.Name))
                        {
                            Logger.Debug($"Adding FLI camera {camera.Id} (as {camera.Name})");
                            Devices.Add(camera);
                        }
                    }
                }
            } catch (Exception ex) {
                Logger.Error(ex);
            }

            /* QHYCCD */
            try {
                Logger.Trace("Adding QHYCCD Cameras");
                uint numCameras = QHYCameras.Count;

                if (numCameras > 0)
                {
                    for (uint i = 0; i < numCameras; i++)
                    {
                        var cam = QHYCameras.GetCamera(i, profileService);
                        if (!string.IsNullOrEmpty(cam.Name))
                        {
                            Logger.Debug($"Adding QHY camera {i}: {cam.Id} (as {cam.Name})");
                            Devices.Add(cam);
                        }
                    }
                }
            } catch (Exception ex) {
                Logger.Error(ex);
            }

            /* ToupTek */
            try {
                Logger.Debug("Adding ToupTek Cameras");
                foreach (var instance in ToupTek.ToupCam.EnumV2())
                {
                    var cam = new ToupTekCamera(instance, profileService);
                    Devices.Add(cam);
                }
            } catch (Exception ex) {
                Logger.Error(ex);
            }

            /* Omegon */
            try {
                Logger.Debug("Adding Omegon Cameras");
                foreach (var instance in Omegon.Omegonprocam.EnumV2())
                {
                    var cam = new OmegonCamera(instance, profileService);
                    Devices.Add(cam);
                }
            } catch (Exception ex) {
                Logger.Error(ex);
            }

            /* ASCOM */
            try {
                foreach (ICamera cam in ASCOMInteraction.GetCameras(profileService))
                {
                    Devices.Add(cam);
                }
            } catch (Exception ex) {
                Logger.Error(ex);
            }

            /* CANON */
            try {
                IntPtr cameraList;
                try {
                    EDSDKLocal.Initialize();
                } catch (Exception ex) {
                    Logger.Error(ex);
                    Utility.Notification.Notification.ShowError(ex.Message);
                }

                uint err = EDSDK.EdsGetCameraList(out cameraList);
                if (err == EDSDK.EDS_ERR_OK)
                {
                    int count;
                    err = EDSDK.EdsGetChildCount(cameraList, out count);

                    for (int i = 0; i < count; i++)
                    {
                        IntPtr cam;
                        err = EDSDK.EdsGetChildAtIndex(cameraList, i, out cam);

                        EDSDK.EdsDeviceInfo info;
                        err = EDSDK.EdsGetDeviceInfo(cam, out info);

                        Logger.Trace(string.Format("Adding {0}", info.szDeviceDescription));
                        Devices.Add(new EDCamera(cam, info, profileService));
                    }
                }
            } catch (Exception ex) {
                Logger.Error(ex);
            }

            /* NIKON */
            try {
                Devices.Add(new NikonCamera(profileService, telescopeMediator));
            } catch (Exception ex) {
                Logger.Error(ex);
            }

            Devices.Add(new Model.MyCamera.FileCamera(profileService, telescopeMediator));
            Devices.Add(new Model.MyCamera.Simulator.SimulatorCamera(profileService, telescopeMediator));

            DetermineSelectedDevice(profileService.ActiveProfile.CameraSettings.Id);
        }