public bool VerifyResponse(IDebugResponse response, DebugRequest request)
{
// Type of echoed request must match
if (response.RequestEcho.GetType() != request.GetType())
{
return(false);
}
// TODO: Compare contents of both request messages
return(true);
}
private void TryEnterBreakmode(IDebugResponse response)
{
SendRegistersResponse registersResponse = response as SendRegistersResponse;
if (registersResponse == null)
{
return;
}
currentRegisters = registersResponse.ToRegisters();
breakMode = true;
}
internal T SendAndReceive <T>(DebugRequest request, int timeout = 1000) where T : class, IDebugResponse
{
signal.Reset();
port.SendRequest(request);
if (!signal.WaitOne(timeout))
{
Logger.Current.Warning("Response not received in time.");
return(null);
}
// Verify that request is echoed correctly
// TODO: Implement equality operator for each request type
// if (lastResponse.Echo != request) return null;
IDebugResponse response = responses.Dequeue();
return(response as T);
}
internal bool SendAndWait(DebugRequest request, int timeout = 1000)
{
signal.Reset();
port.SendRequest(request);
if (!signal.WaitOne(timeout))
{
Logger.Current.Warning("Response not received in time.");
return(false);
}
// Check whether right response was received
while (responses.Count > 0)
{
IDebugResponse response = responses.Dequeue();
if (VerifyResponse(response, request))
{
return(true);
}
}
return(false);
}
public static IDebugResponse CreateResponse(DebugCommand command)
{
IDebugResponse response = null;
switch (command)
{
case DebugCommand.Continue:
response = new DebugResponse <ContinueRequest>();
break;
case DebugCommand.ReceiveRegisters:
response = new DebugResponse <ReceiveRegistersRequest>();
break;
case DebugCommand.WriteMemory:
return(null);
//response = new DebugResponse<WriteMemoryRequest>();
case DebugCommand.ReadMemory:
response = new ReadMemoryResponse();
break;
case DebugCommand.SendRegisters:
response = new SendRegistersResponse();
break;
case DebugCommand.DownloadScreen:
response = new DownloadScreenResponse();
break;
default:
return(null);
}
response.AddBytes(new byte[1] {
(byte)command
});
return(response);
}
public void Start(string portName, int baudrate, Parity parity)
{
serialPort = new SerialPort(portName, baudrate, parity, 8, StopBits.One);
serialPort.ReceivedBytesThreshold = 1;
serialPort.ReadBufferSize = 256;
serialPort.WriteBufferSize = 256;
var observablePort = Observable.FromEventPattern <SerialDataReceivedEventHandler, SerialDataReceivedEventArgs>(
ev => serialPort.DataReceived += ev,
ev => serialPort.DataReceived -= ev).Select(args =>
{
int bytesToRead = serialPort.BytesToRead;
byte[] buffer = new byte[bytesToRead];
int bytesRead = serialPort.Read(buffer, 0, bytesToRead);
return(buffer);
});
// Naieve implementation
//Queue<byte> queue = new Queue<byte>();
//observablePort.Subscribe(buffer => buffer.ToList().ForEach(b => queue.Enqueue(b)));
var observableSerialData = Observable.Create <IDebugResponse>(observer =>
{
IDebugResponse response = null;
var subscription = observablePort.Subscribe(buffer =>
{
// Check how long buffer of received bytes is
var bytesRead = buffer.Length;
int index = 0;
//
while (index < bytesRead)
{
if (response == null)
{
// Create response based on prolog byte.
response = DebugResponseFactory.CreateResponse(buffer[index++]);
//If not present logic will skip bytes until non-null response is returned
}
else
{
// Take as many bytes as are needed to complete current response
int availableBytes = Math.Min(bytesRead - index, response.RemainingBytes);
response.AddBytes(buffer.Skip(index).Take(availableBytes));
index += availableBytes;
// Even though correct number of bytes might have been added, response could still be
// incomplete because length of data to receive has changed (when length byte is available)
if (response.IsComplete)
{
// Current response is ready, so return to observers
observer.OnNext(response);
response = null;
}
}
}
});
return(Disposable.Empty);
}
);
observableSerialData.Subscribe(
response => {
DebugResponseReceived(this, new DebugResponseReceivedEventArgs(response));
});
serialPort.Open();
}
public DebugResponseReceivedEventArgs(IDebugResponse response)
{
this.Response = response;
}
