protected internal RuntimeValue_Primitive( Engine eng, WireProtocol.Commands.Debugging_Value handle ) : base( eng, handle )
{
Type t;
switch((RuntimeDataType)handle.m_dt)
{
case RuntimeDataType.DATATYPE_BOOLEAN: t = typeof( bool ); break;
case RuntimeDataType.DATATYPE_I1 : t = typeof(sbyte ); break;
case RuntimeDataType.DATATYPE_U1 : t = typeof( byte ); break;
case RuntimeDataType.DATATYPE_CHAR : t = typeof( char ); break;
case RuntimeDataType.DATATYPE_I2 : t = typeof( short ); break;
case RuntimeDataType.DATATYPE_U2 : t = typeof(ushort ); break;
case RuntimeDataType.DATATYPE_I4 : t = typeof( int ); break;
case RuntimeDataType.DATATYPE_U4 : t = typeof(uint ); break;
case RuntimeDataType.DATATYPE_R4 : t = typeof( float ); break;
case RuntimeDataType.DATATYPE_I8 : t = typeof( long ); break;
case RuntimeDataType.DATATYPE_U8 : t = typeof(ulong ); break;
case RuntimeDataType.DATATYPE_R8 : t = typeof( double); break;
default: throw new ArgumentException( String.Format( "Not a primitive: {0}", handle.m_dt ) );
}
m_value = System.Runtime.Serialization.FormatterServices.GetUninitializedObject( t );
m_eng.CreateConverter().Deserialize( m_value, handle.m_builtinValue );
}
internal EndPoint(Type type, uint id, Engine engine)
{
m_type = BinaryFormatter.LookupHash(type);
m_id = id;
m_seq = 0;
m_eng = engine;
}
public override void OnAction(IMFDeployForm form, MFDevice device)
{
if (device == null || form == null)
{
return;
}
_DBG.Engine engine = device.DbgEngine;
_DBG.WireProtocol.Commands.Monitor_MemoryMap.Range[] range = engine.MemoryMap();
if (range != null && range.Length > 0)
{
form.DumpToOutput("Type Start Size");
form.DumpToOutput("--------------------------------");
for (int i = 0; i < range.Length; i++)
{
string mem = "";
switch (range[i].m_flags)
{
case _DBG.WireProtocol.Commands.Monitor_MemoryMap.c_FLASH:
mem = "FLASH";
break;
case _DBG.WireProtocol.Commands.Monitor_MemoryMap.c_RAM:
mem = "RAM";
break;
}
form.DumpToOutput(string.Format("{0,-6} 0x{1:x08} 0x{2:x08}", mem, range[i].m_address, range[i].m_length));
}
}
}
private void buttonPing_Click(object sender, EventArgs e)
{
bool bWasStarted = EnsureDebuggerConnection();
_DBG.WireProtocol.Commands.Monitor_Ping.Reply reply;
reply = m_eng.GetConnectionSource();
if (reply != null)
{
switch (reply.m_source)
{
case _DBG.WireProtocol.Commands.Monitor_Ping.c_Ping_Source_TinyCLR:
NewText("Connected to TinyCLR\r\n");
break;
case _DBG.WireProtocol.Commands.Monitor_Ping.c_Ping_Source_TinyBooter:
NewText("Connected to TinyBooter\r\n");
break;
default:
NewText("Connected to unknown source\r\n");
break;
}
}
else
{
NewText("No connection\r\n");
}
if (!bWasStarted)
{
m_eng.Stop();
m_eng = null;
}
}
public override void OnAction(IMFDeployForm form, MFDevice device)
{
if (form == null || device == null)
{
return;
}
_DBG.Engine engine = device.DbgEngine;
_DBG.WireProtocol.Commands.Monitor_DeploymentMap.Reply reply = engine.DeploymentMap();
if (reply != null)
{
for (int i = 0; i < reply.m_count; i++)
{
_DBG.WireProtocol.Commands.Monitor_DeploymentMap.DeploymentData dd = reply.m_map[i];
form.DumpToOutput("Assembly " + i.ToString());
form.DumpToOutput(" Address: " + dd.m_address.ToString());
form.DumpToOutput(" Size : " + dd.m_size.ToString());
form.DumpToOutput(" CRC : " + dd.m_CRC.ToString());
}
if (reply.m_count == 0)
{
form.DumpToOutput("No deployed assemblies");
}
}
else
{
form.DumpToOutput("Command Not Supported by Device");
}
}
protected internal RuntimeValue_Indirect( Engine eng, WireProtocol.Commands.Debugging_Value[] array, int pos ) : base( eng, array[pos] )
{
if(++pos < array.Length)
{
m_value = Convert( eng, array, pos );
}
}
private void buttonDeployMap_Click(object sender, EventArgs e)
{
bool bWasStarted = EnsureDebuggerConnection();
Microsoft.SPOT.Debugger.WireProtocol.Commands.Monitor_DeploymentMap.Reply deployMap = m_eng.DeploymentMap();
if (deployMap != null)
{
NewText("Deployment Map\r\n");
for (int i = 0; i < deployMap.m_count; i++)
{
NewText("Assembly " + i.ToString() + ":\r\n");
NewText(string.Format("\tAddress: 0x{0:x}\r\n", deployMap.m_map[i].m_address));
NewText(string.Format("\tCRC: 0x{0:x}\r\n", deployMap.m_map[i].m_CRC));
NewText(string.Format("\tSize: 0x{0:x}\r\n", deployMap.m_map[i].m_size));
}
if (deployMap.m_count == 0)
{
NewText("No assemblies in deployment sector\r\n");
}
}
else
{
NewText("Nothing in deployment sector - or - deployment map not supported\r\n");
}
if (!bWasStarted)
{
m_eng.Stop();
m_eng = null;
}
}
private void cLRCapabilitiesToolStripMenuItem_Click(object sender, EventArgs e)
{
try
{
MFDevice device = ConnectToSelectedDevice();
if (device != null)
{
_DBG.Engine engine = device.DbgEngine;
engine.TryToConnect(0, 100, true, Microsoft.SPOT.Debugger.ConnectionSource.Unknown);
Microsoft.SPOT.CLRCapabilities caps = engine.Capabilities;
if (caps == null || caps.IsUnknown)
{
DumpToOutput(Properties.Resources.ErrorNotSupported);
DisconnectFromSelectedDevice();
return;
}
Type t = typeof(Microsoft.SPOT.CLRCapabilities);
foreach (PropertyInfo pi in t.GetProperties())
{
object o = pi.GetValue(caps, null);
try
{
if (o is Microsoft.SPOT.CLRCapabilities.LCDCapabilities ||
o is Microsoft.SPOT.CLRCapabilities.SoftwareVersionProperties ||
o is Microsoft.SPOT.CLRCapabilities.HalSystemInfoProperties ||
o is Microsoft.SPOT.CLRCapabilities.ClrInfoProperties ||
o is Microsoft.SPOT.CLRCapabilities.SolutionInfoProperties
)
{
foreach (FieldInfo fi in pi.PropertyType.GetFields())
{
DumpToOutput(string.Format("{0,-40}{1}", pi.Name + "." + fi.Name + ":", fi.GetValue(o)));
}
}
else
{
DumpToOutput(string.Format("{0,-40}{1}", pi.Name + ":", o));
}
}
catch
{
DumpToOutput(Properties.Resources.ErrorNotSupported);
}
}
DisconnectFromSelectedDevice();
}
}
catch
{
DumpToOutput(Properties.Resources.ErrorNotSupported);
}
}
internal void CreateDeploymentData(BackgroundWorker backgroundWorker, DoWorkEventArgs doWorkEventArgs)
{
MFDevice device = doWorkEventArgs.Argument as MFDevice;
_DBG.Engine eng = device.DbgEngine;
Commands.Monitor_FlashSectorMap.Reply flashMap = eng.GetFlashSectorMap();
//find deployment sectors.
uint addressStart = 0;
uint cBytes = 0;
//First, find out where the deployment sectors are
for (int iSector = flashMap.m_map.Length - 1; iSector >= 0; iSector--)
{
Commands.Monitor_FlashSectorMap.FlashSectorData flashSectorData = flashMap.m_map[iSector];
if ((flashSectorData.m_flags & Commands.Monitor_FlashSectorMap.c_MEMORY_USAGE_MASK) == Commands.Monitor_FlashSectorMap.c_MEMORY_USAGE_DEPLOYMENT)
{
addressStart = flashSectorData.m_address;
cBytes += flashSectorData.m_size;
}
}
if (cBytes == 0)
{
throw new ApplicationException("Could not find deployment sectorsd");
}
byte[] deploymentData = new byte[cBytes];
//Read deployment data
if (!CreateDeploymentReadHelper(backgroundWorker, doWorkEventArgs, eng, addressStart, deploymentData))
{
return;
}
//create deployment stream
MemoryStream deploymentStream = new MemoryStream();
deploymentStream.Write(deploymentData, 0, deploymentData.Length);
//convert to srec
MFApplicationDeploymentData data = new MFApplicationDeploymentData();
MemoryStream streamSrec = new MemoryStream();
data.BinaryData = deploymentData;
deploymentStream.Seek(0, SeekOrigin.Begin);
new BinToSrec().DoConversion(deploymentStream, streamSrec, addressStart);
//Get bytes
long pos = streamSrec.Seek(0, SeekOrigin.Current);
data.HexData = new byte[(int)pos];
streamSrec.Seek(0, SeekOrigin.Begin);
streamSrec.Read(data.HexData, 0, (int)pos);
doWorkEventArgs.Result = data;
}
private void DetachFromEngine()
{
if (m_engine != null)
{
Thread.Sleep(500);
m_engine.OnMessage -= new MessageEventHandler(OnMessage);
m_engine.OnCommand -= new CommandEventHandler(OnCommand);
m_engine.OnNoise -= new NoiseEventHandler(OnNoise);
try
{
m_engine.Dispose();
}
catch
{
// Depending on when we get called, stopping the engine
// throws anything from NullReferenceException, ArgumentNullException, IOException, etc.
}
m_engine = null;
if (m_emulatorProcess != null && !m_emulatorProcess.WaitForExit(4000))
{
if (m_emulatorProcess != null && !m_emulatorProcess.HasExited)
{
m_emulatorProcess.Kill();
m_emulatorProcess = null;
}
foreach (Process p in Process.GetProcessesByName("Microsoft.SPOT.Emulator.Sample.SampleEmulator"))
{
p.Kill();
}
}
GC.Collect();
}
///
/// Make sure process exit thread dies
///
if (m_waitForProc != null && m_waitForProc.IsAlive)
{
try
{
if (!m_waitForProc.Join(1000))
{
m_waitForProc.Abort();
}
}
catch
{
}
}
}
internal bool Disconnect()
{
if (m_eng != null)
{
m_eng.OnNoise -= new _DBG.NoiseEventHandler(OnNoiseHandler);
m_eng.OnMessage -= new _DBG.MessageEventHandler(OnMessage);
m_eng.Stop();
m_eng = null;
}
return(true);
}
protected internal RuntimeValue_ByRef( Engine eng, WireProtocol.Commands.Debugging_Value[] array, int pos ) : base( eng, array, pos )
{
if(m_value == null && m_handle.m_arrayref_referenceID != 0)
{
m_value = m_eng.GetArrayElement( m_handle.m_arrayref_referenceID, m_handle.m_arrayref_index );
}
if(m_value == null)
{
throw new ArgumentException();
}
}
public static uint AppDomainIdFromCall (Engine engine, WireProtocol.Commands.Debugging_Thread_Stack.Reply.Call call)
{
uint appDomainId = CorDebugAppDomain.CAppDomainIdForNoAppDomainSupport;
if (engine.Capabilities.AppDomains) {
WireProtocol.Commands.Debugging_Thread_Stack.Reply.CallEx callEx = call as WireProtocol.Commands.Debugging_Thread_Stack.Reply.CallEx;
appDomainId = callEx.m_appDomainID;
}
return appDomainId;
}
private void buttonRebootAndStop_Click(object sender, EventArgs e)
{
bool bWasStarted = EnsureDebuggerConnection( );
m_eng.RebootDevice(_DBG.Engine.RebootOption.EnterBootloader);
if (!bWasStarted)
{
m_eng.Stop();
m_eng = null;
}
}
/// <include file='doc\ConnectionManager.uex' path='docs/doc[@for="Manager.Connect"]/*' />
public _DBG.Engine Connect(_DBG.PortDefinition pd)
{
_DBG.Engine eng = new _DBG.Engine();
GatewayProxy gwp = new GatewayProxy();
GatewayStub gws = m_mgr.Connect(pd, gwp);
gwp.SetOwner(eng);
eng.SetController(gwp);
return(eng);
}
public override void OnAction(IMFDeployForm form, MFDevice device)
{
if (form == null || device == null)
{
return;
}
_DBG.Engine engine = device.DbgEngine;
engine.RebootDevice(Microsoft.SPOT.Debugger.Engine.RebootOption.EnterBootloader);
device.ConnectToTinyBooter();
}
private void Disconnect()
{
if (m_state == ProfilingState.Disconnected)
{
return;
}
if (m_state == ProfilingState.Connected)
{
if (m_session != null)
{
m_session.Disconnect();
}
if (m_exporter != null)
{
m_exporter.Close();
}
}
try
{
lock (m_engine)
{
m_engine.Stop();
}
}
catch { } //Depending on when we get called, stopping the engine throws anything from NullReferenceException, ArgumentNullException, IOException, etc.
m_engine = null;
if (m_state == ProfilingState.Connected)
{
LogText("Disconnected from TinyCLR.");
}
KillEmulator();
ProfilingState oldstate = m_state;
m_state = ProfilingState.Disconnected;
EnableUI();
if (!m_closing && oldstate == ProfilingState.Connected && m_exporter is _PRF.Exporter_CLRProfiler)
{
clrProfiler.LoadLogFile(m_exporter.FileName);
EnableDisableViewMenuItems();
}
}
public override void OnAction(IMFDeployForm form, MFDevice device)
{
_DBG.Engine engine = device.DbgEngine;
if (device.ConnectToTinyBooter())
{
// ExecuteMemory at address 0 performs an enumerate and execute, which
// will clear the bootloader entry flag
engine.ExecuteMemory(0);
}
else
{
form.DumpToOutput("Unable to connect to TinyBooter!");
}
}
void Run()
{
m_eng.Silent = true;
m_eng.Start();
m_eng.OnNoise += new _DBG.NoiseEventHandler(OnNoise);
m_eng.OnMessage += new _DBG.MessageEventHandler(OnMessage);
Console.WriteLine("####### PRESS RETURN TO EXIT #######");
Console.ReadLine();
m_eng.Stop();
m_eng = null;
}
protected internal RuntimeValue_String( Engine eng, WireProtocol.Commands.Debugging_Value handle ) : base( eng, handle )
{
byte[] buf = handle.m_builtinValue;
if(handle.m_bytesInString >= buf.Length)
{
if(m_eng.ReadMemory( m_handle.m_charsInString, m_handle.m_bytesInString, out buf ) == false)
{
// Revert to the preview on failure
buf = handle.m_builtinValue;
}
}
m_value = WireProtocol.Commands.GetZeroTerminatedString( buf, true );
}
protected override void OnRun (DebuggerStartInfo startInfo)
{
var mfStartInfo = startInfo as MicroFrameworkDebuggerStartInfo;
if (mfStartInfo == null)//This should never happen...
throw new InvalidOperationException ();
var command = mfStartInfo.MFCommand;
var portDefinition = ((MicroFrameworkExecutionTarget)command.Target).PortDefinition;
using (var deployEngine = new Engine (portDefinition)) {
deployEngine.Start ();
string newCommand = "/CorDebug_DeployDeviceName:" + portDefinition.PersistName;
var listOfAseemblies = new ArrayList ();
//TODO: Check if this is robust enough will "be" and "le" really always be in output folder?
OutputDirectory = command.OutputDirectory;
string dir = command.OutputDirectory;
if (deployEngine.IsTargetBigEndian)
dir = Path.Combine (dir, "be");
else
dir = Path.Combine (dir, "le");
string[] files = Directory.GetFiles (dir, "*.pe");
foreach (var file in files) {
newCommand = "/load:" + file + " " + newCommand;
using (var fs = new FileStream (file, FileMode.Open)) {
byte[] data = new byte[fs.Length];
fs.Read (data, 0, data.Length);
listOfAseemblies.Add (data);
}
}
startInfo.Command = newCommand;
deployEngine.Deployment_Execute (listOfAseemblies, false, (str) => OnDebuggerOutput (false, "Deploy: " + str + Environment.NewLine));
deployEngine.RebootDevice (Engine.RebootOption.RebootClrWaitForDebugger);
}
VsPackage.MessageCentre.Session = this;
try {
CorDebugProcess process = CorDebugProcess.CreateProcess (new DebugPortSupplier ().FindPort ("USB"), startInfo.Command);
process.StartDebugging (this, false);
// StartDebugging() will either get a connected device into a debuggable state and start the dispatch thread, or throw.
} catch (ProcessExitException) {
VsPackage.MessageCentre.DeploymentMsg (DiagnosticStrings.InitializeProcessFailedProcessDied);
} catch (Exception ex) {
VsPackage.MessageCentre.DeploymentMsg (DiagnosticStrings.InitializeProcessFailed);
VsPackage.MessageCentre.InternalErrorMsg (false, ex.Message);
}
}
private void buttonCLRCap_Click(object sender, EventArgs e)
{
bool bWasStarted = EnsureDebuggerConnection();
Microsoft.SPOT.CLRCapabilities CLRCapabilities = m_eng.Capabilities;
NewText("CLR Capabilities\r\n");
if (CLRCapabilities.FloatingPoint)
{
NewText("Floating Point \r\n");
}
if (CLRCapabilities.SourceLevelDebugging)
{
NewText("Source Level Debugging \r\n");
}
if (CLRCapabilities.AppDomains)
{
NewText("Application Domain \r\n");
}
if (CLRCapabilities.ExceptionFilters)
{
NewText("Exception filter\r\n");
}
if (CLRCapabilities.IncrementalDeployment)
{
NewText("Incremental Deployment \r\n");
}
if (CLRCapabilities.SoftReboot)
{
NewText("Soft Reboot \r\n");
}
NewText("Done\r\n");
if (!bWasStarted)
{
m_eng.Stop();
m_eng = null;
}
}
private bool CreateDeploymentReadHelper(
BackgroundWorker backgroundWorker,
DoWorkEventArgs doWorkEventArgs,
Microsoft.SPOT.Debugger.Engine engine,
uint address,
byte[] buf
)
{
uint bytesTotal = (uint)buf.Length;
uint bytesRemaining = bytesTotal;
uint bytesRead = 0;
while (bytesRemaining > 0)
{
uint cBytes = System.Math.Min(1024, bytesRemaining);
byte[] bufT;
if (!engine.ReadMemory(address, cBytes, out bufT))
{
throw new ApplicationException("Cannot read data");
}
bufT.CopyTo(buf, bytesRead);
address += cBytes;
bytesRead += cBytes;
bytesRemaining -= cBytes;
if (backgroundWorker.WorkerReportsProgress)
{
int progress = (int)(100.0 * (double)bytesRead / (double)bytesTotal);
backgroundWorker.ReportProgress(progress);
}
if (backgroundWorker.CancellationPending)
{
doWorkEventArgs.Cancel = true;
return(false);
}
}
return(true);
}
void Stop()
{
if (m_worker != null)
{
m_worker.Abort();
m_worker.Join();
m_worker = null;
}
if (m_fl != null)
{
m_fl.Stop();
m_fl = null;
}
if (m_eng != null)
{
m_eng.Stop();
m_eng = null;
}
}
private bool CreateDeploymentReadHelper(
BackgroundWorker backgroundWorker,
DoWorkEventArgs doWorkEventArgs,
Microsoft.SPOT.Debugger.Engine engine,
ref uint address,
uint addressStart,
uint addressEnd,
uint bytes,
out byte[] data
)
{
data = new byte[bytes];
uint iByte = 0;
while (bytes > 0)
{
uint cBytes = System.Math.Min(1024, bytes);
byte[] buf;
if (!engine.ReadMemory(address, cBytes, out buf))
{
throw new ApplicationException("Cannot read data");
}
buf.CopyTo(data, iByte);
address += cBytes;
iByte += cBytes;
bytes -= cBytes;
if (backgroundWorker.CancellationPending)
{
doWorkEventArgs.Cancel = true;
return(false);
}
}
return(true);
}
/// <summary>
///
/// </summary>
/// <returns>Returns the previous conneciton state of the debugger engine</returns>
private bool EnsureDebuggerConnection()
{
if (m_eng == null)
{
_DBG.PortDefinition pd = GetSelectedPortDefinition();
m_eng = new _DBG.Engine(pd);
m_eng.OnNoise += new _DBG.NoiseEventHandler(OnNoise);
m_eng.OnMessage += new _DBG.MessageEventHandler(OnMessage);
m_eng.Start();
m_eng.TryToConnect(5, 100);
return(false);
}
// TryToConnect calls GetCLRCapabilities which prevents a bunch of asserts
m_eng.TryToConnect(5, 100);
return(true);
}
public ProfilerSession(_DBG.Engine engine)
{
if (engine == null)
{
throw new ArgumentNullException();
}
m_connected = true;
m_engine = engine;
m_engine.OnCommand += new _DBG.CommandEventHandler(OnDeviceCommand);
m_incomingStream = new _DBG.BitStream(true);
m_startTime = 0;
m_lastKnownTime = 0;
m_currentHeapDump = null;
m_threadCallStacks = new Dictionary<uint, Stack<uint>>();
m_liveObjectTable = new List<uint>();
m_firstPacket = true;
m_receiverThread = new Thread(WorkerThread);
m_receiverThread.Start();
}
public ProfilerSession(_DBG.Engine engine)
{
if (engine == null)
{
throw new ArgumentNullException();
}
m_connected = true;
m_engine = engine;
m_engine.OnCommand += new _DBG.CommandEventHandler(OnDeviceCommand);
m_incomingStream = new _DBG.BitStream(true);
m_startTime = 0;
m_lastKnownTime = 0;
m_currentHeapDump = null;
m_threadCallStacks = new Dictionary <uint, Stack <uint> >();
m_liveObjectTable = new List <uint>();
m_firstPacket = true;
m_receiverThread = new Thread(WorkerThread);
m_receiverThread.Start();
}
private void Disconnect()
{
if (m_ah != null)
{
m_ah.Stop();
m_ah.Dispose();
m_ah = null;
}
if (m_eng != null)
{
if (m_deviceRunning)
{
m_eng.ResumeExecution();
}
m_eng.Stop();
m_eng = null;
}
m_deviceRunning = false;
}
private void buttonEraseDeployment_Click( object sender, EventArgs e )
{
bool bWasStarted = EnsureDebuggerConnection();
Cursor old = Cursor.Current;
Cursor = Cursors.WaitCursor;
buttonEraseDeployment.Text = "Erasing...";
buttonEraseDeployment.Update();
NewText( "Erasing Deployment Sector...\r\n" );
try
{
_DBG.WireProtocol.Commands.Monitor_Ping.Reply ping = m_eng.GetConnectionSource();
if(ping == null)
{
NewText("Unable to connect to device\r\n");
return;
}
bool fClrConnection = ping.m_source == _DBG.WireProtocol.Commands.Monitor_Ping.c_Ping_Source_TinyCLR;
if (fClrConnection)
{
m_eng.PauseExecution();
}
_DBG.WireProtocol.Commands.Monitor_FlashSectorMap.Reply status = m_eng.GetFlashSectorMap() as _DBG.WireProtocol.Commands.Monitor_FlashSectorMap.Reply;
if (status == null)
{
NewText( "Erase Deployment may Not be supported on this device build\r\n" );
}
else
{
const uint c_deployFlag = _DBG.WireProtocol.Commands.Monitor_FlashSectorMap.c_MEMORY_USAGE_DEPLOYMENT;
const uint c_usageMask = _DBG.WireProtocol.Commands.Monitor_FlashSectorMap.c_MEMORY_USAGE_MASK;
foreach( _DBG.WireProtocol.Commands.Monitor_FlashSectorMap.FlashSectorData sector in status.m_map)
{
if (c_deployFlag == (c_usageMask & sector.m_flags))
{
NewText(string.Format("Erasing sector at 0x{0:x08}\r\n", sector.m_address));
m_eng.EraseMemory(sector.m_address, sector.m_size);
}
}
if (fClrConnection)
{
m_eng.RebootDevice(_DBG.Engine.RebootOption.RebootClrOnly);
}
NewText("Erase Deployment Successfull");
}
}
catch( Exception ex )
{
NewText( "Exception: " + ex.Message + "\r\n" );
}
finally
{
buttonEraseDeployment.Text = "Erase Deployment";
Cursor = old;
if( !bWasStarted )
{
m_eng.Stop();
m_eng = null;
}
}
}
SerialDump(string[] args)
{
_DBG.PortDefinition pd = null;
string port = null;
uint baudrate = 0;
for (int i = 0; i < args.Length; i++)
{
string arg = args[i];
if (String.Compare(arg, "-dump", true) == 0)
{
m_output = new FileStream(args[++i], FileMode.Create, FileAccess.ReadWrite, FileShare.Read);
continue;
}
if (String.Compare(arg, "-timestamp", true) == 0)
{
m_fTimestamp = true;
continue;
}
if (String.Compare(arg, "-usb", true) == 0)
{
m_fUsb = true;
continue;
}
if (port == null)
{
port = arg; continue;
}
if (baudrate == 0)
{
baudrate = UInt32.Parse(arg); continue;
}
}
if (m_fUsb)
{
_DBG.PortDefinition[] ports = _DBG.AsyncUsbStream.EnumeratePorts();
if (port == null)
{
if (ports.Length == 0)
{
System.Console.WriteLine("No Usb SPOT device is present");
throw new ApplicationException();
}
else if (ports.Length == 1)
{
pd = ports[0];
}
else
{
System.Console.WriteLine("More than one USB SPOT device is present");
System.Console.WriteLine("To dump data from a specific device, choose your device from the list below and execute:");
System.Console.WriteLine(" serialdump -usb <device> ");
System.Console.WriteLine("");
//
// More than one usb device attached; dump list so user can choose
//
for (int i = 0; i < ports.Length; ++i)
{
System.Console.WriteLine("Device " + i + ": " + ports[i].DisplayName);
}
throw new ApplicationException();
}
}
else
{
foreach (_DBG.PortDefinition pd2 in ports)
{
if (port.Equals(pd2.DisplayName))
{
pd = pd2;
break;
}
}
}
}
if (pd == null)
{
if (port == null)
{
port = "COM1";
}
if (baudrate == 0)
{
baudrate = 115200;
}
pd = _DBG.PortDefinition.CreateInstanceForSerial(port, port, baudrate);
}
m_eng = new _DBG.Engine(pd);
}
/// <summary>
///
/// </summary>
/// <returns>Returns the previous conneciton state of the debugger engine</returns>
private bool EnsureDebuggerConnection()
{
if( m_eng == null )
{
_DBG.PortDefinition pd = GetSelectedPortDefinition();
m_eng = new _DBG.Engine( pd );
m_eng.OnNoise += new _DBG.NoiseEventHandler( OnNoise );
m_eng.OnMessage += new _DBG.MessageEventHandler( OnMessage );
m_eng.Start();
m_eng.TryToConnect(5, 100);
return false;
}
// TryToConnect calls GetCLRCapabilities which prevents a bunch of asserts
m_eng.TryToConnect(5, 100);
return true;
}
private void buttonCLRCap_Click( object sender, EventArgs e )
{
bool bWasStarted = EnsureDebuggerConnection();
Microsoft.SPOT.CLRCapabilities CLRCapabilities = m_eng.Capabilities;
NewText( "CLR Capabilities\r\n" );
if (CLRCapabilities.FloatingPoint)
{
NewText( "Floating Point \r\n" );
}
if (CLRCapabilities.SourceLevelDebugging)
{
NewText( "Source Level Debugging \r\n" );
}
if (CLRCapabilities.AppDomains)
{
NewText( "Application Domain \r\n" );
}
if (CLRCapabilities.ExceptionFilters)
{
NewText( "Exception filter\r\n" );
}
if (CLRCapabilities.IncrementalDeployment)
{
NewText( "Incremental Deployment \r\n" );
}
if (CLRCapabilities.SoftReboot)
{
NewText( "Soft Reboot \r\n" );
}
NewText( "Done\r\n" );
if( !bWasStarted )
{
m_eng.Stop();
m_eng = null;
}
}
static internal object GetObject(Engine eng, EndPoint ep, Type classToRemote)
{
uint id = eng.RpcGetUniqueEndpointId();
EndPoint epLocal = new EndPoint(typeof(EndPointProxy), id, eng);
EndPointProxy prx = new EndPointProxy(eng, epLocal, ep, classToRemote);
return prx.GetTransparentProxy();
}
public void Dispose()
{
try
{
if (m_from != null)
{
m_from.Deregister();
}
}
catch
{
}
finally
{
m_eng = null;
m_from = null;
m_to = null;
m_type = null;
}
}
protected internal RuntimeValue_Object( Engine eng, WireProtocol.Commands.Debugging_Value[] array, int pos ) : base( eng, array, pos )
{
}
public EndPoint(Type type, uint id, object server, Type classToRemote, Engine engine)
: this(type, id, engine)
{
m_server = server;
m_serverClassToRemote = classToRemote;
}
private void EraseDialog_Load(object sender, EventArgs e)
{
_DBG.Engine engine = m_device.DbgEngine;
_DBG.WireProtocol.Commands.Monitor_FlashSectorMap.Reply reply = engine.GetFlashSectorMap();
if (reply != null)
{
Dictionary <EraseOptions, _DBG.WireProtocol.Commands.Monitor_FlashSectorMap.FlashSectorData> hashBlockType = new Dictionary <EraseOptions, _DBG.WireProtocol.Commands.Monitor_FlashSectorMap.FlashSectorData>();
Dictionary <EraseOptions, string> usageNameHash = new Dictionary <EraseOptions, string>();
for (int i = 0; i < reply.m_map.Length; i++)
{
_DBG.WireProtocol.Commands.Monitor_FlashSectorMap.FlashSectorData fsd = reply.m_map[i];
string usage = "";
EraseOptions eo = (EraseOptions)(-1);
switch (fsd.m_flags & _DBG.WireProtocol.Commands.Monitor_FlashSectorMap.c_MEMORY_USAGE_MASK)
{
case _DBG.WireProtocol.Commands.Monitor_FlashSectorMap.c_MEMORY_USAGE_BOOTSTRAP:
//usage = "Bootstrap";
break;
case _DBG.WireProtocol.Commands.Monitor_FlashSectorMap.c_MEMORY_USAGE_CONFIG:
case _DBG.WireProtocol.Commands.Monitor_FlashSectorMap.c_MEMORY_USAGE_CODE:
if (m_device.DbgEngine.ConnectionSource == _DBG.ConnectionSource.TinyBooter)
{
usage = "Firmware";
eo = EraseOptions.Firmware;
}
break;
case _DBG.WireProtocol.Commands.Monitor_FlashSectorMap.c_MEMORY_USAGE_DEPLOYMENT:
usage = "Deployment";
eo = EraseOptions.Deployment;
break;
case _DBG.WireProtocol.Commands.Monitor_FlashSectorMap.c_MEMORY_USAGE_UPDATE:
usage = "Update Storage";
eo = EraseOptions.UpdateStorage;
break;
case _DBG.WireProtocol.Commands.Monitor_FlashSectorMap.c_MEMORY_USAGE_FS:
usage = "File System";
eo = EraseOptions.FileSystem;
break;
case _DBG.WireProtocol.Commands.Monitor_FlashSectorMap.c_MEMORY_USAGE_SIMPLE_B:
case _DBG.WireProtocol.Commands.Monitor_FlashSectorMap.c_MEMORY_USAGE_SIMPLE_A:
usage = "Simple Storage";
eo = EraseOptions.SimpleStorage;
break;
case _DBG.WireProtocol.Commands.Monitor_FlashSectorMap.c_MEMORY_USAGE_STORAGE_A:
case _DBG.WireProtocol.Commands.Monitor_FlashSectorMap.c_MEMORY_USAGE_STORAGE_B:
usage = "User Storage";
eo = EraseOptions.UserStorage;
break;
}
if (eo != (EraseOptions)(-1))
{
if (hashBlockType.ContainsKey(eo))
{
_DBG.WireProtocol.Commands.Monitor_FlashSectorMap.FlashSectorData prev = hashBlockType[eo];
if (prev.m_address + prev.m_size == fsd.m_address)
{
prev.m_size += fsd.m_size;
hashBlockType[eo] = prev;
}
}
else
{
hashBlockType[eo] = fsd;
usageNameHash[eo] = usage;
}
}
}
foreach (EraseOptions eo in hashBlockType.Keys)
{
ListViewItem lvi = listViewEraseSectors.Items.Add(new ListViewItem(new string[] { usageNameHash[eo], string.Format("0x{0:X08}", hashBlockType[eo].m_address), string.Format("0x{0:X08}", hashBlockType[eo].m_size) }));
lvi.Tag = eo;
if (eo != EraseOptions.Firmware)
{
lvi.Checked = true;
}
}
}
}
static internal RuntimeValue Convert( Engine eng, WireProtocol.Commands.Debugging_Value[] array )
{
if(array == null || array.Length == 0) return null;
return Convert( eng, array, 0 );
}
private void ConnectToDevice(string buildPath, string exePath, ArrayList referenceList)
{
TestSystem.IncludesDeviceTest = true;
PortDefinition port = Utils.GetPort(m_device, m_transport, exePath);
try
{
for (int retry = 0; retry < 3; retry++)
{
m_engine = new Microsoft.SPOT.Debugger.Engine(port);
m_engine.StopDebuggerOnConnect = true;
m_engine.Start();
bool connected = false;
connected = m_engine.TryToConnect(200, 500, true, ConnectionSource.TinyCLR);
if (connected)
{
m_engine.PauseExecution();
if (!string.Equals(m_transport.ToLower(), "emulator"))
{
// Deploy the test files to the device.
Utils.DeployToDevice(buildPath, referenceList, m_engine, m_transport, m_isDevEnvironment, m_assemblyName);
// Connect to the device and execute the deployed test.
m_engine.RebootDevice(Microsoft.SPOT.Debugger.Engine.RebootOption.RebootClrWaitForDebugger);
// give the device some time to restart (especially for tcp/ip)
Thread.Sleep(500);
if (m_engine.PortDefinition is PortDefinition_Tcp)
{
Thread.Sleep(1000);
}
connected = false;
connected = m_engine.TryToConnect(200, 500, true, ConnectionSource.TinyCLR);
}
if (!connected)
{
DetachFromEngine();
throw new ApplicationException("Reboot Failed");
}
AttachToProcess();
m_engine.ThrowOnCommunicationFailure = true;
m_engine.OnMessage += new MessageEventHandler(OnMessage);
m_engine.OnCommand += new CommandEventHandler(OnCommand);
m_engine.OnNoise += new NoiseEventHandler(OnNoise);
Console.WriteLine("\tExecuting the device test..");
m_initialTime = DateTime.Now;
m_engine.ResumeExecution();
m_deviceDone.WaitOne();
break;
}
else
{
DetachFromEngine();
//throw new ApplicationException("Connection failed");
}
}
}
catch (Exception ex)
{
DetachFromEngine();
throw new ApplicationException("Connection failed: " + ex.ToString());
}
}
internal void CreateDeploymentData(BackgroundWorker backgroundWorker, DoWorkEventArgs doWorkEventArgs)
{
MFDevice device = doWorkEventArgs.Argument as MFDevice;
_DBG.Engine eng = device.DbgEngine;
Commands.Monitor_FlashSectorMap.Reply flashMap = eng.GetFlashSectorMap();
//find deployment sectors.
MemoryStream deploymentStream = new MemoryStream();
//this duplicates LoadDeploymentAssemblies logic, as how to find assemblies in the deployment sectors
int iSectorStart = -1, iSectorEnd = 0;
uint address, addressAssemblyStart, addressStart = 0, addressEnd = 0;
int iSector;
//First, find out where the deployment sectors are
for (iSector = 0; iSector < flashMap.m_map.Length; iSector++)
{
Commands.Monitor_FlashSectorMap.FlashSectorData flashSectorData = flashMap.m_map[iSector];
if ((flashSectorData.m_flags & Commands.Monitor_FlashSectorMap.c_MEMORY_USAGE_MASK) == Commands.Monitor_FlashSectorMap.c_MEMORY_USAGE_DEPLOYMENT)
{
if (iSectorStart < 0)
{
iSectorStart = iSector;
addressStart = flashSectorData.m_address;
}
iSectorEnd = iSector;
addressEnd = flashSectorData.m_address + flashSectorData.m_size;
}
}
if (iSectorStart < 0)
{
throw new ApplicationException("Could not find deployment sectors");
}
address = addressStart;
iSector = iSectorStart;
while (true)
{
if (backgroundWorker.WorkerReportsProgress)
{
int progress = (int)(100.0 * (double)address / (double)addressEnd);
backgroundWorker.ReportProgress(progress);
}
//read assembly header
uint assemblyHeaderSize = (uint)Marshal.SizeOf(typeof(CLR_RECORD_ASSEMBLY));
byte[] assemblyHeaderBytes = null;
byte[] assemblyDataBytes = null;
if (address + assemblyHeaderSize >= addressEnd)
{
break;
}
addressAssemblyStart = address;
if (!CreateDeploymentReadHelper(backgroundWorker, doWorkEventArgs, eng, ref address, addressStart, addressEnd, assemblyHeaderSize, out assemblyHeaderBytes))
{
return;
}
GCHandle gch = GCHandle.Alloc(assemblyHeaderBytes, GCHandleType.Pinned);
CLR_RECORD_ASSEMBLY assemblyHeader = (CLR_RECORD_ASSEMBLY)Marshal.PtrToStructure(gch.AddrOfPinnedObject(), typeof(CLR_RECORD_ASSEMBLY));
gch.Free();
//check if valid header
//check marker
bool fValidAssembly = assemblyHeader.marker == CLR_RECORD_ASSEMBLY.MARKER_ASSEMBLY_V1;
if (fValidAssembly)
{
//check header crc
uint crcHeader = assemblyHeader.headerCRC;
//clear headerCRC
int headerCRCOffset = 8;
int headerCRCSize = 4;
Array.Clear(assemblyHeaderBytes, headerCRCOffset, headerCRCSize);
uint crc = _DBG.CRC.ComputeCRC(assemblyHeaderBytes, 0);
//Reset headerCRC
Array.Copy(BitConverter.GetBytes(crcHeader), 0, assemblyHeaderBytes, headerCRCOffset, headerCRCSize);
fValidAssembly = (crcHeader == crc);
}
if (fValidAssembly)
{
uint assemblyTotalSize = assemblyHeader.startOfTables[CLR_RECORD_ASSEMBLY.TBL_EndOfAssembly];
uint assemblyDataSize = assemblyTotalSize - assemblyHeaderSize;
if (address + assemblyDataSize >= addressEnd)
{
break;
}
//read body
if (!CreateDeploymentReadHelper(backgroundWorker, doWorkEventArgs, eng, ref address, addressStart, addressEnd, assemblyDataSize, out assemblyDataBytes))
{
return;
}
//check if valid body (crc)
uint crc = _DBG.CRC.ComputeCRC(assemblyDataBytes, 0);
fValidAssembly = (crc == assemblyHeader.assemblyCRC);
}
if (fValidAssembly)
{
// add to compact stream
deploymentStream.Write(assemblyHeaderBytes, 0, assemblyHeaderBytes.Length);
deploymentStream.Write(assemblyDataBytes, 0, assemblyDataBytes.Length);
// make sure we are on 4 byte boundary
if (0 != (address % sizeof(UInt32)))
{
byte[] buff = new byte[sizeof(UInt32) - (address % sizeof(UInt32))];
deploymentStream.Write(buff, 0, buff.Length);
address += sizeof(UInt32) - (address % sizeof(UInt32));
}
}
else
{
//if no, clear assemblyData, jump to next sector (if in middle of sector), or finish (if at beginning of sector)
while (iSector < iSectorEnd)
{
Commands.Monitor_FlashSectorMap.FlashSectorData flashSectorData = flashMap.m_map[iSector];
if (addressAssemblyStart >= flashSectorData.m_address && addressAssemblyStart < flashSectorData.m_address + flashSectorData.m_size)
{
// jump to next sector
address = flashSectorData.m_address + flashSectorData.m_size;
System.Diagnostics.Debug.Assert(address == flashMap.m_map[iSector + 1].m_address);
break;
}
iSector++;
}
}
}
//Finished reading
//convert to srec
MFApplicationDeploymentData data = new MFApplicationDeploymentData();
long deploymentLength = deploymentStream.Seek(0, SeekOrigin.Current);
MemoryStream streamSrec = new MemoryStream();
deploymentStream.Seek(0, SeekOrigin.Begin);
data.BinaryData = new byte[(int)deploymentLength];
deploymentStream.Read(data.BinaryData, 0, (int)deploymentLength);
deploymentStream.Seek(0, SeekOrigin.Begin);
new BinToSrec().DoConversion(deploymentStream, streamSrec, flashMap.m_map[iSectorStart].m_address);
//add zero bytes to all other deployment sectors?
//Get bytes
long pos = streamSrec.Seek(0, SeekOrigin.Current);
data.HexData = new byte[pos];
streamSrec.Seek(0, SeekOrigin.Begin);
streamSrec.Read(data.HexData, 0, (int)pos);
doWorkEventArgs.Result = data;
}
private void bwConnecter_DoWork(System.Object sender, DoWorkEventArgs e)
{
BackgroundConnectorArguments bca = (BackgroundConnectorArguments)e.Argument;
_DBG.PortDefinition port = bca.connectPort;
Debug.Assert(m_engine == null);
e.Result = false;
#if USE_CONNECTION_MANAGER
m_engine = m_port.DebugPortSupplier.Manager.Connect(port);
#else
m_engine = new _DBG.Engine(port);
#endif
m_killEmulator = false;
lock (m_engine)
{
m_engine.StopDebuggerOnConnect = true;
m_engine.OnCommand += new _DBG.CommandEventHandler(OnWPCommand);
m_engine.OnMessage += new _DBG.MessageEventHandler(OnWPMessage);
m_engine.Start();
const int retries = 50;
bool connected = false;
for (int i = 0; connected == false && i < retries; i++)
{
if (bwConnecter.CancellationPending)
{
e.Cancel = true;
return;
}
connected = m_engine.TryToConnect(1, 100, false, _DBG.ConnectionSource.TinyCLR);
}
if (connected)
{
if (m_engine.Capabilities.Profiling == false)
{
throw new ApplicationException("This device is not running a version of TinyCLR that supports profiling.");
}
//Move IsDeviceInInitializeState(), IsDeviceInExitedState(), GetDeviceState(),EnsureProcessIsInInitializedState() to Debugger.dll?
uint executionMode = 0;
m_engine.SetExecutionMode(0, 0, out executionMode);
if (bca.reboot || (executionMode & _WP.Commands.Debugging_Execution_ChangeConditions.c_State_Mask) != _WP.Commands.Debugging_Execution_ChangeConditions.c_State_Initialize)
{
m_engine.RebootDevice(_DBG.Engine.RebootOption.RebootClrWaitForDebugger);
m_engine.TryToConnect(10, 1000);
m_engine.SetExecutionMode(0, 0, out executionMode);
Debug.Assert((executionMode & _WP.Commands.Debugging_Execution_ChangeConditions.c_State_Mask) == _WP.Commands.Debugging_Execution_ChangeConditions.c_State_Initialize);
}
m_engine.ThrowOnCommunicationFailure = true;
m_session = new _PRF.ProfilerSession(m_engine);
if (m_exporter != null)
{
m_exporter.Close();
}
switch (bca.exporter)
{
case BackgroundConnectorArguments.ExporterType.CLRProfiler:
m_exporter = new _PRF.Exporter_CLRProfiler(m_session, bca.outputFileName);
break;
#if DEBUG
case BackgroundConnectorArguments.ExporterType.OffProf:
m_exporter = new _PRF.Exporter_OffProf(m_session, bca.outputFileName);
break;
#endif
default:
throw new ArgumentException("Unsupported export format");
}
m_session.EnableProfiling();
e.Result = true;
}
}
return;
}
/// <summary>
/// Attempt to establish a connection with TinyBooter (with reboot if necessary)
/// </summary>
/// <returns>true connection was made, false otherwise</returns>
public bool ConnectToTinyBooter()
{
bool ret = false;
if (m_eng == null)
{
_DBG.PortDefinition pd = m_portTinyBooter;
try
{
if (m_eng == null)
{
m_eng = new _DBG.Engine(pd);
m_eng.OnNoise += new _DBG.NoiseEventHandler(OnNoiseHandler);
m_eng.OnMessage += new _DBG.MessageEventHandler(OnMessage);
m_eng.Start();
m_eng.TryToConnect(5, 100, true, _DBG.ConnectionSource.Unknown);
}
}
catch
{
}
}
if (m_eng != null)
{
if (m_eng.ConnectionSource == _DBG.ConnectionSource.TinyBooter)
{
return(true);
}
m_eng.RebootDevice(_DBG.Engine.RebootOption.EnterBootloader);
// tinyBooter is only com port so
if (m_port is _DBG.PortDefinition_Tcp)
{
Disconnect();
m_port = m_portTinyBooter;
// digi takes forever to reset
if (!Connect(60000, true))
{
Console.WriteLine(Properties.Resources.ErrorUnableToConnectToTinyBooterSerial);
return(false);
}
}
bool fConnected = false;
for (int i = 0; i < 40; i++)
{
if (EventCancel.WaitOne(0, false))
{
throw new MFUserExitException();
}
if (fConnected = m_eng.TryToConnect(0, 500, true, _DBG.ConnectionSource.Unknown))
{
_WP.Commands.Monitor_Ping.Reply reply = m_eng.GetConnectionSource();
ret = (reply.m_source == _WP.Commands.Monitor_Ping.c_Ping_Source_TinyBooter);
break;
}
}
if (!fConnected)
{
Console.WriteLine(Properties.Resources.ErrorUnableToConnectToTinyBooter);
}
}
return(ret);
}
protected internal RuntimeValue_Array( Engine eng, WireProtocol.Commands.Debugging_Value handle ) : base( eng, handle )
{
}
private bool RebootDevice(Engine.RebootOption option)
{
PortFilter[] args = { };
switch (this.Transport.ToLower())
{
case "emulator":
args = new PortFilter[] { PortFilter.Emulator };
break;
case "serial":
args = new PortFilter[] { PortFilter.Serial };
break;
case "tcpip":
args = new PortFilter[] { PortFilter.TcpIp };
break;
case "usb":
args = new PortFilter[] { PortFilter.Usb };
break;
}
ArrayList list = PortDefinition.Enumerate(args);
PortDefinition port = null;
foreach (object prt in list)
{
port = (PortDefinition)prt;
if (port.DisplayName.ToLower().Contains(this.Device.ToLower()))
{
break;
}
else
{
port = null;
}
}
if (null == port)
{
return false;
}
using (Engine engine = new Engine(port))
{
engine.Start();
bool connect = false;
connect = engine.TryToConnect(200, 500, true, ConnectionSource.TinyCLR);
if (!connect)
{
return false;
}
engine.RebootDevice(option);
}
return true;
}
protected internal RuntimeValue_Reflection( Engine eng, WireProtocol.Commands.Debugging_Value handle ) : base( eng, handle )
{
m_rd = (ReflectionDefinition)System.Runtime.Serialization.FormatterServices.GetUninitializedObject( typeof(ReflectionDefinition) );
m_eng.CreateConverter().Deserialize( m_rd, handle.m_builtinValue );
}
static public object GetObject(Engine eng, Type type, uint id, Type classToRemote)
{
return GetObject(eng, new EndPoint(type, id, eng), classToRemote);
}
internal bool Connect( int timeout_ms, bool tryConnect )
{
// to use user cancel event, so that cancel button is more responsive
int retries = timeout_ms/100;
int loops = 1;
if (retries == 0) retries = 1;
if (m_portTinyBooter != null && m_port.UniqueId != m_portTinyBooter.UniqueId)
{
retries /= 2;
loops = 2;
}
for (int i = 0; i < loops; i++)
{
_DBG.PortDefinition pd = i == 0 ? m_port : m_portTinyBooter;
if (EventCancel.WaitOne(0, false)) throw new MFUserExitException();
try
{
if (m_eng == null)
{
m_eng = new _DBG.Engine(pd);
m_eng.OnNoise += new _DBG.NoiseEventHandler(OnNoiseHandler);
m_eng.OnMessage += new _DBG.MessageEventHandler(OnMessage);
}
if (!m_eng.IsConnected)
{
m_eng.Start();
if (tryConnect)
{
for (int j = retries; j > 0; j-=5)
{
if (m_eng.TryToConnect(5, 100, true, _DBG.ConnectionSource.Unknown))
{
//UNLOCK DEVICE in secure way?
m_eng.UnlockDevice(m_data);
break;
}
if (EventCancel.WaitOne(0, false)) throw new MFUserExitException();
}
if (m_eng.IsConnected)
{
break;
}
else
{
Disconnect();
}
}
else
{
break;
}
}
}
catch (MFUserExitException)
{
Disconnect();
throw;
}
catch
{
Disconnect();
}
}
return (m_eng != null && (!tryConnect || m_eng.IsConnected));
}
internal EndPointProxy(Engine eng, EndPoint from, EndPoint to, Type type)
: base(type)
{
from.Register();
if (from.CheckDestination(to) == false)
{
from.Deregister();
throw new ArgumentException("Cannot connect to device EndPoint");
}
m_eng = eng;
m_from = from;
m_to = to;
m_type = type;
}
internal bool Disconnect()
{
if (m_eng != null)
{
m_eng.OnNoise -= new _DBG.NoiseEventHandler(OnNoiseHandler);
m_eng.OnMessage -= new _DBG.MessageEventHandler(OnMessage);
m_eng.Stop();
m_eng = null;
}
return true;
}
internal Request(Engine parent, WireProtocol.OutgoingMessage req, int retries, int timeout, CommandEventHandler callback)
{
if (retries < 0)
{
throw new ArgumentException("Value cannot be negative", "retries");
}
if (timeout < 1 || timeout > 60 * 60 * 1000)
{
throw new ArgumentException(String.Format("Value out of bounds: {0}", timeout), "timeout");
}
m_parent = parent;
m_req = req;
m_retries = retries;
m_timeoutRetry = new TimeSpan(timeout * TimeSpan.TicksPerMillisecond);
m_timeoutWait = new TimeSpan((retries == 0 ? 1 : 2 * retries) * timeout * TimeSpan.TicksPerMillisecond);
m_callback = callback;
if (callback == null)
{
m_event = new ManualResetEvent(false);
}
}
/// <summary>
/// Attempt to establish a connection with TinyBooter (with reboot if necessary)
/// </summary>
/// <returns>true connection was made, false otherwise</returns>
public bool ConnectToTinyBooter()
{
bool ret = false;
if (m_eng == null)
{
_DBG.PortDefinition pd = m_portTinyBooter;
try
{
if (m_eng == null)
{
m_eng = new _DBG.Engine(pd);
m_eng.OnNoise += new _DBG.NoiseEventHandler(OnNoiseHandler);
m_eng.OnMessage += new _DBG.MessageEventHandler(OnMessage);
m_eng.Start();
m_eng.TryToConnect(5, 100, true, _DBG.ConnectionSource.Unknown);
}
}
catch
{
}
}
if (m_eng != null)
{
if (m_eng.ConnectionSource == _DBG.ConnectionSource.TinyBooter) return true;
m_eng.RebootDevice(_DBG.Engine.RebootOption.EnterBootloader);
// tinyBooter is only com port so
if (m_port is _DBG.PortDefinition_Tcp)
{
Disconnect();
m_port = m_portTinyBooter;
// digi takes forever to reset
if (!Connect(60000, true))
{
Console.WriteLine(Properties.Resources.ErrorUnableToConnectToTinyBooterSerial);
return false;
}
}
bool fConnected = false;
for(int i = 0; i<40; i++)
{
if (EventCancel.WaitOne(0, false)) throw new MFUserExitException();
if (fConnected = m_eng.TryToConnect(0, 500, true, _DBG.ConnectionSource.Unknown))
{
_WP.Commands.Monitor_Ping.Reply reply = m_eng.GetConnectionSource();
ret = (reply.m_source == _WP.Commands.Monitor_Ping.c_Ping_Source_TinyBooter);
break;
}
}
if(!fConnected)
{
Console.WriteLine(Properties.Resources.ErrorUnableToConnectToTinyBooter);
}
}
return ret;
}
private void buttonDeployMap_Click( object sender, EventArgs e )
{
bool bWasStarted = EnsureDebuggerConnection();
Microsoft.SPOT.Debugger.WireProtocol.Commands.Monitor_DeploymentMap.Reply deployMap = m_eng.DeploymentMap();
if( deployMap != null )
{
NewText( "Deployment Map\r\n" );
for(int i=0; i<deployMap.m_count; i++ )
{
NewText( "Assembly " + i.ToString() + ":\r\n" );
NewText( string.Format( "\tAddress: 0x{0:x}\r\n", deployMap.m_map[i].m_address ) );
NewText( string.Format( "\tCRC: 0x{0:x}\r\n", deployMap.m_map[i].m_CRC ) );
NewText( string.Format( "\tSize: 0x{0:x}\r\n", deployMap.m_map[i].m_size ) );
}
if( deployMap.m_count == 0 )
{
NewText( "No assemblies in deployment sector\r\n" );
}
}
else
{
NewText( "Nothing in deployment sector - or - deployment map not supported\r\n" );
}
if( !bWasStarted )
{
m_eng.Stop();
m_eng = null;
}
}
internal bool Connect(int timeout_ms, bool tryConnect)
{
// to use user cancel event, so that cancel button is more responsive
int retries = timeout_ms / 100;
int loops = 1;
if (retries == 0)
{
retries = 1;
}
if (m_portTinyBooter != null && m_port.UniqueId != m_portTinyBooter.UniqueId)
{
retries /= 2;
loops = 2;
}
for (int i = 0; i < loops; i++)
{
_DBG.PortDefinition pd = i == 0 ? m_port : m_portTinyBooter;
if (EventCancel.WaitOne(0, false))
{
throw new MFUserExitException();
}
try
{
if (m_eng == null)
{
m_eng = new _DBG.Engine(pd);
m_eng.OnNoise += new _DBG.NoiseEventHandler(OnNoiseHandler);
m_eng.OnMessage += new _DBG.MessageEventHandler(OnMessage);
}
if (!m_eng.IsConnected)
{
m_eng.Start();
if (tryConnect)
{
for (int j = retries; j > 0; j -= 5)
{
if (m_eng.TryToConnect(5, 100, true, _DBG.ConnectionSource.Unknown))
{
//UNLOCK DEVICE in secure way?
m_eng.UnlockDevice(m_data);
break;
}
if (EventCancel.WaitOne(0, false))
{
throw new MFUserExitException();
}
}
if (m_eng.IsConnected)
{
break;
}
else
{
Disconnect();
}
}
else
{
break;
}
}
}
catch (MFUserExitException)
{
Disconnect();
throw;
}
catch
{
Disconnect();
}
}
return(m_eng != null && (!tryConnect || m_eng.IsConnected));
}
private void buttonRebootAndStop_Click( object sender, EventArgs e )
{
bool bWasStarted = EnsureDebuggerConnection( );
m_eng.RebootDevice(_DBG.Engine.RebootOption.EnterBootloader);
if(!bWasStarted)
{
m_eng.Stop();
m_eng = null;
}
}
// Write the concatonated header and configuration data to the Flash config sector
private void WriteConfig(string configName, byte[] data, bool staticSize, bool updateConfigSector)
{
_DBG.Engine engine = m_device.DbgEngine;
if (!m_init)
{
InitializeConfigData();
}
// updating the config
if (m_cfgHash.ContainsKey(configName))
{
ConfigIndexData cid = (ConfigIndexData)m_cfgHash[configName];
// If old and new data are different sizes
if (cid.Size != data.Length)
{
// If data comes from a well defined structure, its size cannot vary
if (staticSize)
{
throw new MFInvalidConfigurationDataException();
}
uint newNextIndex, oldNextIndex;
byte[] temp;
int diff = 0;
// Figure out where any following configuration data will start
newNextIndex = (uint)(cid.Index + data.Length);
while (0 != (newNextIndex % 4))
{
newNextIndex++; // Force a 4 byte boundary
}
// Figure out where any following configuration data previously started
oldNextIndex = (uint)(cid.Index + cid.Size);
while (0 != (oldNextIndex % 4))
{
oldNextIndex++; // Force a 4 byte boundary
}
diff = (int)newNextIndex - (int)oldNextIndex; // Find the adjusted difference in size between old and new config data
temp = new byte[m_lastCfgIndex + diff]; // Create a new byte array to contain all the configuration data
Array.Copy(m_all_cfg_data, temp, cid.Index); // Copy all preceding data to new array
Array.Copy(data, 0, temp, cid.Index, data.Length); // Copy new configuration to new array
if (oldNextIndex < m_lastCfgIndex) // Copy all following data (if it exists) to new array
{
Array.Copy(m_all_cfg_data, oldNextIndex, temp, newNextIndex, (m_all_cfg_data.Length - oldNextIndex));
}
// Update the local copy of the configuration list
m_all_cfg_data = temp;
m_lastCfgIndex += diff;
}
else
{
// Copy the new configuration data on top of the old
Array.Copy(data, 0, m_all_cfg_data, cid.Index, data.Length);
}
}
else // adding a new configuration to the end of the current list
{
uint newLastIndex;
if (m_lastCfgIndex == -1)
{
throw new MFConfigurationSectorOutOfMemoryException();
}
// Find the new size of the whole configuration list
newLastIndex = (uint)(m_lastCfgIndex + data.Length);
while (0 != (newLastIndex % 4))
{
newLastIndex++; // Force a 4 byte boundary
}
byte[] temp = new byte[m_lastCfgIndex >= m_all_cfg_data.Length ? m_lastCfgIndex + data.Length : m_all_cfg_data.Length];
Array.Copy(m_all_cfg_data, 0, temp, 0, m_all_cfg_data.Length);
Array.Copy(data, 0, temp, m_lastCfgIndex, data.Length);
// Update the local copy of the configuration list
m_all_cfg_data = temp;
m_lastCfgIndex = (int)newLastIndex;
}
if (!updateConfigSector)
{
return;
}
// Rewrite entire configuration list to Flash
if (!engine.EraseMemory(m_cfg_sector.m_address, (uint)m_all_cfg_data.Length))
{
throw new MFConfigSectorEraseFailureException();
}
if (!engine.WriteMemory(m_cfg_sector.m_address, m_all_cfg_data))
{
throw new MFConfigSectorWriteFailureException();
}
// Rebuild hash table
m_cfgHash.Clear();
uint hal_config_block_size = 0;
unsafe
{
hal_config_block_size = (uint)sizeof(HAL_CONFIG_BLOCK);
}
int index = (int)m_StaticConfig.ConfigurationLength;
byte[] headerData = new byte[hal_config_block_size];
HAL_CONFIG_BLOCK cfg_header;
while (index < m_lastCfgIndex)
{
// Read in next configuration header
Array.Copy(m_all_cfg_data, index, headerData, 0, hal_config_block_size);
cfg_header = (HAL_CONFIG_BLOCK)UnmarshalData(headerData, typeof(HAL_CONFIG_BLOCK));
m_cfgHash[cfg_header.DriverNameString] = new ConfigIndexData(index, (int)(cfg_header.Size + hal_config_block_size));
// Index of next configuration header must lie on a 4 byte boundary
index += (int)(cfg_header.Size + hal_config_block_size);
while (0 != (index % 4))
{
index++; // Force a 4 byte boundary
}
}
// we need to perform signature check regardless of key update, in order for the device to write from ram buffer to flash
if (!engine.CheckSignature(new byte[TINYBOOTER_KEY_CONFIG.c_KeySignatureLength], 0))
{
if (engine.ConnectionSource == Microsoft.SPOT.Debugger.ConnectionSource.TinyBooter)
{
throw new MFConfigSectorWriteFailureException();
}
}
if (engine.ConnectionSource == Microsoft.SPOT.Debugger.ConnectionSource.TinyBooter && m_fRestartClr)
{
engine.ExecuteMemory(c_EnumerateAndLaunchAddr);
}
}
private void buttonPing_Click(object sender, EventArgs e)
{
bool bWasStarted = EnsureDebuggerConnection();
_DBG.WireProtocol.Commands.Monitor_Ping.Reply reply;
reply = m_eng.GetConnectionSource();
if (reply != null)
{
switch (reply.m_source)
{
case _DBG.WireProtocol.Commands.Monitor_Ping.c_Ping_Source_TinyCLR:
NewText("Connected to TinyCLR\r\n");
break;
case _DBG.WireProtocol.Commands.Monitor_Ping.c_Ping_Source_TinyBooter:
NewText("Connected to TinyBooter\r\n");
break;
default:
NewText("Connected to unknown source\r\n");
break;
}
}
else
{
NewText("No connection\r\n");
}
if (!bWasStarted)
{
m_eng.Stop();
m_eng = null;
}
}
void Stop()
{
if(m_worker != null)
{
m_worker.Abort();
m_worker.Join ();
m_worker = null;
}
if(m_fl != null)
{
m_fl.Stop();
m_fl = null;
}
if(m_eng != null)
{
m_eng.Stop();
m_eng = null;
}
}
private void StartOrStop( bool fStart )
{
bool fButtonState;
if(fStart)
{
if(m_eng != null) return;
m_blocks = new ArrayList();
m_fWait = checkBoxWait.Checked;
m_fDisconnect = checkBoxDisconnect.Checked;
listViewFiles.SelectedIndices.Clear();
try
{
_DBG.PortDefinition pd = GetSelectedPortDefinition();
m_eng = new _DBG.Engine( pd );
m_eng.Silent = true;
m_eng.OnNoise += new _DBG.NoiseEventHandler ( OnNoise );
m_eng.OnMessage += new _DBG.MessageEventHandler( OnMessage );
m_eng.Start();
if (m_eng.TryToConnect(5, 100))
{
if (m_fWait)
{
// if w are talking to the booter, have it to stop and wait for upload
// PortBooter will wait to secs no matter what
m_eng.RebootDevice(radioButtonPortBooter.Checked ? _DBG.Engine.RebootOption.EnterBootloader : _DBG.Engine.RebootOption.NormalReboot);
}
}
foreach(ListViewItem item in this.listViewFiles.CheckedItems)
{
m_blocks.Add( item.Tag );
}
if(m_blocks.Count > 0)
{
if(radioButtonPortBooter.Checked)
{
m_fl = new _DBG.PortBooter( m_eng );
m_fl.OnProgress += new _DBG.PortBooter.ProgressEventHandler( this.OnProgress );
m_fl.Start();
m_worker = new Thread( new ThreadStart( this.UploadWithPortBooter ) );
}
else
{
m_worker = new Thread( new ThreadStart( this.UploadWithTinyBooter ) );
}
m_worker.Start();
}
buttonAction.Text = "Stop";
richTextBox1.Focus();
}
catch(Exception ex)
{
MessageBox.Show( ex.Message );
return;
}
fButtonState = false;
}
else
{
if(m_eng == null) return;
Stop();
buttonAction.Text = "Start";
fButtonState = true;
}
buttonReload .Enabled = fButtonState;
buttonRemove .Enabled = fButtonState;
buttonRemoveAll .Enabled = fButtonState;
buttonBrowse .Enabled = fButtonState;
comboBoxPort .Enabled = fButtonState;
comboBoxBaud .Enabled = fButtonState;
listViewFiles .Enabled = fButtonState;
}
bool Process(string[] args)
{
string port = null;
uint baudrate = 0;
bool fWait = true;
int i;
if (args.Length == 0)
{
Usage();
return(false);
}
for (i = 0; i < args.Length; i++)
{
string arg = args[i].ToLower();
if (arg == "-port")
{
port = args[++i]; continue;
}
if (arg == "-baudrate")
{
baudrate = UInt32.Parse(args[++i]); continue;
}
if (arg == "-nowait")
{
fWait = false; continue;
}
if (arg == "-com1")
{
port = "COM1"; baudrate = 115200; continue;
}
if (arg == "-com2")
{
port = "COM2"; baudrate = 115200; continue;
}
if (arg == "-write")
{
try
{
string file = args[++i];
Console.WriteLine("Loading {0}...", file);
Microsoft.SPOT.Debugger.SRecordFile.Parse(file, m_blocks, null);
Console.WriteLine("Loaded.");
}
catch (Exception e)
{
Console.WriteLine("{0}", e.ToString());
return(false);
}
continue;
}
if (arg == "-writeandexecute")
{
try
{
string file = args[++i];
Console.WriteLine("Loading {0}...", file);
m_entrypoint = Microsoft.SPOT.Debugger.SRecordFile.Parse(file, m_blocks, null);
Console.WriteLine("Loaded.");
}
catch (Exception e)
{
Console.WriteLine("{0}", e.ToString());
return(false);
}
continue;
}
if (arg == "-entrypoint")
{
m_entrypoint = ParseHex(args[++i]);
continue;
}
Usage();
return(false);
}
if (port == null || baudrate == 0)
{
Console.WriteLine("No serial port specified!");
return(false);
}
m_eng = new _DBG.Engine(new Microsoft.SPOT.Debugger.PortDefinition_Serial(port, port, baudrate));
m_eng.Silent = true;
m_eng.OnMessage += new _DBG.MessageEventHandler(OnMessage);
m_eng.Start();
if (fWait)
{
if (m_eng.TryToConnect(5, 100))
{
m_eng.RebootDevice();
}
}
m_fl = new _DBG.PortBooter(m_eng);
m_fl.OnProgress += new _DBG.PortBooter.ProgressEventHandler(this.OnProgress);
m_fl.Start();
if (fWait)
{
m_fl.WaitBanner(Int32.MaxValue, 2000);
}
DateTime start = DateTime.Now;
m_fl.Program(m_blocks);
Console.WriteLine("Execute: {0}", DateTime.Now - start);
if (m_entrypoint != 0)
{
while (true)
{
m_fl.Execute(m_entrypoint);
_DBG.PortBooter.Report r = m_fl.GetReport(2000);
if (r != null && r.type == _DBG.PortBooter.Report.State.EntryPoint)
{
break;
}
}
}
m_fl.Stop();
m_eng.Stop();
return(true);
}
