public void PulseGuide(GuideDirections direction, int duration)
{
if (TelescopeInfo.Connected)
{
Telescope.PulseGuide(direction, duration);
}
}
public void PulseGuide(GuideDirections Direction, int Duration)
{
this.isPulseGuiding = true;
if (this.isSlewing)
{
return;
}
switch (Direction)
{
case GuideDirections.guideNorth:
this.MoveAxis(TelescopeAxes.axisSecondary, 1);
break;
case GuideDirections.guideSouth:
this.MoveAxis(TelescopeAxes.axisSecondary, -1);
break;
case GuideDirections.guideEast:
this.MoveAxis(TelescopeAxes.axisPrimary, 1);
break;
case GuideDirections.guideWest:
this.MoveAxis(TelescopeAxes.axisPrimary, -1);
break;
}
HC.WaitForMilliseconds(Duration);
this.AbortSlew();
this.isPulseGuiding = false;
}
public static byte[] CommandPulseGuidingSpeed(GuideDirections dir, short time)
{
Byte dirByte;
switch (dir)
{
case GuideDirections.guideNorth:
dirByte = 1;
break;
case GuideDirections.guideSouth:
dirByte = 2;
break;
case GuideDirections.guideEast:
dirByte = 3;
break;
case GuideDirections.guideWest:
dirByte = 4;
break;
default:
dirByte = 0;
break;
}
byte[] r = new byte[4];
r[0] = (byte)CommandByte.PulseGuide;
r[1] = dirByte;
Array.Copy(BitConverter.GetBytes(IPAddress.HostToNetworkOrder(time)), 0, r, 2, 2);
return(r);
}
public void PulseGuide(GuideDirections direction, int duration)
{
string name = GetGuideDirectionName(direction);
LogActivityStart(ActivityMessageTypes.Commands, "PulseGuide {0} for {1} ms:", name, duration);
CheckDevice();
DateTime startTime = DateTime.Now;
Service.PulseGuide(direction, duration);
// Pulse guiding can be synchronous or asynchronous. If it is the former then
// we will not see IsPulseGuiding set to true.
if (Service.IsPulseGuiding)
{
Status.IsPulseGuiding = true;
DateTime endTime = startTime.AddMilliseconds(duration);
Task.Run(() => MonitorPulseGuidingTask(endTime));
}
else
{
Status.IsPulseGuiding = false;
}
LogActivityEnd(ActivityMessageTypes.Commands, Done);
}
//////////////////////////////////////////////
//PULSE GUIDE METHODS
//////////////////////////////////////////////
//
// Resumen:
// Moves the scope in the given direction for the given interval or time at
// the rate given by the corresponding guide rate property
//
// Parámetros:
// Direction:
// The direction in which the guide-rate motion is to be made
//
// Duration:
// The duration of the guide-rate motion (milliseconds)
//
// Excepciones:
// ASCOM.MethodNotImplementedException:
// If the method is not implemented and ASCOM.DeviceInterface.ITelescopeV3.CanPulseGuide
// is False
//
// ASCOM.InvalidValueException:
// If an invalid direction or duration is given.
//
// Comentarios:
// This method returns immediately if the hardware is capable of back-to-back
// moves, i.e. dual-axis moves. For hardware not having the dual-axis capability,
// the method returns only after the move has completed.
// NOTES: Raises an error if ASCOM.DeviceInterface.ITelescopeV3.AtPark is true.
// The ASCOM.DeviceInterface.ITelescopeV3.IsPulseGuiding property must be be
// True during pulse-guiding. The rate of motion for movements about the right
// ascension axis is specified by the ASCOM.DeviceInterface.ITelescopeV3.GuideRateRightAscension
// property. The rate of motion for movements about the declination axis is
// specified by the ASCOM.DeviceInterface.ITelescopeV3.GuideRateDeclination
// property. These two rates may be tied together into a single rate, depending
// on the driver's implementation and the capabilities of the telescope.
public void PulseGuide(GuideDirections Direction, int Duration)
{
tl.LogMessage("PulseGuide", "Direction => " + Direction);
tl.LogMessage("PulseGuide", "Duration => " + Duration + " msec.");
mTxPkt[1] = (byte)mSeq++;
mTxPkt[2] = (byte)Direction;
byte[] duration = BitConverter.GetBytes(Duration);
for (int i = 0; i < 4; ++i)
{
mTxPkt[3 + i] = duration[i];
}
if (Direction == GuideDirections.guideEast || Direction == GuideDirections.guideWest)
{
mTxPkt[7] = (byte)(mGuideRateRA * 10.0);
}
else
{
mTxPkt[7] = (byte)(mGuideRateDEC * 10.0);
}
if (mDevice != null)
{
for (int i = 0; i < 3; ++i)
{
mSender.Send(mTxPkt, mTxPkt.Length, mDevice);
}
}
else
{
mSender.Send(mTxPkt, mTxPkt.Length, new IPEndPoint(IPAddress.Broadcast, TX_PORT));
tl.LogMessage("PulseGuide", "WARNING: Opensynscan not discovered");
}
mLastCommandEndTime = DateTime.Now.AddMilliseconds(Duration);
}
public void PulseGuide(GuideDirections Direction, int Duration)
{
Axis.AxisControl theAxis = null;
Axis.AxisControl.Direction theDirection;
if (Direction == GuideDirections.guideEast || Direction == GuideDirections.guideWest)
{
theAxis = RaAxis;
}
else
{
theAxis = null;
}
if (Direction == GuideDirections.guideWest || Direction == GuideDirections.guideNorth)
{
theDirection = Axis.AxisControl.Direction.forward;
}
else
{
theDirection = Axis.AxisControl.Direction.backward;
}
if (theAxis != null)
{
theAxis.Pulse(theDirection, Duration);
}
}
public void PulseGuide(GuideDirections Direction, int Duration)
{
//tl.LogMessage("PulseGuide", "Not implemented");
//throw new ASCOM.MethodNotImplementedException("PulseGuide");
CheckRange(Duration, 0, 32767, "PulseGuide", "Duration");
telescope.PulseGuide(Direction, Duration);
}
public void PulseGuide(GuideDirections Direction, int Duration)
{
switch (Direction)
{
case GuideDirections.guideEast:
{
fMounter.NavSpeed = GuideRateRightAscension;
fMounter.Roll(MOTOR.RA, STEPDIR.STEP_BACKWARD, (short)Duration);
break;
}
case GuideDirections.guideWest:
{
fMounter.NavSpeed = GuideRateRightAscension;
fMounter.Roll(MOTOR.RA, STEPDIR.STEP_FORWARD, (short)Duration);
break;
}
case GuideDirections.guideNorth:
{
fMounter.NavSpeed = GuideRateDeclination;
fMounter.Roll(MOTOR.DE, STEPDIR.STEP_BACKWARD, (short)Duration);
break;
}
case GuideDirections.guideSouth:
{
fMounter.NavSpeed = GuideRateDeclination;
fMounter.Roll(MOTOR.DE, STEPDIR.STEP_FORWARD, (short)Duration);
break;
}
}
fMounter.OnStopWaitEvent.WaitOne(Duration + 100);
}
public Puls(GuideDirections dir, int timeNow, int duration)
{
this.Direction = dir;
// this.TimeBegin = timeNow;
this.Duration = duration;
this.TimeEnd = timeNow + duration;
}
public void PulseGuide(GuideDirections direction, int duration)
{
traceLogger.LogMessage("PulseGuide", "Direction - " + direction.ToString() + "Duration - " + duration.ToString());
//Duration in milliseconds
TimeSpan moveDuration = TimeSpan.FromMilliseconds(duration);
switch (direction)
{
case GuideDirections.guideEast:
axisControllers[(int)Axis.RA].Move(moveDuration, Orientation.PLUS);
break;
case GuideDirections.guideWest:
axisControllers[(int)Axis.RA].Move(moveDuration, Orientation.MINUS);
break;
case GuideDirections.guideNorth:
axisControllers[(int)Axis.DEC].Move(moveDuration, Orientation.PLUS);
break;
case GuideDirections.guideSouth:
axisControllers[(int)Axis.DEC].Move(moveDuration, Orientation.MINUS);
break;
}
}
public void PulseGuide(GuideDirections Direction, int Duration)
{
tl.LogMessage("PulseGuide", $"{Direction} {Duration}");
if (Direction == GuideDirections.guideEast || Direction == GuideDirections.guideWest)
{
var arcsecs = guideRate * Duration / 1000;
if (Direction == GuideDirections.guideEast)
{
arcsecs = -arcsecs;
}
serial.Transmit($"m {arcsecs.ToString("F4", CultureInfo.InvariantCulture)}\r\n");
var ackStopwatch = new Stopwatch();
ackStopwatch.Start();
bool isAck = false;
while (!isAck && ackStopwatch.ElapsedMilliseconds < 1000)
{
isAck = serial.ReceiveTerminated("\r\n") == "ack\r\n";
}
;
if (!isAck)
{
throw new DriverException("Did not receive ACK");
}
guideDurationStopwatch.Start();
guideMilliseconds = Duration;
}
}
public void PulseGuide(GuideDirections Direction, int Duration)
{
this._memberFactory.CallMember(3, "PulseGuide", new Type[2]
{
typeof(GuideDirections),
typeof(int)
}, (object)Direction, (object)Duration);
}
public void PulseGuide(GuideDirections Direction, int Duration)
{
if (wisetele.ShuttingDown)
{
throw new InvalidOperationException("Wise40 is shutting down");
}
wisetele.PulseGuide(Direction, Duration);
}
public void PulseGuide(GuideDirections Direction, int Duration)
{
if (Duration > short.MaxValue)
{
throw new ASCOM.InvalidValueException("PulseGuide Duration too long");
}
pulseGuiding = true;
SendCommand(Commands.CommandPulseGuidingSpeed(Direction, (short)Duration));
}
public void PulseGuide(GuideDirections Direction, int Duration)
{
this.CheckConnected("PulseGuide");
if (Duration < this.pulseGuideMin || this.pulseGuideMax < Duration)
{
throw new InvalidValueException("PulseGuide", Duration.ToString(), pulseGuideMin.ToString(), pulseGuideMax.ToString());
}
ComPort.Response response;
switch (Direction)
{
case GuideDirections.guideEast:
response = this.comPort.East(Duration); break;
case GuideDirections.guideNorth:
response = this.comPort.North(Duration); break;
case GuideDirections.guideSouth:
response = this.comPort.South(Duration); break;
case GuideDirections.guideWest:
response = this.comPort.West(Duration); break;
default:
throw new InvalidValueException("PulseGuide", Direction.ToString(), "guideEast,guideNorth,guideSouth,guideWest");
}
LogMessage("PulseGuide", response.ToString());
if (response != ComPort.Response.OK)
{
throw new InvalidOperationException("PulseGuide");
}
HashSet <string> states = new HashSet <string>();
while (true)
{
response = this.comPort.State(states);
LogMessage("PulseGuide", response.ToString());
if (response != ComPort.Response.OK)
{
throw new InvalidOperationException("PulseGuide");
}
if (!states.Contains(ComPort.PulseGuide))
{
break;
}
Thread.Sleep(1);
}
}
public void PulseGuide(GuideDirections Direction, int Duration)
{
Dictionary <string, string> Parameters = new Dictionary <string, string>
{
{ SharedConstants.DIRECTION_PARAMETER_NAME, ((int)Direction).ToString() },
{ SharedConstants.DURATION_PARAMETER_NAME, Duration.ToString() }
};
RemoteClientDriver.SendToRemoteDriver <NoReturnValue>(clientNumber, client, URIBase, TL, "PulseGuide", Parameters, Method.PUT);
}
public void PulseGuide(GuideDirections Direction, int Duration)
{
RemoteClientDriver.SetClientTimeout(client, longServerResponseTimeout);
Dictionary <string, string> Parameters = new Dictionary <string, string>
{
{ SharedConstants.DIRECTION_PARAMETER_NAME, ((int)Direction).ToString(CultureInfo.InvariantCulture) },
{ SharedConstants.DURATION_PARAMETER_NAME, Duration.ToString(CultureInfo.InvariantCulture) }
};
RemoteClientDriver.SendToRemoteDriver <NoReturnValue>(clientNumber, client, URIBase, TL, "PulseGuide", Parameters, Method.PUT);
}
public void PulseGuide(GuideDirections Direction, int Duration)
{
if (MyDriverType == 0)
{
MySSCamera.PulseGuide(Direction, Duration);
}
else
{
tl.LogMessage("PulseGuide", "Not implemented");
throw new ASCOM.MethodNotImplementedException("PulseGuide");
}
}
private void StopPulseGuiding(GuideDirections direction)
{
double decRate = 0.0;
double raRate = 0.0;
switch (direction)
{
case GuideDirections.guideNorth:
case GuideDirections.guideSouth:
lock (_PulseGuidingLock[DEC_AXIS])
{
_PulseGuideDuration[DEC_AXIS] = 0;
_PulseGuidingStopwatch[DEC_AXIS].Stop();
decRate = Settings.DeclinationRate;
if (decRate != 0.0)
{
Controller.MCStartTrackingRate(AxisId.Axis2_Dec, decRate, Hemisphere, (Hemisphere == HemisphereOption.Northern ? AxisDirection.Forward : AxisDirection.Reverse));
}
else
{
Controller.MCAxisStop(AxisId.Axis2_Dec);
}
}
break;
case GuideDirections.guideEast:
case GuideDirections.guideWest:
lock (_PulseGuidingLock[DEC_AXIS])
{
_PulseGuideDuration[RA_AXIS] = 0;
_PulseGuidingStopwatch[RA_AXIS].Stop();
if (Tracking)
{
raRate = Settings.DriveRateValue[Settings.TrackingRate] + (Settings.RightAscensionRate * CoreConstants.SIDEREAL_RATE * 15.0);
Controller.MCStartTrackingRate(AxisId.Axis1_RA, raRate, Hemisphere, (Hemisphere == HemisphereOption.Northern ? AxisDirection.Forward : AxisDirection.Reverse));
}
else
{
Controller.MCAxisStop(AxisId.Axis1_RA);
}
}
break;
default:
// Shouldn't be able to get here
throw new ASCOM.InvalidValueException("Unrecognised guide direction.");
}
if (!_PulseGuidingStopwatch[DEC_AXIS].IsRunning && !_PulseGuidingStopwatch[RA_AXIS].IsRunning)
{
_PulseGuidingTimer.Enabled = false;
}
}
//public void Park()
//{
// tl.LogMessage("Park", "Not implemented");
// throw new ASCOM.MethodNotImplementedException("Park");
//}
public void PulseGuide(GuideDirections Direction, int Duration)
{
//Command: “:MnXXXXX#” “:MsXXXXX#” “:MeXXXXX#” “:MwXXXXX#”
//Response: (none)
//Command motion for XXXXX milliseconds in the direction specified at the currently selected guide
//rate. If XXXXX has a value of zero, motion is continuous and requires a “:Mx00000#” command
//to terminate.x is the same direction of the previous command.
// XXXXX is in the range of 0 to 32767.
pulseGuiding = true;
String MoveDurationCommand;
String XXXXX = Duration.ToString().PadLeft(5, '0');
switch (Direction)
{
case ASCOM.DeviceInterface.GuideDirections.guideEast:
MoveDurationCommand = ":Me" + XXXXX + "#";
break;
case ASCOM.DeviceInterface.GuideDirections.guideNorth:
MoveDurationCommand = ":Mn" + XXXXX + "#";
break;
case ASCOM.DeviceInterface.GuideDirections.guideSouth:
MoveDurationCommand = ":Ms" + XXXXX + "#";
break;
case ASCOM.DeviceInterface.GuideDirections.guideWest:
MoveDurationCommand = ":Mw" + XXXXX + "#";
break;
default:
MoveDurationCommand = "";
break;
}
if (MoveDurationCommand != "")
{
var MoveDurationTransaction = new ZEQ25NoReplyTransaction(MoveDurationCommand);
Task.Run(() => transactionProcessor.CommitTransaction(MoveDurationTransaction));
log.Info("Waiting for move command completion");
MoveDurationTransaction.WaitForCompletionOrTimeout();
Thread.Sleep(Duration);
}
pulseGuiding = false;
}
public void Start(GuideDirections direction, int duration)
{
PulserTask pulserTask;
pulserTask = new PulserTask()
{
_axis = guideDirection2Axis[direction],
_duration = duration,
_motor = guideDirection2Motor[direction],
task = null,
};
pulseGuideCT = pulseGuideCTS.Token;
Activate(pulserTask);
pulserTask.task = Task.Run(() =>
{
try
{
pulserTask.Run();
}
catch (Exception ex)
{
#region debug
debugger.WriteLine(Common.Debugger.DebugLevel.DebugLogic,
"Caught exception: {0}, aborting pulse guiding", ex.Message);
#endregion
Abort();
Deactivate(pulserTask, Activity.State.Aborted, string.Format("Caught exception: {0}, aborting pulse guiding", ex.Message));
}
}, pulseGuideCT).ContinueWith((t) =>
{
#region debug
debugger.WriteLine(Common.Debugger.DebugLevel.DebugLogic,
"pulser on {0} completed with status: {1}",
pulserTask._axis.ToString(), t.Status.ToString());
#endregion
Deactivate(pulserTask, Activity.State.Succeeded, string.Format("pulser on {0} completed with status: {1}",
pulserTask._axis.ToString(), t.Status.ToString()));
}, TaskContinuationOptions.ExecuteSynchronously);
}
public void PulseGuide(GuideDirections Direction, int Duration)
{
//tl.LogMessage("PulseGuide", "Not implemented");
//throw new ASCOM.MethodNotImplementedException("PulseGuide");
if (Direction == GuideDirections.guideEast) //East
{
serialPort.Transmit("E#" + Duration.ToString() + "#");
}
else if (Direction == GuideDirections.guideWest) //West
{
serialPort.Transmit("W#" + Duration.ToString() + "#");
}
if (Direction == GuideDirections.guideNorth) //North
{
serialPort.Transmit("U#" + Duration.ToString() + "#");
}
if (Direction == GuideDirections.guideSouth) //South
{
serialPort.Transmit("D#" + Duration.ToString() + "#");
}
}
public void PulseGuide(GuideDirections Direction, int Duration)
{
string STR = "";
tl.LogMessage("PulseGuide", "Implemented");
if (Duration > 0)
{
if ((int)Direction == 0)
{
STR = "PN"; //guideNorth
}
if ((int)Direction == 1)
{
STR = "PS"; //guideSouth
}
if ((int)Direction == 2)
{
STR = "PE"; //guideEast
}
if ((int)Direction == 3)
{
STR = "PW"; //guideWest
}
}
if (STR.Length == 2)
{
PulseGuiding = true;
STR += Duration;
if (CommandBool(STR, true))
{
PulseGuiding = false;
}
}
throw new ASCOM.MethodNotImplementedException("PulseGuide");
}
public void PulseGuide(GuideDirections Direction, int Duration)
{
this.isSlewing = true;
if (Direction == GuideDirections.guideEast) //East
{
serialPort.Transmit("E#" + Duration.ToString() + "#");
}
else if (Direction == GuideDirections.guideWest) //West
{
serialPort.Transmit("W#" + Duration.ToString() + "#");
}
else if (Direction == GuideDirections.guideNorth) //North
{
serialPort.Transmit("N#" + Duration.ToString() + "#");
}
else if (Direction == GuideDirections.guideSouth) //South
{
serialPort.Transmit("S#" + Duration.ToString() + "#");
}
this.isSlewing = false;
}
public void PulseGuide(GuideDirections Direction, int Duration)
{
Axis.AxisControl theAxis = null;
Axis.AxisControl.Direction theDirection;
if (Direction == GuideDirections.guideEast || Direction == GuideDirections.guideWest)
{
theAxis = RaAxis;
}
else
{
theAxis = null;
}
if (Direction == GuideDirections.guideWest || Direction == GuideDirections.guideNorth)
{
theDirection = Axis.AxisControl.Direction.forward;
}
else
{
theDirection = Axis.AxisControl.Direction.backward;
}
if (theAxis != null)
{
theAxis.Pulse(theDirection, Duration);
}
}
public void PulseGuide(GuideDirections Direction, int Duration)
{
tl.LogMessage("PulseGuide", "Not implemented");
throw new ASCOM.MethodNotImplementedException("PulseGuide");
}
public void PulseGuide(GuideDirections Direction, int Duration)
{
objTypeScope.InvokeMember("PulseGuide", BindingFlags.Default | BindingFlags.InvokeMethod,
null, objScopeLateBound, new object[] { (int)Direction, Duration });
}
public void PulseGuide(GuideDirections direction, int duration)
{
throw new MethodNotImplementedException("PulseGuide");
}
public void TelescopePulseGuide(GuideDirections direction, PulseRate pulseRate, CallType callType = CallType.Async, Guid? clientId = null, CallbackAction callback = null, Control callbackUIControl = null)
{
IsolatedAction((x, y) =>
{
try
{
if (m_ConnectedTelescope != null && m_ConnectedTelescope.Connected)
{
AssertTelescopeEngagement(clientId);
m_ConnectedTelescope.PulseGuide(x, y, Settings.Default.TelPulseDuration);
TelescopeEquatorialPosition position = m_ConnectedTelescope.GetEquatorialPosition();
OnTelescopePosition(position);
return position;
}
return null;
}
catch (Exception ex)
{
OnTelescopeErrored();
Trace.WriteLine(ex.GetFullStackTrace());
return ex;
}
},
direction, pulseRate, callType, callback, callbackUIControl);
}
public void PulseGuide(GuideDirections dir, int duration, PulsState ps)
{
if (!this.ti.CanSlewHighRate) throw new NotSupportedException("Puls guiding is not supported");
this.CheckRateTrackingState();
double rate;
switch (dir)
{
case GuideDirections.guideNorth:
ps.Dec = new Puls(dir, Environment.TickCount, duration);
rate = this.tp.DeclinationRateOffset + this.tp.PulseRateAlt;
this.ti.SlewHighRate(SlewAxes.DecAlt, rate);
break;
case GuideDirections.guideSouth:
ps.Dec = new Puls(dir, Environment.TickCount, duration);
rate = this.tp.DeclinationRateOffset - this.tp.PulseRateAlt;
this.ti.SlewHighRate(SlewAxes.DecAlt, rate);
break;
case GuideDirections.guideEast:
ps.Ra = new Puls(dir, Environment.TickCount, duration);
rate = this.GetRateRa(this.tp.TrackingRate, this.tp.TrackingMode) + this.tp.PulseRateAzm;
this.ti.SlewHighRate(SlewAxes.RaAzm, rate);
break;
case GuideDirections.guideWest:
ps.Ra = new Puls(dir, Environment.TickCount, duration);
rate = this.GetRateRa(this.tp.TrackingRate, this.tp.TrackingMode) - this.tp.PulseRateAzm;
this.ti.SlewHighRate(SlewAxes.RaAzm, rate);
break;
}
}
/// <summary>
/// PulseGuide for Gemini L5 and above
/// </summary>
/// <param name="Direction"></param>
/// <param name="Duration"></param>
public void PulseGuideL5(GuideDirections Direction, int Duration)
{
GeminiHardware.Instance.Trace.Enter("IT:PulseGuide5", Direction, Duration);
AssertConnect();
if (GeminiHardware.Instance.AtPark) throw new DriverException(SharedResources.MSG_INVALID_AT_PARK, (int)SharedResources.INVALID_AT_PARK);
string cmd = String.Empty;
switch (Direction)
{
case GuideDirections.guideEast:
cmd = ":Mge";
break;
case GuideDirections.guideNorth:
cmd = ":Mgn";
break;
case GuideDirections.guideSouth:
cmd = ":Mgs";
break;
case GuideDirections.guideWest:
cmd = ":Mgw";
break;
}
if (Duration > 60000 || Duration <= 0) // too large or zero/negative...
throw new InvalidValueException("PulseGuide5", Duration.ToString(), "1..60000");
string c = cmd + Duration.ToString();
// Set time for pulse guide command to be started (used by IsPulseGuiding property)
// IsPulseGuiding will report true until this many milliseconds elapse.
// After this time, IsPulseGuiding will query the mount for tracking speed
// to return the proper status. This is necessary because Gemini doesn't immediately
// set 'G' or 'C' tracking rate when pulse-guiding command is issued and continues to track
// for a little while. Use 1/2 of the total duration or 100 milliseconds, whichever is greater:
GeminiHardware.Instance.EndOfPulseGuide = Math.Max(Duration / 2, 100);
GeminiHardware.Instance.Velocity = "G";
GeminiHardware.Instance.DoCommandResult(c, Duration + GeminiHardware.Instance.MAX_TIMEOUT, false);
if (!GeminiHardware.Instance.AsyncPulseGuide)
GeminiHardware.Instance.WaitForVelocity("TN", Duration + GeminiHardware.Instance.MAX_TIMEOUT); // shouldn't take much longer than 'Duration', right?
GeminiHardware.Instance.Trace.Exit("IT:PulseGuide5", Direction, Duration, GeminiHardware.Instance.AsyncPulseGuide);
}
public void PulseGuide(GuideDirections Direction, int Duration)
{
throw new NotImplementedException();
}
/// <summary>
/// Moves the mount in guiding speed to a specified direction for a specified duration
/// If the mount is not slewing, a move command is issued. Immediately a timer is started
/// for the specified duration, which will stop the moving if it expires.
/// </summary>
/// <param name="direction"></param>
/// <param name="duration"></param>
/// <returns>true if succesful</returns>
public bool PulseGuide(GuideDirections direction, int duration)
{
bool success = false;
if (BusySlewing(out bool busySlewing))
{
if (!busySlewing)
{
// go into guiding mode. Issue this command always, because
// slewing might have been selected manually on the controller
if (!Request(":RG#"))
{
return(success);
}
char directionChar = ' ';
switch (direction)
{
case GuideDirections.guideEast:
if (!eastGuideBusy)
{
directionChar = 'e';
}
break;
case GuideDirections.guideNorth:
if (!northGuideBusy)
{
directionChar = 'n';
}
break;
case GuideDirections.guideSouth:
if (!southGuideBusy)
{
directionChar = 's';
}
break;
case GuideDirections.guideWest:
if (!westGuideBusy)
{
directionChar = 'w';
}
break;
}
if (directionChar != ' ')
{
if (Request(string.Format(":M{0}#", directionChar)))
{
switch (direction)
{
case GuideDirections.guideEast:
eastGuideBusy = true;
eastGuideTimer =
new System.Threading.Timer(new TimerCallback(OnEastGuideTimer), null, 0, duration);
success = true;
break;
case GuideDirections.guideNorth:
northGuideBusy = true;
northGuideTimer =
new System.Threading.Timer(new TimerCallback(OnNorthGuideTimer), null, 0, duration);
success = true;
break;
case GuideDirections.guideSouth:
southGuideBusy = true;
southGuideTimer =
new System.Threading.Timer(new TimerCallback(OnSouthGuideTimer), null, 0, duration);
success = true;
break;
case GuideDirections.guideWest:
westGuideBusy = true;
westGuideTimer =
new System.Threading.Timer(new TimerCallback(OnWestGuideTimer), null, 0, duration);
success = true;
break;
} // switch
} // move request succesful
} // direction valid
} // mount is not slewing
} // able to determine slewing
return(success);
} // PulseGuide
public void PulseGuide(GuideDirections direction, int durationMilliseconds)
{
m_IsolatedTelescope.PulseGuide(direction, durationMilliseconds);
}
public void PulseGuide(GuideDirections dir, int duration)
{
this.CheckPark();
if(this.telescopeMode != TelescopeMode.Normal && this.telescopeMode != TelescopeMode.Guiding) return;
lock (_sync)
{
this.tp.IsAtHome = false;
this.two.PulseGuide(dir, duration, this.ps);
this.telescopeMode = TelescopeMode.Guiding;
}
}
public void PulseGuide(GuideDirections direction, int duration)
{
traceLogger.LogMessage("PulseGuide", "Direction - " + direction.ToString() + "Duration - " + duration.ToString());
//Duration in milliseconds
TimeSpan moveDuration = TimeSpan.FromMilliseconds(duration);
switch (direction)
{
case GuideDirections.guideEast:
axisControllers[(int)Axis.RA].Move(moveDuration, Orientation.PLUS);
break;
case GuideDirections.guideWest:
axisControllers[(int)Axis.RA].Move(moveDuration, Orientation.MINUS);
break;
case GuideDirections.guideNorth:
axisControllers[(int)Axis.DEC].Move(moveDuration, Orientation.PLUS);
break;
case GuideDirections.guideSouth:
axisControllers[(int)Axis.DEC].Move(moveDuration, Orientation.MINUS);
break;
}
}
public void StartSlewing(GuideDirections direction)
{
Trace.WriteLine(string.Format("OccuRec: ASCOMServer::{0}(Telescope)::StartSlewing({1})", ProgId, direction));
switch (direction)
{
case GuideDirections.guideEast:
SlewEast();
break;
case GuideDirections.guideWest:
SlewWest();
break;
case GuideDirections.guideNorth:
SlewNorth();
break;
case GuideDirections.guideSouth:
SlewSouth();
break;
}
}
public void PulseGuide(GuideDirections Direction, int Duration)
{
throw new MethodNotImplementedException();
}
/// <summary>
/// Send pulse-guide commands to the mount in the required direction, for the required duration
/// </summary>
/// <param name="Direction"></param>
/// <param name="Duration"></param>
public void PulseGuide(GuideDirections Direction, int Duration)
{
if (GeminiHardware.Instance.GeminiLevel > 4)
{
PulseGuideL5(Direction, Duration);
return;
}
if (!GeminiHardware.Instance.PrecisionPulseGuide)
{
OldPulseGuide(Direction, Duration);
return;
}
GeminiHardware.Instance.Trace.Enter("IT:PulseGuide", Direction, Duration);
AssertConnect();
if (GeminiHardware.Instance.AtPark) throw new DriverException(SharedResources.MSG_INVALID_AT_PARK, (int)SharedResources.INVALID_AT_PARK);
// don't update mount parameters each time a guide command is issued: this will slow things down while guiding
// do it on a polling interval:
if (DateTime.Now - m_LastPulseGuideUpdate > TimeSpan.FromMilliseconds(SharedResources.PULSEGUIDE_POLLING_INTERVAL) ||
m_GuideRateStepsPerMilliSecond == 0)
{
string[] mountpar = null;
GeminiHardware.Instance.DoCommandResult(new string[] { "<21:", "<23:", "<25:" }, GeminiHardware.Instance.MAX_TIMEOUT / 2, false, out mountpar);
if (mountpar != null)
{
string wormGearRatio = mountpar[0];
string spurGearRatio = mountpar[1];
string encoderResolution = mountpar[2];
// compute actual tracking rate, including any offset, in arcsecs/second
m_TrackRate = (this.RightAscensionRate * 0.9972695677 + SharedResources.EARTH_ANG_ROT_DEG_MIN * 60);
if (spurGearRatio != null && wormGearRatio != null && encoderResolution != null)
{
double StepsPerDegree = (Math.Abs(double.Parse(wormGearRatio)) * double.Parse(spurGearRatio) * double.Parse(encoderResolution)) / 360.0;
m_GuideRA = GuideRateRightAscension;
m_GuideRateStepsPerMilliSecond = StepsPerDegree * m_GuideRA / 1000; // guide rate in encoder ticks per milli-second
m_GuideRateStepsPerMilliSecondEast = StepsPerDegree * (m_TrackRate / 3600 - m_GuideRA) / 1000;
m_GuideRateStepsPerMilliSecondWest = StepsPerDegree * (m_TrackRate / 3600 + m_GuideRA) / 1000;
m_LastPulseGuideUpdate = DateTime.Now;
GeminiHardware.Instance.Trace.Info(3, "PulseGuide Param", m_GuideRateStepsPerMilliSecond, m_GuideRateStepsPerMilliSecondEast, m_GuideRateStepsPerMilliSecondWest);
}
}
}
if (m_GuideRateStepsPerMilliSecond == 0) // never did get the rate!
throw new ASCOM.DriverException(SharedResources.MSG_INVALID_VALUE, (int)SharedResources.SCODE_INVALID_VALUE);
string cmd = String.Empty;
//switch (Direction)
//{
// case GuideDirections.guideEast:
// cmd = ":Mie";
// break;
// case GuideDirections.guideNorth:
// cmd = ":Min";
// break;
// case GuideDirections.guideSouth:
// cmd = ":Mis";
// break;
// case GuideDirections.guideWest:
// cmd = ":Miw";
// break;
//}
int maxduration = (int)(255 / m_GuideRateStepsPerMilliSecond);
int prescaler = 1;
switch (Direction)
{
case GuideDirections.guideEast:
cmd = ":Mge";
maxduration = (int)(255 / m_GuideRateStepsPerMilliSecondEast);
// perhaps a bug in Gemini: the prescaler value used for East guiding rate
// needs to be reversed for West guiding rate.
// actual divisor:
//prescaler = (int)(1500 / m_GuideRateStepsPerMilliSecondWest);
//// prescaler needed to fit into 16 bits:
//prescaler = (prescaler / 65536) + 1;
// adjust duration to account for prescaler:
Duration *= prescaler;
break;
case GuideDirections.guideNorth:
cmd = ":Mgn";
break;
case GuideDirections.guideSouth:
cmd = ":Mgs";
break;
case GuideDirections.guideWest:
maxduration = (int)(255 / m_GuideRateStepsPerMilliSecondWest);
// factor is due to different step speed in West direction: (1+g)/(1-g):
double fact = (1 + m_GuideRA / (SharedResources.EARTH_ANG_ROT_DEG_MIN / 60.0)) / (1 - m_GuideRA / (SharedResources.EARTH_ANG_ROT_DEG_MIN / 60.0));
Duration = (int)(Duration / fact);
// perhaps a bug in Gemini: the prescaler value used for East guiding rate
// needs to be reversed for West guiding rate.
// actual divisor:
prescaler = (int)(1500 / m_GuideRateStepsPerMilliSecondEast);
// prescaler needed to fit into 16 bits:
prescaler = (prescaler / 65536) + 1;
// adjust duration to account for prescaler:
Duration *= prescaler;
cmd = ":Mgw";
break;
}
// max duration is rounded to whole seconds, as per Rene G.:
maxduration = ((int)(maxduration / 1000)) * 1000;
//System.Windows.Forms.MessageBox.Show("Max duration: " + maxduration.ToString() + "\r\n" +
// "Guide Rate: " + (m_GuideRA / (SharedResources.EARTH_ANG_ROT_DEG_MIN / 60.0)).ToString() + "\r\n" +
// "East Steps/Sec: " + (m_GuideRateStepsPerMilliSecondEast * 1000).ToString() + "\r\n" +
// "West Steps/Sec: " + (m_GuideRateStepsPerMilliSecondWest * 1000).ToString() + "\r\n" +
// "Prescaler : " + prescaler.ToString());
GeminiHardware.Instance.Trace.Info(3, "PulseGuide MaxDuration", maxduration);
int totalSteps = (int)(Duration * m_GuideRateStepsPerMilliSecond + 0.5); // total encoder ticks
GeminiHardware.Instance.Trace.Info(4, "IT:PulseGuide Ticks", totalSteps);
GeminiHardware.Instance.Trace.Info(4, "IT:PulseGuide MaxDur", maxduration);
if (Duration > 60000 || Duration < 0) // too large or negative...
throw new InvalidValueException("PulseGuide", Duration.ToString(), "0..60000");
if (totalSteps <= 0) return; //too small a move (less than 1 encoder tick)
int count = Duration;
for (int idx = 0; count > 0; ++idx)
{
int d = (count > maxduration ? maxduration : count);
string c = cmd + d.ToString();
// Set time for pulse guide command to be started (used by IsPulseGuiding property)
// IsPulseGuiding will report true until this many milliseconds elapse.
// After this time, IsPulseGuiding will query the mount for tracking speed
// to return the proper status. This is necessary because Gemini doesn't immediately
// set 'G' or 'C' tracking rate when pulse-guiding command is issued and continues to track
// for a little while. Use 1/2 of the total duration or 100 milliseconds, whichever is greater:
GeminiHardware.Instance.EndOfPulseGuide = Math.Max(d / 2, 100);
GeminiHardware.Instance.DoCommandResult(c, Duration + GeminiHardware.Instance.MAX_TIMEOUT, false);
GeminiHardware.Instance.Velocity = "G";
count -= d;
if (!GeminiHardware.Instance.AsyncPulseGuide || count > 0)
GeminiHardware.Instance.WaitForVelocity("TN", Duration + GeminiHardware.Instance.MAX_TIMEOUT); // shouldn't take much longer than 'Duration', right?
}
GeminiHardware.Instance.Trace.Exit("IT:PulseGuide", Direction, Duration, totalSteps, GeminiHardware.Instance.AsyncPulseGuide);
}
public void SlewNearBy(double distanceArSecs, GuideDirections direction)
{
Trace.WriteLine(string.Format("OccuRec: ASCOMServer::{0}(Telescope)::SlewNearBy({1}, {2})", ProgId, distanceArSecs, direction));
try
{
double rightAscension = m_Telescope.RightAscension;
double declination = m_Telescope.Declination;
switch (direction)
{
case GuideDirections.guideEast:
rightAscension -= (distanceArSecs / 54000.0);
if (rightAscension < 0) rightAscension += 24;
break;
case GuideDirections.guideWest:
rightAscension += (distanceArSecs / 54000.0);
if (rightAscension > 24) rightAscension -= 24;
break;
case GuideDirections.guideNorth:
declination += (distanceArSecs / 3600.0);
if (declination > 90) declination = 90;
break;
case GuideDirections.guideSouth:
declination -= (distanceArSecs / 3600.0);
if (declination < -90) declination = -90;
break;
}
m_Telescope.SlewToCoordinates(rightAscension, declination);
}
catch (Exception ex)
{
Trace.WriteLine(ex.GetFullStackTrace());
}
}
/// <summary>
/// Use pc timing to execute pulse-guiding commands instead of Gemini precision-guiding commands
/// </summary>
/// <param name="Direction"></param>
/// <param name="Duration"></param>
private void OldPulseGuide(GuideDirections Direction, int Duration)
{
GeminiHardware.Instance.Trace.Enter("IT:OldPulseGuide", Direction, Duration, GeminiHardware.Instance.AsyncPulseGuide);
AssertConnect();
if (GeminiHardware.Instance.AtPark) throw new DriverException(SharedResources.MSG_INVALID_AT_PARK, (int)SharedResources.INVALID_AT_PARK);
if (Duration > 60000 || Duration < 0) // too large or negative...
throw new InvalidValueException("PulseGuide", Duration.ToString(), "0..60000");
if (Duration == 0) return;
string[] cmd = new string[2];
cmd[0] = ":RG";
switch (Direction)
{
case GuideDirections.guideEast:
cmd[1] = ":Me";
break;
case GuideDirections.guideNorth:
cmd[1] = ":Mn";
break;
case GuideDirections.guideSouth:
cmd[1] = ":Ms";
break;
case GuideDirections.guideWest:
cmd[1] = ":Mw";
break;
}
// Set time for pulse guide command to be started (used by IsPulseGuiding property)
// IsPulseGuiding will report true until this many milliseconds elapse.
// After this time, IsPulseGuiding will query the mount for tracking speed
// to return the proper status. This is necessary because Gemini doesn't immediately
// set 'G' or 'C' tracking rate when pulse-guiding command is issued and continues to track
// for a little while. Use the total duration:
GeminiHardware.Instance.EndOfPulseGuide = Duration;
GeminiHardware.Instance.Velocity = "G";
GeminiHardware.Instance.DoPulseCommand(cmd, Duration, GeminiHardware.Instance.AsyncPulseGuide);
GeminiHardware.Instance.Trace.Exit("IT:OldPulseGuide", Direction, Duration, GeminiHardware.Instance.AsyncPulseGuide);
}
public void SlewNearBy(double distanceArSecs, GuideDirections direction)
{
m_IsolatedTelescope.SlewNearBy(distanceArSecs, direction);
}
public void Initialize()
{
this.direction = GuideDirections.off;
this.requestedVelocity = 0;
}
public void TelescopeStartSlewing(GuideDirections direction, CallType callType = CallType.Async, Guid? clientId = null, CallbackAction callback = null, Control callbackUIControl = null)
{
IsolatedAction((dir) =>
{
try
{
if (m_ConnectedTelescope != null && m_ConnectedTelescope.Connected)
{
AssertTelescopeEngagement(clientId);
m_ConnectedTelescope.StartSlewing(dir);
TelescopeEquatorialPosition position = m_ConnectedTelescope.GetEquatorialPosition();
OnTelescopePosition(position);
return position;
}
return null;
}
catch (Exception ex)
{
OnTelescopeErrored();
Trace.WriteLine(ex.GetFullStackTrace());
return ex;
}
},
direction, callType, callback, callbackUIControl);
}
public void PulseGuide(GuideDirections direction, PulseRate rate, int durationMilliseconds)
{
EnsureRequestedGuideRate(rate);
PulseGuide(direction, durationMilliseconds);
}
private void StartSlewGuide(SlewDirection direction)
{
try
{
if (this.radioButtonPulseGuide.Checked)
{
// Do Pulse Guiding instead
GuideDirections dir = GuideDirections.guideEast;
switch (direction)
{
case SlewDirection.SlewNorth:
case SlewDirection.SlewUp:
dir = GuideDirections.guideNorth;
break;
case SlewDirection.SlewSouth:
case SlewDirection.SlewDown:
dir = GuideDirections.guideSouth;
break;
case SlewDirection.SlewEast:
case SlewDirection.SlewRight:
dir = GuideDirections.guideEast;
break;
case SlewDirection.SlewWest:
case SlewDirection.SlewLeft:
dir = GuideDirections.guideWest;
break;
case SlewDirection.SlewNone:
default:
return;
}
TelescopeHardware.Guide(dir, GuideDuration());
return;
}
double rate = GetSlewSpeed();
TelescopeAxes axes = TelescopeAxes.axisPrimary;
//if (TelescopeHardware.AlignmentMode == DeviceInterface.AlignmentModes.algAltAz)
//{
// slewDirection = direction;
//}
//else
//{
switch (direction)
{
case SlewDirection.SlewEast:
case SlewDirection.SlewRight:
axes = TelescopeAxes.axisPrimary;
break;
case SlewDirection.SlewWest:
case SlewDirection.SlewLeft:
axes = TelescopeAxes.axisPrimary;
rate = -rate;
break;
case SlewDirection.SlewNorth:
case SlewDirection.SlewUp:
axes = TelescopeAxes.axisSecondary;
break;
case SlewDirection.SlewSouth:
case SlewDirection.SlewDown:
axes = TelescopeAxes.axisSecondary;
rate = -rate;
break;
case SlewDirection.SlewNone:
default:
return;
}
//}
TelescopeHardware.MoveAxis(axes, rate);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, ex.ToString(), MessageBoxButtons.OK);
}
}
public void PulseGuide(GuideDirections Direction, int Duration) {
throw new ASCOM.MethodNotImplementedException("The PulseGuide property is not implemented");
}
public void PulseGuide(GuideDirections Direction, int Duration)
{
tl.LogMessage("PulseGuide", "Not implemented");
throw new ASCOM.MethodNotImplementedException("PulseGuide");
}
public void StartSlewing(GuideDirections direction)
{
m_IsolatedTelescope.StartSlewing(direction);
}
private void MoveToDirection(GuideDirections direction)
{
PulseRate? rate;
double? degreesPerMinute;
ReadPulseRateOrSlewRate(out rate, out degreesPerMinute);
if (rate.HasValue)
{
DisableEnableControls(false);
ObservatoryController.TelescopePulseGuide(direction, rate.Value, CallType.Async, null, OnPulseCompleted);
}
else if (degreesPerMinute.HasValue)
{
DisableEnableControls(false);
if (degreesPerMinute == 0.5)
ObservatoryController.TelescopeSetSlewRate(double.NaN, callback: (arg) => ObservatoryController.TelescopeStartSlewing(direction, CallType.Async, null, OnPulseCompleted));
else if (degreesPerMinute == 2)
ObservatoryController.TelescopeSetSlewRate(0, callback: (arg) => ObservatoryController.TelescopeStartSlewing(direction, CallType.Async, null, OnPulseCompleted));
else
ObservatoryController.TelescopeSetSlewRate(degreesPerMinute.Value / 60.0, callback: (arg) => ObservatoryController.TelescopeStartSlewing(direction, CallType.Async, null, OnPulseCompleted));
}
}
/// <summary>
/// This method returns only after the move has completed.
/// symbolic Constants
/// The (symbolic) values for GuideDirections are:
/// Constant Value Description
/// -------- ----- -----------
/// guideNorth 0 North (+ declination/elevation)
/// guideSouth 1 South (- declination/elevation)
/// guideEast 2 East (+ right ascension/azimuth)
/// guideWest 3 West (+ right ascension/azimuth)
/// Note: directions are nominal and may depend on exact mount wiring. guideNorth
/// must be opposite guideSouth, and guideEast must be opposite guideWest.
/// </summary>
/// <param name="direction">The direction.</param>
/// <param name="duration">The duration.</param>
/// <exception cref=" System.Exception">PulseGuide command is unsupported</exception>
/// <exception cref=" System.Exception">PulseGuide command is unsuccessful</exception>
public void PulseGuide(GuideDirections direction, int duration)
{
_memberFactory.CallMember(3, "PulseGuide", new[] { typeof(GuideDirections), typeof(int) },
new object[] { direction, duration });
}
public void SetGuideDirection(GuideLocations location, GuideDirections direction)
{
TruckCommBus.Instance.SetGuideDirection(location, direction);
}
//Camera Pulse Guide, doesn't supported in hardware
public void PulseGuide(GuideDirections Direction, int Duretion)
{
throw new ASCOM.PropertyNotImplementedException("PulseGuide not supported now");
}
//Camera Pulse Guide, doesn't supported in hardware
public void PulseGuide(GuideDirections Direction, int Duretion)
{
throw new ASCOM.PropertyNotImplementedException("PulseGuide not supported now");
}
public void PulseGuide(GuideDirections Direction, int Duration)
{
this.isPulseGuiding = true;
if (this.isSlewing)
return;
switch (Direction)
{
case GuideDirections.guideNorth:
this.MoveAxis(TelescopeAxes.axisSecondary, 1);
break;
case GuideDirections.guideSouth:
this.MoveAxis(TelescopeAxes.axisSecondary, -1);
break;
case GuideDirections.guideEast:
this.MoveAxis(TelescopeAxes.axisPrimary, 1);
break;
case GuideDirections.guideWest:
this.MoveAxis(TelescopeAxes.axisPrimary, -1);
break;
}
HC.WaitForMilliseconds(Duration);
this.AbortSlew();
this.isPulseGuiding = false;
}
public void SetGuideDirection(GuideLocations location, GuideDirections direction)
{
if (GuideLocations.left == location)
{
this.guideLeftStatus.direction = direction;
}
else if (GuideLocations.right == location)
{
this.guideRightStatus.direction = direction;
}
}
public void PulseGuide(GuideDirections direction, int durationMilliseconds)
{
try
{
Trace.WriteLine(string.Format("OccuRec: ASCOMServer::{0}(Telescope)::PulseGuide({1}, {2})", ProgId, direction, durationMilliseconds));
m_Telescope.PulseGuide((global::ASCOM.DeviceInterface.GuideDirections)direction, durationMilliseconds);
}
catch (Exception ex)
{
Trace.WriteLine(ex.GetFullStackTrace());
}
while (m_Telescope.IsPulseGuiding)
{
Thread.Sleep(100);
}
}
