ST_CUBE_MES/ST-CUBE_MES/Service/STLinkCliPrograrmService.cs

using ST_CUBE_MES.Model;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;

namespace ST_CUBE_MES.Service
{
    public class STLinkCliPrograrmService
    {
        public STLinkCliPrograrmService(string stlCliPath = "", string port = "", string customDefaultOption = null)
        {
            this._cli = new STLinkCliWrapService(stlCliPath, port, customDefaultOption);
        }

        public delegate void OnMsgRecevicedEvent(string msg);
        public event OnMsgRecevicedEvent OnMsgReceviced;

        public delegate void OnProgressChangedEvent(int currentStep, int maxStep);
        public event OnProgressChangedEvent OnProgressChanged;
        public string CliPath => _cli.CliPath;

        private readonly STLinkCliWrapService _cli;

        public Result StartProgramProcess(string filePath)
        {
            Result result = new Result() { IsSuccess = false };

            result.Step = 1;
            var setOptionByteResult = SetOptionByte();
            if (setOptionByteResult != null)
            {
                result.ErrorMsg = setOptionByteResult.ErrorMsg;
                foreach (var pair in setOptionByteResult.Data)
                {
                    result.Data[pair.Key] = pair.Value;
                }
            }
            if (setOptionByteResult == null || !setOptionByteResult.IsSuccess)
            {
                return result;
            }
            OnProgressChanged?.Invoke(1, 4);

            result.Step = 2;
            var eraseResult = Erase();
            if (eraseResult != null)
            {
                result.ErrorMsg = eraseResult.ErrorMsg;
                foreach (var pair in eraseResult.Data)
                {
                    result.Data[pair.Key] = pair.Value;
                }
            }
            if (eraseResult == null || !eraseResult.IsSuccess)
            {
                return result;
            }
            OnProgressChanged?.Invoke(2, 4);

            result.Step = 3;
            var startProgramResult = StartProgram(filePath);
            if (startProgramResult != null)
            {
                result.ErrorMsg = startProgramResult.ErrorMsg;
                foreach (var pair in startProgramResult.Data)
                {
                    result.Data[pair.Key] = pair.Value;
                }
            }
            if (startProgramResult == null || !startProgramResult.IsSuccess)
            {
                return result;
            }
            OnProgressChanged?.Invoke(3, 4);

            result.Step = 4;
            var getCheckSumResult = GetCheckSum(filePath);
            if (getCheckSumResult != null)
            {
                result.ErrorMsg = getCheckSumResult.ErrorMsg;
                foreach (var pair in getCheckSumResult.Data)
                {
                    result.Data[pair.Key] = pair.Value;
                }
            }
            if (getCheckSumResult == null || !getCheckSumResult.IsSuccess)
            {
                return result;
            }
            OnProgressChanged?.Invoke(4, 4);

            result.IsSuccess = true;
            return result;
        }

        public Result SetOptionByte()
        {
            var result = new Result() { IsSuccess = true };

            _cli.OnMsgReceviced += stlCli_OnMsgReceviced_SetDefaultOptions;
            var resultInt = _cli.SetOptionByte();
            _cli.OnMsgReceviced -= stlCli_OnMsgReceviced_SetDefaultOptions;

            result.IsSuccess = resultInt == 0;
            return result;

            void stlCli_OnMsgReceviced_SetDefaultOptions(string msg)
            {
                if (msg is null)
                    return;

                if (msg.Contains("Error: No debug probe detected"))
                {
                    result.ErrorMsg = "Error: No debug probe detected";
                }
                OnMsgReceviced?.Invoke(msg);
            }
        }

        public Result Erase()
        {
            var result = new Result() { IsSuccess = true };

            _cli.OnMsgReceviced += stlCli_OnMsgReceviced_SetDefaultOptions;
            var resultInt = _cli.Erase();
            _cli.OnMsgReceviced -= stlCli_OnMsgReceviced_SetDefaultOptions;

            result.IsSuccess = resultInt == 0;
            return result;

            void stlCli_OnMsgReceviced_SetDefaultOptions(string msg)
            {
                if (msg is null)
                    return;

                if (msg.Contains("Error: No debug probe detected"))
                {
                    result.ErrorMsg = "Error: No debug probe detected";
                }
                OnMsgReceviced?.Invoke(msg);
            }
        }

        public Result GetCheckSum(string filePath)
        {
            if (!File.Exists(filePath))
            {
                return new Result()
                {
                    IsSuccess = false,
                    ErrorMsg = "ERROR: Check file not found",
                };
            }

            var result = new Result() { IsSuccess = true };

            _cli.OnMsgReceviced += stlCli_OnMsgReceviced_StartProgram;
            var resultInt = _cli.GetCheckSum(filePath);
            _cli.OnMsgReceviced -= stlCli_OnMsgReceviced_StartProgram;

            result.IsSuccess = resultInt == 0;
            return result;

            void stlCli_OnMsgReceviced_StartProgram(string msg)
            {
                if (msg is null)
                    return;

                Regex checksumRegex = new Regex("^(.*)Checksum = (0x.*)$");
                var match = checksumRegex.Match(msg);
                if (match.Success &&
                    match.Groups.Count > 2 &&
                    match.Groups[2].Value.StartsWith("0x"))
                {
                    var checksum = match.Groups[2].Value;
                    result.Data.Add("checksum", checksum);
                    result.Data.Add("fileName", Path.GetFileName(filePath));

                    OnMsgReceviced?.Invoke($"checksum: {checksum}");
                }

                if (msg.Contains("Error: No debug probe detected"))
                {
                    result.ErrorMsg = "Error: No debug probe detected";
                }
                OnMsgReceviced?.Invoke(msg);
            }
        }

        public Result StartProgram(string filePath)
        {
            if (!File.Exists(filePath))
            {
                return new Result()
                {
                    IsSuccess = false,
                    ErrorMsg = "ERROR: Program file not found",
                };
            }

            var result = new Result() { IsSuccess = true };

            _cli.OnMsgReceviced += stlCli_OnMsgReceviced_StartProgram;
            var resultInt = _cli.StartProgram(filePath);
            _cli.OnMsgReceviced -= stlCli_OnMsgReceviced_StartProgram;

            result.IsSuccess = resultInt == 0;
            return result;

            void stlCli_OnMsgReceviced_StartProgram(string msg)
            {
                if (msg is null)
                    return;

                if (msg.Contains("Error: No debug probe detected"))
                {
                    result.ErrorMsg = "Error: No debug probe detected";
                }
                OnMsgReceviced?.Invoke(msg);
            }
        }

        public Result GetMemCheckSum()
        {
            var result = new Result() { IsSuccess = true };

            _cli.OnMsgReceviced += stlCli_OnMsgReceviced_SetDefaultOptions;
            var resultInt = _cli.GetMemCheckSum();
            _cli.OnMsgReceviced -= stlCli_OnMsgReceviced_SetDefaultOptions;

            result.IsSuccess = resultInt == 0;
            return result;

            void stlCli_OnMsgReceviced_SetDefaultOptions(string msg)
            {
                if (msg is null)
                    return;

                Regex checksumRegex = new Regex("^(.*)Checksum : (0x.*)$");
                var match = checksumRegex.Match(msg);
                if (match.Success &&
                    match.Groups.Count > 2 &&
                    match.Groups[2].Value.StartsWith("0x"))
                {
                    var checksum = match.Groups[2].Value;
                    //result.Data.Add("checksum", checksum);

                    OnMsgReceviced?.Invoke($"memory checksum: {checksum}");
                }

                if (msg.Contains("Error: No debug probe detected"))
                {
                    result.ErrorMsg = "Error: No debug probe detected";
                }
                OnMsgReceviced?.Invoke(msg);
            }
        }
    }
}