Ejemplo n.º 1
0
        /// <summary>
        /// Starts execution on the connected .Net Micro Framework device at the supplied address (parameter entrypoint).
        /// This method is generally used after the Deploy method to jump into the code that was deployed.
        /// </summary>
        /// <param name="entrypoint">Entry point address for execution to begin</param>
        /// <param name="cancellationToken">Cancellation token for caller to cancel task execution</param>
        /// <returns>Returns false if execution fails, true otherwise
        /// Possible exceptions: MFDeviceNoResponseException
        /// </returns>
        public async Task <bool> ExecuteAync(uint entryPoint, CancellationToken cancellationToken)
        {
            if (DebugEngine == null)
            {
                throw new NanoFrameworkDeviceNoResponseException();
            }

            if (await CheckForMicroBooterAsync(cancellationToken))
            {
                // check if cancellation was requested
                if (cancellationToken.IsCancellationRequested)
                {
                    throw new NanoUserExitException();
                }

                if (m_execSrecHash.ContainsKey(entryPoint))
                {
                    string execRec = (string)m_execSrecHash[entryPoint];
                    bool   fRet    = false;

                    for (int retry = 0; retry < 10; retry++)
                    {
                        // check if cancellation was requested
                        if (cancellationToken.IsCancellationRequested)
                        {
                            throw new NanoUserExitException();
                        }

                        await DebugEngine.SendBufferAsync(UTF8Encoding.UTF8.GetBytes(execRec), TimeSpan.FromMilliseconds(1000), cancellationToken);

                        // check if cancellation was requested
                        if (cancellationToken.IsCancellationRequested)
                        {
                            throw new NanoUserExitException();
                        }

                        await DebugEngine.SendBufferAsync(UTF8Encoding.UTF8.GetBytes("\n"), TimeSpan.FromMilliseconds(1000), cancellationToken);

                        // check if cancellation was requested
                        if (cancellationToken.IsCancellationRequested)
                        {
                            throw new NanoUserExitException();
                        }

                        if (m_evtMicroBooter.WaitOne(1000))
                        {
                            fRet = true;
                            break;
                        }
                    }

                    return(fRet);
                }

                return(false);
            }

            Commands.Monitor_Ping.Reply reply = DebugEngine.GetConnectionSource();

            if (reply == null)
            {
                throw new NanoFrameworkDeviceNoResponseException();
            }

            // only execute if we are talking to the nanoBooter, otherwise reboot
            if (reply.m_source == Commands.Monitor_Ping.c_Ping_Source_NanoBooter)
            {
                return(DebugEngine.ExecuteMemory(entryPoint));
            }
            else // if we are talking to the CLR then we simply did a deployment update, so reboot
            {
                DebugEngine.RebootDevice(RebootOptions.ClrOnly);
            }

            return(true);
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Erases the deployment sectors of the connected .Net Micro Framework device
        /// </summary>
        /// <param name="options">Identifies which areas are to be erased</param>
        /// <param name="cancellationToken">Cancellation token to allow caller to cancel task</param>
        /// <param name="progress">Progress report of execution</param>
        /// <returns>Returns false if the erase fails, true otherwise
        /// Possible exceptions: MFUserExitException, MFDeviceNoResponseException
        /// </returns>
        public async Task <bool> EraseAsync(EraseOptions options, CancellationToken cancellationToken, IProgress <ProgressReport> progress = null)
        {
            bool ret    = false;
            bool fReset = false;

            if (DebugEngine == null)
            {
                throw new NanoFrameworkDeviceNoResponseException();
            }

            if (!await DebugEngine.ConnectAsync(500, true))
            {
                throw new NanoFrameworkDeviceNoResponseException();
            }

            if (!IsClrDebuggerEnabled || 0 != (options & EraseOptions.Firmware))
            {
                fReset = (Ping() == PingConnectionType.nanoCLR);

                if (!await ConnectToNanoBooterAsync(cancellationToken))
                {
                    throw new NanoBooterConnectionFailureException();
                }
            }

            var reply = DebugEngine.GetFlashSectorMap();

            if (reply == null)
            {
                throw new NanoFrameworkDeviceNoResponseException();
            }

            Commands.Monitor_Ping.Reply ping = DebugEngine.GetConnectionSource();

            ret = true;

            long total = 0;
            long value = 0;

            bool isConnectedToCLR = ((ping != null) && (ping.m_source == Commands.Monitor_Ping.c_Ping_Source_NanoCLR));


            if (isConnectedToCLR)
            {
                DebugEngine.PauseExecution();
            }

            List <Commands.Monitor_FlashSectorMap.FlashSectorData> eraseSectors = new List <Commands.Monitor_FlashSectorMap.FlashSectorData>();

            foreach (Commands.Monitor_FlashSectorMap.FlashSectorData flashSectorData in reply)
            {
                if (cancellationToken.IsCancellationRequested)
                {
                    throw new NanoUserExitException();
                }

                switch (flashSectorData.m_flags & Commands.Monitor_FlashSectorMap.c_MEMORY_USAGE_MASK)
                {
                case Commands.Monitor_FlashSectorMap.c_MEMORY_USAGE_DEPLOYMENT:
                    if (EraseOptions.Deployment == (options & EraseOptions.Deployment))
                    {
                        eraseSectors.Add(flashSectorData);
                        total++;
                    }
                    break;

                case Commands.Monitor_FlashSectorMap.c_MEMORY_USAGE_UPDATE:
                    if (EraseOptions.UpdateStorage == (options & EraseOptions.UpdateStorage))
                    {
                        eraseSectors.Add(flashSectorData);
                        total++;
                    }
                    break;

                case Commands.Monitor_FlashSectorMap.c_MEMORY_USAGE_SIMPLE_A:
                case Commands.Monitor_FlashSectorMap.c_MEMORY_USAGE_SIMPLE_B:
                    if (EraseOptions.SimpleStorage == (options & EraseOptions.SimpleStorage))
                    {
                        eraseSectors.Add(flashSectorData);
                        total++;
                    }
                    break;

                case Commands.Monitor_FlashSectorMap.c_MEMORY_USAGE_STORAGE_A:
                case Commands.Monitor_FlashSectorMap.c_MEMORY_USAGE_STORAGE_B:
                    if (EraseOptions.UserStorage == (options & EraseOptions.UserStorage))
                    {
                        eraseSectors.Add(flashSectorData);
                        total++;
                    }
                    break;

                case Commands.Monitor_FlashSectorMap.c_MEMORY_USAGE_FS:
                    if (EraseOptions.FileSystem == (options & EraseOptions.FileSystem))
                    {
                        eraseSectors.Add(flashSectorData);
                        total++;
                    }
                    break;

                case Commands.Monitor_FlashSectorMap.c_MEMORY_USAGE_CONFIG:
                    if (EraseOptions.Configuration == (options & EraseOptions.Configuration))
                    {
                        eraseSectors.Add(flashSectorData);
                        total++;
                    }
                    break;

                case Commands.Monitor_FlashSectorMap.c_MEMORY_USAGE_CODE:
                    if (EraseOptions.Firmware == (options & EraseOptions.Firmware))
                    {
                        eraseSectors.Add(flashSectorData);
                        total++;
                    }
                    break;
                }
            }

            foreach (Commands.Monitor_FlashSectorMap.FlashSectorData flashSectorData in eraseSectors)
            {
                progress?.Report(new ProgressReport(value, total, string.Format("Erasing sector 0x{0:x08}", flashSectorData.m_StartAddress)));

                var eraseResult = DebugEngine.EraseMemory(flashSectorData.m_StartAddress, (flashSectorData.m_NumBlocks * flashSectorData.m_BytesPerBlock));

                ret &= eraseResult.Success;

                value++;
            }

            // reset if we specifically entered nanoBooter to erase
            if (fReset)
            {
                DebugEngine.ExecuteMemory(0);
            }

            // reboot if we are talking to the CLR
            if (isConnectedToCLR)
            {
                progress?.Report(new ProgressReport(0, 0, "Rebooting..."));

                var rebootOptions = RebootOptions.ClrOnly;

                // if we've just erase the deployment area there is no more app so the execution engine can't be gracefully stopped
                if ((options & EraseOptions.Deployment) == EraseOptions.Deployment)
                {
                    rebootOptions |= RebootOptions.NoShutdown;
                }

                DebugEngine.RebootDevice(rebootOptions);
            }

            return(ret);
        }