Autopilot/SIASUN.Autopilot.BLL/Controler/BlControler.cs

using ProjectBase.Data.Logs;
using ProjectBase.Data.Redis;
using SIASUN.Autopilot.Device.Common;
using SIASUN.Autopilot.Device.Message;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SIASUN.Autopilot.BLL.Controler
{
   
    public class BlControler
    {
        // 控制器命令值
        private string power = "1";

        /// <summary>
        /// 定时器
        /// </summary>
        private static MTimer mTime;

        private RedisHelper redis = new RedisHelper(0);

        /// <summary>
        /// 控制上电命令 ICU-》RCU 
        /// </summary>
        /// <param name="power">0=Power Off;1=Power ON;2=无效命令</param>
        /// <returns></returns>
        public int RCUPowerOnRequest(PowerStatus power)
        {
            try
            {
                LogHelper.log.Info("发送RCU控制上电命令请求");
                控制器上电命令 sMsg = new 控制器上电命令()
                {
                    RCU上电 = power.ToString(),
                    油门电机控制器上电 = power.ToString(),
                    制动电机控制器上电 = power.ToString(),
                    离合电机控制器上电 = power.ToString(),
                    转向电机控制器上电 = power.ToString(),
                    换挡臂X电机控制器上电 = power.ToString(),
                    换挡臂Y电机控制器上电 = power.ToString()

                };
                SimpleCommand<控制器上电命令> cmd = new SimpleCommand<控制器上电命令>();
                int r = cmd.Execute(sMsg, sMsg.GetId);
                LogHelper.log.Info(string.Format("发送控制器上电命令，返回值{0}", r));
                if (r > 0)
                {
                    mTime = new MTimer(100, 500, 1, CirculateSend);
                    mTime.Open();
                }
                return r;
            }
            catch (Exception ex)
            {
                LogHelper.log.Error("发送控制器上电命令出现错误", ex);
                return 0;
            }

        }

        /// <summary>
        /// 执行机构使能请求
        /// </summary>
        /// <param name="common">0=Disable;1=Enable</param>
        /// <param name="throttleClutch">油门离合器控制:0=Joint;1=Release;2=无效命令</param>
        /// <param name="actuallySysControl">实际系统控制模式请求:0=自动学习模式;1=手动学习模式;3=人工驾驶模式;4=机器人自检模式;5=机器人调试模式</param>
        /// <returns></returns>
        public int RCUEnableRequest()
        {
            try
            {
                LogHelper.log.Info("发送RCU使能命令请求");
                执行机构使能请求 sMsg = new 执行机构使能请求();
                sMsg = redis.GetString<执行机构使能请求>("执行机构使能请求");
                SimpleCommand<执行机构使能请求> cmd = new SimpleCommand<执行机构使能请求>();
                int r = cmd.Execute(sMsg, sMsg.GetId);
                LogHelper.log.Info(string.Format("发送执行机构使能请求，返回值{0}", r));
                return r;
            }
            catch (Exception ex)
            {
                LogHelper.log.Error("发送执行机构使能请求出现错误", ex);
                return 0;
            }

        }

        /// <summary>
        /// 循环发送命令
        /// </summary>
        private static void CirculateSend(object sender, long JumpPeriod, long interval)
        {

        }

        /// <summary>
        /// 学习模式请求确认
        /// </summary>
        /// <param name="sMg"></param>
        /// <returns></returns>
        public int RCULearnModeRequest()
        {
            try
            {
                LogHelper.log.Info("发送RCU学习模式请求确认命令");
                学习模式请求确认 sMg = new 学习模式请求确认();
                sMg = redis.GetString<学习模式请求确认>("学习模式请求确认");
                SimpleCommand<学习模式请求确认> cmd = new SimpleCommand<学习模式请求确认>();
                int r = cmd.Execute(sMg, sMg.GetId);
                LogHelper.log.Info(string.Format("发送学习模式请求确认命令，返回值{0}", r));
                return r;
            }
            catch (Exception ex)
            {
                LogHelper.log.Error("发送学习模式请求确认命令出现错误", ex);
                return 0;
            }

        }

        /// <summary>
        /// 踏板执行机构控制命令
        /// </summary>
        /// <returns></returns>
        public int PedalControlCommand(踏板执行机构控制命令 sMg)
        {
            try
            {
                LogHelper.log.Info("发送踏板执行机构控制命令");
                SimpleCommand<踏板执行机构控制命令> cmd = new SimpleCommand<踏板执行机构控制命令>();
                int r = cmd.Execute(sMg, sMg.GetId);
                LogHelper.log.Info(string.Format("发送踏板执行机构控制命令，返回值{0}", r));
                return r;
            }
            catch (Exception ex)
            {
                LogHelper.log.Error("发送踏板执行机构控制命令出现错误", ex);
                return 0;
            }

        }

        /// <summary>
        /// 转向执行机构控制命令
        /// </summary>
        /// <returns></returns>
        public int TurnControlCommand(转向执行机构控制命令 sMg)
        {
            try
            {
                LogHelper.log.Info("发送转向执行机构控制命令");
                SimpleCommand<转向执行机构控制命令> cmd = new SimpleCommand<转向执行机构控制命令>();
                int r = cmd.Execute(sMg, sMg.GetId);
                LogHelper.log.Info(string.Format("发送转向执行机构控制命令，返回值{0}", r));
                return r;
            }
            catch (Exception ex)
            {
                LogHelper.log.Error("发送转向执行机构控制命令出现错误", ex);
                return 0;
            }

        }

        /// <summary>
        /// 挡位执行机构控制命令
        /// </summary>
        /// <returns></returns>
        public int GearControlCommand(挡位执行机构控制命令 sMg)
        {
            try
            {
                LogHelper.log.Info("发送挡位执行机构控制命令");
                SimpleCommand<挡位执行机构控制命令> cmd = new SimpleCommand<挡位执行机构控制命令>();
                int r = cmd.Execute(sMg, sMg.GetId);
                LogHelper.log.Info(string.Format("发送挡位执行机构控制命令，返回值{0}", r));
                return r;
            }
            catch (Exception ex)
            {
                LogHelper.log.Error("发送挡位执行机构控制命令出现错误", ex);
                return 0;
            }

        }
    }
}