wcs/WCS/Service/Impl/JobService.cs

/*using HslCommunication.Profinet.Siemens;
using HslCommunication;
using Newtonsoft.Json;
using Quartz;
using WCS.DeviceProtocol;
using WCS.Entitys;
using WCS.Model;
using WCS.Services;
using WCS.Utils;
using StackExchange.Redis;

namespace WCS.Service.Impl
{
    public class JobService : IJob

    {
        private readonly IConnectionMultiplexer _redis;
        private readonly IDeviceService _deviceService;
        private readonly IWcsTagValueService _wcsTagValueService;

        private string wcs_redis_key = "WCS:";

        private string LOG_TITLE_S7 = "S7采集";
        public JobService(IConnectionMultiplexer redisService, IDeviceService deviceService)
        {
            this._redis = redisService;
            this._deviceService = deviceService;
        }

        public async Task Execute(IJobExecutionContext context)
        {
            try
            {
                Console.WriteLine($"Job executed at {DateTime.Now}");
                await this.getDeviceList();
            }
            catch (Exception ex)
            {
                // 记录异常
                Console.WriteLine($"An error occurred: {ex.Message}");
                // 你可以选择记录到日志文件或其他日志系统
            }
        }



        /// <summary>
        /// 采集数据S7
        /// </summary> 
        /// <returns></returns>
        public async Task<string> DataCollectS7Job()
        {
            try
            {
                List<WcsDevice> deviceList = await getDeviceList();
                deviceList = deviceList.Where(x => x.ProtocolType.Equals(ProtocalTypeEnum.S7_1500.ToString()) && x.State).ToList();
                foreach (WcsDevice device in deviceList)
                {
                    List<WcsTagValue> tagValues = new List<WcsTagValue>();
                    string redis_key = "WCS:" + device.Ip + ":" + device.ProtocolType;
                    var data = await _redis.GetDatabase().StringGetAsync(redis_key);
                    if (data.IsNullOrEmpty)
                    {
                        WcsTagValue tagQuery = new WcsTagValue();
                        tagQuery.ProtocolType = device.ProtocolType;
                        tagQuery.Ip = device.Ip;
                        tagValues = _wcsTagValueService.GetList(tagQuery);
                        //首次设置redis
                        if (tagValues != null && tagValues.Count > 0)
                        {
                            await _redis.GetDatabase().StringSetAsync(redis_key, JsonConvert.SerializeObject(tagValues));
                        }
                    }
                    else
                    {
                        tagValues = JsonConvert.DeserializeObject<List<WcsTagValue>>(data);
                    }

                    if (tagValues != null && tagValues.Count > 0)
                    {
                        tagValues = JsonConvert.DeserializeObject<List<WcsTagValue>>(data);
                        List<WcsTagValue> changTagValues = new List<WcsTagValue>();


                        //Plc s7 = DevicePlcS7.S7(device.ServerUrl, ProtocalTypeEnum.S7_1500.ToString());
                        SiemensS7Net s7 = DevicePlcS7.SiemensS7(device.Ip);
                        OperateResult ConnectionResult = s7.ConnectServer();
                        if (!ConnectionResult.IsSuccess)
                        {
                            device.State = false;
                            await _deviceService.UpdateDevice(device);
                            s7.ConnectClose();
                            Log.Instance.WriteLogAdd("S7采集异常,plc连不上==>" + device.Ip, LOG_TITLE_S7);
                            return "采集失败，plc连不上";
                        }
                        else
                        {
                            foreach (WcsTagValue tagValueData in tagValues)
                            {
                                string operateResult = "";
                                if (tagValueData.Type.Equals(TagValueReadTypeEnum.BOOL.ToString()))
                                {
                                    operateResult = s7.ReadBool(tagValueData.Address).Content.ToString();
                                }
                                else if (tagValueData.Type.Equals(TagValueReadTypeEnum.SHORT.ToString()))
                                {
                                    operateResult = s7.ReadInt16(tagValueData.Address).Content.ToString();
                                }
                                else if (tagValueData.Type.Equals(TagValueReadTypeEnum.String.ToString()))
                                {
                                    operateResult = s7.ReadString(tagValueData.Address).Content.ToString();
                                }
                                else if (tagValueData.Type.Equals(TagValueReadTypeEnum.Array.ToString()))
                                {
                                    operateResult = ToolUtils.ReturnStringByBytes(s7.Read(tagValueData.Address, 40).Content);
                                }

                                if (!string.IsNullOrEmpty(operateResult) && tagValueData.TagValue != operateResult)
                                {
                                    tagValueData.TagValue = operateResult.ToString();
                                    tagValueData.UpdateTime = DateTime.Now;
                                    changTagValues.Add(tagValueData);
                                    Log.Instance.WriteLogAdd("S7采集,Ip:" + tagValueData.Ip + " 地址:" + tagValueData.Address + ",值:" + tagValueData.TagValue + ",发生变化", LOG_TITLE_S7);
                                    //有变化更新数据库
                                    await _wcsTagValueService.Update(tagValueData);
                                }
                                Thread.Sleep(50);
                            }
                            s7.ConnectClose();
                            //值有变化，重新设置一次redis
                            if (changTagValues != null && changTagValues.Count > 0)
                            {
                                await _redis.GetDatabase().StringSetAsync(redis_key, JsonConvert.SerializeObject(tagValues));
                            }
                            //存储采集数据
                            CollectDataLog.Instance.WriteLogAdd(data, LOG_TITLE_S7);
                        }

                    }
                }
                return "S7采集成功";
            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd("S7采集异常===>>" + ex.Message, LOG_TITLE_S7);
                return "S7采集失败";
            }
        }



        /// <summary>
        /// 获取redis 设备在线列表
        /// </summary>
        /// <param name="strData"></param>
        /// <returns></returns>
        private async Task<List<WcsDevice>> getDeviceList()
        {
            List<WcsDevice> deviceList = new List<WcsDevice>();
            var deviceListData = await _redis.GetDatabase().StringGetAsync(wcs_redis_key + RedisKeyEnum.DeviceList);
            if (deviceListData.IsNullOrEmpty || deviceListData.Length() == 0)
            {
                deviceList = _deviceService.GetDeviceList();
                await _redis.GetDatabase().StringSetAsync(wcs_redis_key + RedisKeyEnum.DeviceList, JsonConvert.SerializeObject(deviceList));
            }
            else
            {
                deviceList = JsonConvert.DeserializeObject<List<WcsDevice>>(deviceListData);
            }
            return deviceList;
        }

    }
}
*/