protected override async void OnNavigatedTo(NavigationEventArgs e)
{
PaintingCanvas.Background = null;
_state = StreamingState.Idle;
if (_faceDetector == null)
{
_faceDetector = await FaceDetector.CreateAsync();
}
if (_faceApiHelper == null)
{
try
{
_faceApiHelper = new FaceApiHelper();
await _faceApiHelper.CheckGroupExistAsync();
}
catch (FaceAPIException faceEx)
{
ShowAlertHelper.ShowDialog(faceEx.ErrorMessage, faceEx.ErrorCode);
}
catch (Exception ex)
{
ShowAlertHelper.ShowDialog(ex.Message);
}
}
}
public bool StreamingToolChange(StreamingState newState, bool always)
{
switch (newState)
{
case StreamingState.ToolChange:
btnStart.IsEnabled = true;
btnHold.IsEnabled = false;
break;
case StreamingState.Send:
case StreamingState.Error:
SetStreamingHandler(StreamingHandler.Previous);
break;
case StreamingState.Stop:
SetStreamingHandler(StreamingHandler.Idle);
break;
}
if (streamingHandler.Handler != StreamingHandler.ToolChange)
{
return(streamingHandler.Call(newState, true));
}
else
{
return(true);
}
}
public void Clear()
{
_fileName = _mdiCommand = string.Empty;
_streamingState = StreamingState.NoFile;
_isMPos = _reset = _isJobRunning = false;
_mpg = "";
_grblState.Error = 0;
_grblState.State = GrblStates.Unknown;
_grblState.Substate = 0;
_grblState.MPG = false;
GrblState = _grblState;
IsMPGActive = null; //??
_MPos = _WPos = _wco = string.Empty;
Position.Clear();
MachinePosition.Clear();
WorkPosition.Clear();
WorkPositionOffset.Clear();
ProgramLimits.Clear();
Set("Pn", string.Empty);
Set("A", string.Empty);
Set("FS", string.Empty);
Set("Sc", string.Empty);
Set("T", "0");
Set("Ov", string.Empty);
Set("Ex", string.Empty);
SDCardStatus = string.Empty;
HomedState = HomedState.Unknown;
if (_latheMode != LatheMode.Disabled)
{
LatheMode = LatheMode.Radius;
}
}
private void SendCommand(string command)
{
if (command.Length == 1)
{
SendRTCommand(command);
}
else if (streamingState == StreamingState.Idle || streamingState == StreamingState.NoFile || streamingState == StreamingState.ToolChange || streamingState == StreamingState.Stop || command == GrblConstants.CMD_UNLOCK)
{
// command = command.ToUpper();
try
{
string c = command;
GCode.File.Parser.ParseBlock(ref c, true);
GCode.File.Commands.Enqueue(command);
if (streamingState != StreamingState.SendMDI)
{
streamingState = StreamingState.SendMDI;
ResponseReceived("go");
}
}
catch
{
}
}
}
private async void ChangeStateAsync(StreamingState newState)
{
switch (newState)
{
case StreamingState.Idle:
// Clear canvas and stop preview.
await ShutdownCameraAsync();
_state = newState;
break;
case StreamingState.Streaming:
bool isStartPreview = await StartStreamingAsync();
// If failure to start preview, change state to idle.
if (!isStartPreview)
{
ChangeStateAsync(StreamingState.Idle);
return;
}
_state = StreamingState.Streaming;
break;
default:
break;
}
}
public void SendMDICommand(string command)
{
if (GrblMessage != null)
{
GrblMessage("");
}
if (command.Length == 1)
{
SendRTCommand(command);
}
else if (this.streamingState == StreamingState.Idle || this.streamingState == StreamingState.NoFile || this.streamingState == StreamingState.ToolChange || command == GrblConstants.CMD_UNLOCK)
{
// command = command.ToUpper();
try
{
file.ParseBlock(command + "\r", false);
file.commands.Enqueue(command);
if (this.streamingState != StreamingState.SendMDI)
{
this.streamingState = StreamingState.SendMDI;
this.DataReceived("ok");
}
}
catch
{
}
}
}
/// <summary>
/// Pauses the streaming playback.
/// </summary>
public void Pause()
{
// Store a buffering state
State = StreamingState.Buffering;
// And pause the player
Player.Pause();
}
private void SendMDICommand(string command)
{
model.Message = "";
if (command.Length == 1)
{
SendRTCommand(command);
}
else if (streamingState == StreamingState.Idle || streamingState == StreamingState.NoFile || streamingState == StreamingState.ToolChange || command == GrblConstants.CMD_UNLOCK)
{
// command = command.ToUpper();
try
{
GCode.Parser.ParseBlock(command, true);
GCode.commands.Enqueue(command);
if (streamingState != StreamingState.SendMDI)
{
streamingState = StreamingState.SendMDI;
DataReceived("ok");
}
}
catch
{
}
}
}
/// <summary>
/// Plays the stored stream.
/// </summary>
public void Play()
{
// Reproduce the player
Player.Play();
// Store the current state
State = StreamingState.Playing;
}
/// <summary>
/// Stops the playback of the stream
/// </summary>
public void Stop()
{
// If the stream is not already stopped
if (State != StreamingState.Stopped)
{
// If the stream is not fully downloaded and there is a request being made, abort it
if (!FullyDownloaded && Request != null)
{
Request.Abort();
}
// Store a stopped state
State = StreamingState.Stopped;
// If there is an existing player
if (Player != null)
{
// Stop the player
Player.Stop();
// Dispose the player
Player.Dispose();
// And set it to null
Player = null;
}
// Disable the timer
HandlingTimer.Enabled = false;
// Wait half a second
Thread.Sleep(500);
}
}
protected override async void OnNavigatedTo(NavigationEventArgs e)
{
_state = StreamingState.Idle;
if (_faceTracker == null)
{
_faceTracker = await FaceTracker.CreateAsync();
}
if (_faceApiHelper == null)
{
try
{
_faceApiHelper = new FaceApiHelper();
_eventHubHelper = new EventHubHelper();
//用不到
//await _faceApiHelper.CheckGroupExistAsync();
}
catch (Microsoft.ProjectOxford.Face.FaceAPIException faceEx)
{
ShowErrorHelper.ShowDialog(faceEx.ErrorMessage, faceEx.ErrorCode);
}
catch (Microsoft.Azure.EventHubs.EventHubsException eventhubEx)
{
ShowErrorHelper.ShowDialog(eventhubEx.Message);
}
catch (Exception ex)
{
ShowErrorHelper.ShowDialog(ex.Message);
}
}
}
public void JogCancel()
{
this.State = StreamingState.Idle;
while (Comms.com.OutCount != 0)
{
Application.DoEvents(); //??
}
Comms.com.WriteByte((byte)GrblConstants.CMD_JOG_CANCEL); // Cancel jog
}
public void StopStreaming(IStreamingState state)
{
StreamingState ss = state as StreamingState;
if (ss == null)
{
throw new ArgumentException();
}
ss.Dispose();
}
public void JogCancel()
{
streamingState = StreamingState.Idle;
while (Comms.com.OutCount != 0)
{
;
}
// Application.DoEvents(); //??
Comms.com.WriteByte(GrblConstants.CMD_JOG_CANCEL); // Cancel jog
jogMode = JogMode.None;
}
public void SendJogCommand(string command)
{
if (this.State == StreamingState.Jogging)
{
Comms.com.WriteByte((byte)GrblConstants.CMD_JOG_CANCEL); // Cancel current jog
}
else
{
this.State = StreamingState.Jogging;
}
Comms.com.WriteCommand(command);
}
public bool StreamingToolChange(StreamingState newState, bool always)
{
bool changed = streamingState != newState;
switch (newState)
{
case StreamingState.ToolChange:
model.IsJobRunning = false; // only enable UI if no ATC?
btnStart.IsEnabled = true;
btnHold.IsEnabled = false;
btnStop.IsEnabled = true;
break;
case StreamingState.Idle:
case StreamingState.Send:
if (JobTimer.IsRunning)
{
model.IsJobRunning = true;
if (job.ToolChangeLine >= 0)
{
GCode.File.Data.Rows[job.ToolChangeLine]["Sent"] = "ok";
job.ToolChangeLine = -1;
}
SetStreamingHandler(StreamingHandler.SendFile);
// SendNextLine();
}
else
{
SetStreamingHandler(StreamingHandler.Previous);
}
break;
case StreamingState.Error:
SetStreamingHandler(StreamingHandler.Previous);
break;
case StreamingState.Stop:
SetStreamingHandler(StreamingHandler.Idle);
break;
}
if (streamingHandler.Handler != StreamingHandler.ToolChange)
{
return(streamingHandler.Call(newState, true));
}
else if (changed)
{
model.StreamingState = streamingState = newState;
StreamingStateChanged?.Invoke(streamingState, grblState.MPG);
}
return(true);
}
public void SendJogCommand(string command)
{
if (this.streamingState == StreamingState.Jogging || this.grblState.State == GrblStates.Jog)
{
while (Comms.com.OutCount != 0)
{
Application.DoEvents(); //??
}
Comms.com.WriteByte((byte)GrblConstants.CMD_JOG_CANCEL); // Cancel current jog
}
this.streamingState = StreamingState.Jogging;
Comms.com.WriteCommand(command);
}
/// <summary>
/// Plays a stream on the player.
/// </summary>
public void Play(string URL)
{
// Stop the existing stream
Stop();
// Store a buffering state
State = StreamingState.Buffering;
// Remove the wave provider
WaveProvider = null;
// Run the streaming function on a separate thread.
ThreadPool.QueueUserWorkItem(StreamMp3, URL);
// Enable the timer
HandlingTimer.Enabled = true;
}
public bool StreamingAwaitIdle(StreamingState newState, bool always)
{
bool changed = streamingState != newState || newState == StreamingState.Idle;
if (changed || always)
{
switch (newState)
{
case StreamingState.Idle:
model.RunTime = JobTimer.RunTime;
JobTimer.Stop();
RewindFile();
SetStreamingHandler(StreamingHandler.Idle);
break;
case StreamingState.Error:
case StreamingState.Halted:
btnStart.IsEnabled = !GrblSettings.IsGrblHAL;
btnHold.IsEnabled = false;
btnStop.IsEnabled = true;
break;
case StreamingState.Send:
btnStart.IsEnabled = false;
btnHold.IsEnabled = true;
btnStop.IsEnabled = true;
btnRewind.IsEnabled = false;
break;
case StreamingState.FeedHold:
SetStreamingHandler(StreamingHandler.FeedHold);
break;
case StreamingState.Stop:
SetStreamingHandler(StreamingHandler.Idle);
break;
}
}
if (streamingHandler.Handler != StreamingHandler.AwaitIdle)
{
return(streamingHandler.Call(newState, true));
}
else if (changed)
{
model.StreamingState = streamingState = newState;
StreamingStateChanged?.Invoke(streamingState, grblState.MPG);
}
return(true);
}
public void SetStreamingState(StreamingState newState)
{
switch (newState)
{
case StreamingState.Disabled:
this.Enabled = false;
break;
case StreamingState.Idle:
case StreamingState.NoFile:
this.Enabled = true;
this.btnStart.Enabled = file.Open;
this.btnStop.Enabled = false;
this.btnRewind.Enabled = file.Open && this.CurrLine != 0;
break;
case StreamingState.Send:
this.btnStart.Enabled = false;
this.btnHold.Enabled = true;
this.btnStop.Enabled = true;
this.btnRewind.Enabled = false;
SendNextLine();
break;
case StreamingState.Halted:
this.btnStart.Enabled = true;
this.btnHold.Enabled = false;
this.btnStop.Enabled = true;
break;
case StreamingState.FeedHold:
this.btnStart.Enabled = true;
this.btnHold.Enabled = false;
break;
case StreamingState.Stop:
this.btnStart.Enabled = false;
this.btnStop.Enabled = false;
this.btnRewind.Enabled = true;
Comms.com.WriteByte((byte)GrblConstants.CMD_STOP);
break;
}
this.State = newState;
if (StreamingStateChanged != null)
{
StreamingStateChanged(this.State);
}
}
public bool StreamingAwaitAction(StreamingState newState, bool always)
{
bool changed = streamingState != newState || newState == StreamingState.Idle;
if (changed || always)
{
switch (newState)
{
case StreamingState.Idle:
btnStart.IsEnabled = !GrblSettings.IsGrblHAL;
break;
case StreamingState.Stop:
if (GrblSettings.IsGrblHAL && !model.GrblReset)
{
Comms.com.WriteByte(GrblConstants.CMD_STOP);
}
newState = StreamingState.Idle;
SetStreamingHandler(StreamingHandler.AwaitIdle);
break;
case StreamingState.Paused:
btnHold.IsEnabled = false;
btnStop.IsEnabled = true;
break;
case StreamingState.Send:
SetStreamingHandler(StreamingHandler.SendFile);
SendNextLine();
break;
case StreamingState.JobFinished:
SetStreamingHandler(StreamingHandler.SendFile);
break;
}
}
if (streamingHandler.Handler != StreamingHandler.AwaitAction)
{
return(streamingHandler.Call(newState, true));
}
else if (changed)
{
model.StreamingState = streamingState = newState;
StreamingStateChanged?.Invoke(streamingState, grblState.MPG);
}
return(true);
}
public bool StreamingFeedHold(StreamingState newState, bool always)
{
bool changed = streamingState != newState;
if (always || changed)
{
switch (newState)
{
case StreamingState.Halted:
case StreamingState.FeedHold:
btnStart.IsEnabled = true;
btnHold.IsEnabled = false;
if ((btnStop.IsEnabled = model.IsJobRunning || model.IsSDCardJob) && !GrblInfo.IsGrblHAL)
{
btnStop.Content = (string)FindResource("JobStop");
}
streamingHandler.Count = job.CurrentRow != null;
break;
case StreamingState.Send:
case StreamingState.Error:
case StreamingState.Idle:
SetStreamingHandler(StreamingHandler.Previous);
break;
case StreamingState.Stop:
SetStreamingHandler(StreamingHandler.Idle);
break;
}
}
if (streamingHandler.Handler != StreamingHandler.FeedHold)
{
return(streamingHandler.Call(newState, true));
}
else if (changed)
{
model.StreamingState = streamingState = newState;
StreamingStateChanged?.Invoke(streamingState, grblState.MPG);
}
return(true);
}
public void Clear()
{
_fileName = _mdiCommand = string.Empty;
_streamingState = StreamingState.NoFile;
_isMPos = _reset = _isJobRunning = _isProbeSuccess = _pgmEnd = _isTloRefSet = false;
_canReset = true;
_pb_avail = _rxb_avail = string.Empty;
_mpg = null;
_line = _pwm = _scrollpos = 0;
_grblState.Error = 0;
_grblState.State = GrblStates.Unknown;
_grblState.Substate = 0;
_grblState.MPG = false;
GrblState = _grblState;
IsMPGActive = null; //??
has_wco = false;
_MPos = _WPos = _wco = _h = string.Empty;
Position.Clear();
MachinePosition.Clear();
WorkPosition.Clear();
WorkPositionOffset.Clear();
ProgramLimits.Clear();
Set("Pn", string.Empty);
Set("A", string.Empty);
Set("FS", string.Empty);
Set("Sc", string.Empty);
Set("T", "0");
Set("Ov", string.Empty);
Set("Ex", string.Empty);
SDCardStatus = string.Empty;
HomedState = HomedState.Unknown;
if (_latheMode != LatheMode.Disabled)
{
LatheMode = LatheMode.Radius;
}
_thcv = _thcs = string.Empty;
}
public bool StreamingFeedHold(StreamingState newState, bool always)
{
bool changed = streamingState != newState;
if (always || changed)
{
switch (newState)
{
case StreamingState.Halted:
case StreamingState.FeedHold:
btnStart.IsEnabled = true;
btnHold.IsEnabled = false;
btnStop.IsEnabled = model.IsJobRunning;
break;
case StreamingState.Send:
case StreamingState.Error:
case StreamingState.Idle:
SetStreamingHandler(StreamingHandler.Previous);
break;
case StreamingState.Stop:
SetStreamingHandler(StreamingHandler.Idle);
break;
}
}
if (streamingHandler.Handler != StreamingHandler.FeedHold)
{
return(streamingHandler.Call(newState, true));
}
else if (changed)
{
model.StreamingState = streamingState = newState;
StreamingStateChanged?.Invoke(streamingState, grblState.MPG);
}
return(true);
}
public GCodeJob()
{
InitializeComponent();
this.grblState.State = GrblStates.Unknown;
this.grblState.Substate = 0;
this.GCodeView.DragEnter += new DragEventHandler(UserUI_DragEnter);
this.GCodeView.DragDrop += new DragEventHandler(UserUI_DragDrop);
this.GCodeView.AutoGenerateColumns = false;
this.btnStart.Click += new EventHandler(btnStart_Click);
this.btnStop.Click += new EventHandler(btnStop_Click);
this.btnHold.Click += new EventHandler(btnHold_Click);
this.btnRewind.Click += new EventHandler(btnRewind_Click);
this.poller = new PollGrbl();
this.polling = new Thread(new ThreadStart(poller.run));
polling.Start();
while (!polling.IsAlive)
{
;
}
}
private async void ChangeStateAsync(StreamingState newState)
{
switch (newState)
{
case StreamingState.Idle:
await ShutdownCameraAsync();
_state = newState;
break;
case StreamingState.Streaming:
PaintingCanvas.Children.Clear();
PaintingCanvas.Background = null;
if (!await StartStreamingAsync())
{
ChangeStateAsync(StreamingState.Idle);
return;
}
_state = newState;
break;
case StreamingState.Took:
if (!await TakePictureAsync())
{
ChangeStateAsync(StreamingState.Idle);
return;
}
_state = newState;
break;
default:
break;
}
}
protected override void OnUpdate()
{
var destroySubScenes = new NativeList <Entity>(Allocator.Temp);
var sceneDataFromEntity = GetComponentDataFromEntity <SceneSectionData>();
bool SceneSectionRequiresSynchronousLoading(Entity entity) =>
(EntityManager.GetComponentData <RequestSceneLoaded>(entity).LoadFlags & SceneLoadFlags.BlockOnStreamIn) != 0;
// Sections > 0 need the external references from sections 0 and will wait for it to be loaded.
// So we have to ensure sections 0 are loaded first, otherwise there's a risk of starving loading streams.
var priorityList = new NativeList <Entity>(Allocator.Temp);
using (var entities = m_PendingStreamRequests.ToEntityArray(Allocator.TempJob))
{
var priorities = new NativeArray <int>(entities.Length, Allocator.Temp);
for (int i = 0; i < entities.Length; ++i)
{
var entity = entities[i];
if (SceneSectionRequiresSynchronousLoading(entity))
{
priorities[i] = 0;
var operation = CreateAsyncLoadSceneOperation(m_SynchronousSceneLoadWorld.EntityManager, entity, true);
var result = UpdateLoadOperation(operation, m_SynchronousSceneLoadWorld, entity);
if (result == UpdateLoadOperationResult.Error)
{
m_SynchronousSceneLoadWorld.Dispose();
m_SynchronousSceneLoadWorld = new World("LoadingWorld (synchronous)");
}
Assert.AreNotEqual(UpdateLoadOperationResult.Aborted, result);
}
else if (sceneDataFromEntity[entity].SubSectionIndex == 0)
{
priorities[i] = 1;
}
else
{
priorities[i] = 2;
}
}
for (int priority = 1; priority <= 2; ++priority)
{
for (int i = 0; i < entities.Length; ++i)
{
if (priorityList.Length == LoadScenesPerFrame)
{
break;
}
if (priorities[i] == priority)
{
priorityList.Add(entities[i]);
}
}
}
}
var priorityArray = priorityList.AsArray();
foreach (var entity in priorityArray)
{
var streamIndex = CreateAsyncLoadScene(entity, false);
if (streamIndex != -1)
{
var streamingState = new StreamingState {
ActiveStreamIndex = streamIndex, Status = StreamingStatus.NotYetProcessed
};
EntityManager.AddComponentData(entity, streamingState);
}
}
Entities.With(m_UnloadStreamRequests).ForEach((Entity entity) =>
{
destroySubScenes.Add(entity);
});
foreach (var destroyScene in destroySubScenes.AsArray())
{
UnloadSectionImmediate(destroyScene);
}
if (ProcessActiveStreams())
{
EditorUpdateUtility.EditModeQueuePlayerLoopUpdate();
}
// Process unloading bundles
SceneBundleHandle.ProcessUnloadingBundles();
}
void DataReceived(string data)
{
if (data.Length == 0)
{
return;
}
if (this.GCodeView.InvokeRequired)
{
this.BeginInvoke(new GcodeCallback(DataReceived), new object[] { data });
}
else if (data.Substring(0, 1) == "<")
{
bool parseState = true;
data = data.Remove(data.Length - 1);
if (!data.Contains("|Pn:"))
{
data += "|Pn:";
}
string[] elements = data.Split('|');
foreach (string e in elements)
{
string[] pair = e.Split(':');
if (parseState)
{
SetGRBLState(pair[0].Substring(1), pair.Count() == 1 ? -1 : int.Parse(pair[1]), false);
parseState = false;
}
else if (parameters.Set(pair[0], pair[1]))
{
if (pair[0] == "MPG")
{
SetStreamingState(pair[1] == "1" ? StreamingState.Disabled : StreamingState.Idle);
}
else if (GrblParameterChanged != null)
{
GrblParameterChanged(pair[0], pair[1]);
}
}
}
if (JobTimer.IsRunning && !JobTimer.IsPaused)
{
this.txtRunTime.Text = JobTimer.RunTime;
}
}
else if (data.StartsWith("ALARM"))
{
SetGRBLState("Alarm", -1, false);
}
else if (data.StartsWith("[GC:"))
{
GrblParserState.Process(data);
}
else if (data.StartsWith("["))
{
if (!this.file.Loaded && data == "[MSG:Pgm End]")
{
SetStreamingState(StreamingState.NoFile);
}
if (GrblMessage != null)
{
GrblMessage(data);
}
}
else if (this.streamingState != StreamingState.Jogging)
{
if (data != "ok" && GrblMessage != null)
{
GrblMessage(data.StartsWith("error:") ? GrblErrors.GetMessage(data.Substring(6)) : data);
}
if (this.ACKPending > 0 && this.streamingState == StreamingState.Send)
{
this.ACKPending--;
if ((string)file.Data.Rows[this.PendingLine]["Sent"] == "*")
{
this.serialUsed -= (int)file.Data.Rows[this.PendingLine]["Length"];
}
if (this.serialUsed < 0)
{
this.serialUsed = 0;
}
file.Data.Rows[this.PendingLine]["Sent"] = data;
if (this.PendingLine > 5)
{
this.GCodeView.FirstDisplayedScrollingRowIndex = this.PendingLine - 5;
}
if (this.streamingState == StreamingState.Send)
{
if (data.StartsWith("error"))
{
SetStreamingState(StreamingState.Halted);
}
else if ((this.pgmComplete = this.PgmEndLine == this.PendingLine))
{
this.ACKPending = this.CurrLine = 0;
if (this.grblState.State == GrblStates.Idle)
{
SetGRBLState(GrblStates.Idle.ToString(), -1, true);
}
}
else
{
SendNextLine();
}
}
this.PendingLine++;
}
switch (this.streamingState)
{
case StreamingState.Send:
SendNextLine();
break;
case StreamingState.SendMDI:
if (file.commands.Count > 0)
{
Comms.com.WriteCommand(file.commands.Dequeue());
}
if (file.commands.Count == 0)
{
this.streamingState = StreamingState.Idle;
}
break;
case StreamingState.Reset:
Comms.com.WriteCommand(GrblConstants.CMD_UNLOCK);
this.streamingState = StreamingState.AwaitResetAck;
break;
case StreamingState.AwaitResetAck:
SetStreamingState(this.file.Loaded ? StreamingState.Idle : StreamingState.NoFile);
break;
}
}
}
public bool StreamingIdle(StreamingState newState, bool always)
{
bool changed = streamingState != newState || newState == StreamingState.Idle;
if (changed || always)
{
switch (newState)
{
case StreamingState.Disabled:
IsEnabled = false;
break;
case StreamingState.Idle:
case StreamingState.NoFile:
IsEnabled = !grblState.MPG;
btnStart.IsEnabled = GCode.File.IsLoaded;
btnStop.IsEnabled = false;
btnHold.IsEnabled = !grblState.MPG;
btnRewind.IsEnabled = !grblState.MPG && GCode.File.IsLoaded && job.CurrLine != 0;
model.IsJobRunning = JobTimer.IsRunning;
break;
case StreamingState.Send:
if (!string.IsNullOrEmpty(model.FileName) && !grblState.MPG)
{
model.IsJobRunning = true;
}
if (JobTimer.IsRunning)
{
SetStreamingHandler(StreamingHandler.SendFile);
}
else
{
btnStop.IsEnabled = true;
btnHold.IsEnabled = !grblState.MPG;
}
break;
case StreamingState.Start: // Streaming from SD Card
job.IsSDFile = true;
JobTimer.Start();
break;
case StreamingState.Error:
case StreamingState.Halted:
btnStart.IsEnabled = !grblState.MPG;
btnHold.IsEnabled = false;
btnStop.IsEnabled = !grblState.MPG;
break;
case StreamingState.FeedHold:
SetStreamingHandler(StreamingHandler.FeedHold);
break;
case StreamingState.ToolChange:
SetStreamingHandler(StreamingHandler.ToolChange);
break;
case StreamingState.Stop:
btnHold.IsEnabled = !(grblState.MPG || grblState.State == GrblStates.Alarm);
btnStart.IsEnabled = btnHold.IsEnabled && GCode.File.IsLoaded; //!GrblSettings.IsGrblHAL;
btnStop.IsEnabled = false;
btnRewind.IsEnabled = false;
job.IsSDFile = false;
model.IsJobRunning = false;
if (!grblState.MPG)
{
if (GrblSettings.IsGrblHAL)
{
if (!model.GrblReset)
{
Comms.com.WriteByte(GrblConstants.CMD_STOP);
}
}
else if (grblState.State == GrblStates.Hold)
{
Comms.com.WriteByte(GrblConstants.CMD_RESET);
}
}
if (JobTimer.IsRunning)
{
always = false;
model.StreamingState = streamingState = streamingState == StreamingState.Error ? StreamingState.Idle : newState;
SetStreamingHandler(StreamingHandler.AwaitIdle);
}
else if (grblState.State != GrblStates.Alarm)
{
return(streamingHandler.Call(StreamingState.Idle, true));
}
break;
}
}
if (streamingHandler.Handler != StreamingHandler.Idle)
{
return(streamingHandler.Call(newState, always));
}
else if (changed)
{
model.StreamingState = streamingState = newState;
StreamingStateChanged?.Invoke(streamingState, grblState.MPG);
}
return(true);
}
private void ResponseReceived(string response)
{
if (streamingHandler.Count)
{
if (job.ACKPending > 0 && response != "pending")
{
job.ACKPending--;
}
if (!job.IsSDFile && (string)GCode.File.Data.Rows[job.PendingLine]["Sent"] == "*")
{
job.serialUsed = Math.Max(0, job.serialUsed - (int)GCode.File.Data.Rows[job.PendingLine]["Length"]);
}
//if (streamingState == StreamingState.Send || streamingState == StreamingState.Paused)
//{
bool isError = response.StartsWith("error");
if (!job.IsSDFile)
{
GCode.File.Data.Rows[job.PendingLine]["Sent"] = response;
if (job.PendingLine > 5)
{
if (grblState.State != GrblStates.Check || isError || (job.PendingLine % 50) == 0)
{
model.ScrollPosition = job.PendingLine - 5;
}
}
if (streamingHandler.Call == StreamingAwaitAction)
{
streamingHandler.Count = false;
}
}
if (isError)
{
streamingHandler.Call(StreamingState.Error, true);
}
else if (job.PgmEndLine == job.PendingLine)
{
streamingHandler.Call(StreamingState.JobFinished, true);
}
else if (streamingHandler.Count && response == "ok")
{
SendNextLine();
}
//}
if (!job.Complete)
{
job.PendingLine++;
model.BlockExecuting = job.PendingLine;
}
}
else if (response == "ok")
{
missed++;
}
switch (streamingState)
{
case StreamingState.Send:
if (response == "start")
{
SendNextLine();
}
break;
case StreamingState.SendMDI:
if (GCode.File.Commands.Count > 0)
{
Comms.com.WriteCommand(GCode.File.Commands.Dequeue());
}
if (GCode.File.Commands.Count == 0)
{
streamingState = StreamingState.Idle;
}
break;
case StreamingState.Reset:
Comms.com.WriteCommand(GrblConstants.CMD_UNLOCK);
streamingState = StreamingState.AwaitResetAck;
break;
case StreamingState.AwaitResetAck:
streamingHandler.Call(GCode.File.IsLoaded ? StreamingState.Idle : StreamingState.NoFile, false);
break;
}
}
