大件

zxx

2025-07-03 eef16e0bb8ddb518c6726f04d4ac43dfd3feca2a

 HH.WCS.Mobox3/HH.WCS.Mobox3.XiaoMi/process/TaskProcess.cs

@@ -714,6 +714,7 @@
                        result = list.OrderBy(s => s.N_ROW).ThenBy(x => x.N_COL).FirstOrDefault();

                    }
                    
                }

            }
@@ -875,897 +876,6 @@
            return result;
        }

        #region 巨石代码
        /// <summary>
        /// 常规送检缓存区货位 abc三个区 两层
        /// </summary>
        /// <param name="startloc">起点货位</param>
        /// <param name="area">库区</param>
        /// <returns></returns>
        public static Location InCgWorkTransport(string startloc, string area)
        {
            Location result = null;
            var db = new SqlHelper<object>().GetInstance();
            try
            {
                //A,B,C3个货架上，这个要有优先级了,CX03,04优先送到A区货架，CX01,CX02优先送到B,C货架
                var reservoirs = Settings.ReservoirAreas.Where(s => s.areaName == "送检缓存区").FirstOrDefault();

                var alllist = db.Queryable<Location>().Where(a => a.S_AREA_CODE.Trim() == reservoirs.areaCode).ToList();
                // 从配置获取优先级规则
                var mapping = Settings.PriorityLocs.FirstOrDefault(m => m.Location == startloc);
                LogHelper.Info($"配置的优先级规则{JsonConvert.SerializeObject(mapping)}");
                if (mapping == null)
                {
                    LogHelper.Info($"未找到产线{startloc}的优先级配置");
                    return null;
                }
                var primaryAreas = mapping.PrimaryArea.Split(',');
                var secondaryAreas = mapping.SecondaryArea.Split(',');
                LogHelper.Info($"优先：{JsonConvert.SerializeObject(primaryAreas)}次选：{JsonConvert.SerializeObject(secondaryAreas)}");
                // 筛选未锁且有空的货位
                var availablePrimaryLocations = FilterAvailableLocations(alllist, primaryAreas);
                //优先
                result = availablePrimaryLocations.OrderBy(l => l.N_COL).ThenBy(l => l.N_LAYER).FirstOrDefault();

                // 次选
                if (result == null)
                {
                    var availableSecondaryLocations = FilterAvailableLocations(alllist, secondaryAreas);
                    result = availableSecondaryLocations.OrderBy(l => l.N_COL).ThenBy(l => l.N_LAYER).FirstOrDefault();
                }

                return result;

            }
            catch (Exception ex)
            {
                Console.WriteLine("InWorkTransport:" + ex.Message + ex.StackTrace);
                LogHelper.Error("InWorkTransport:" + ex.Message, ex);
            }
            return result;
        }
        //筛选可用位置
        private static List<Location> FilterAvailableLocations(List<Location> locations, string[] targetAreas)
        {
            return locations
                .Where(l => targetAreas.Any(area => l.S_CODE.Contains(area)))
                .Where(l => l.N_LOCK_STATE == 0 && l.C_ENABLE == "Y" && l.N_CURRENT_NUM < l.N_CAPACITY)
                .ToList();
        }

        /// <summary>
        /// 紧凑型入库货位  紧急送检区 空托缓存一、二区
        /// </summary>
        /// <param name="area">库区</param>
        /// <returns></returns>
        public static Location CompactWorkTransport(string area)
        {
            Location result = null;
            var db = new SqlHelper<object>().GetInstance();
            try
            {
                //查询每排最后一列有托盘的货位  根据行分区 再找每一行的最后一列有货的货位
                var list = db.Queryable<Location>().
                    Where(a => a.N_CURRENT_NUM > 0 && a.S_AREA_CODE.Trim() == area).PartitionBy(a => a.N_ROW)
                    .OrderByDescending(a => a.N_COL).Take(1).ToList();
                if (list.Count > 0)
                {
                    for (int i = 0; i < list.Count; i++)
                    {
                        LogHelper.Info($"有托盘排号{list[i].N_ROW}，库区{area}");

                        //入货位后一位货位
                        result = db.Queryable<Location>().OrderBy(a => a.N_COL)
                            .Where(a => a.S_AREA_CODE.Trim() == area && a.N_ROW == list[i].N_ROW
                            && a.N_COL > list[i].N_COL).First();
                        if (result != null && result.N_LOCK_STATE == 0 && result.C_ENABLE == "Y")
                        {
                            return result;
                        }
                    }
                }
                //没找到说明库区是空的 入里面
                else
                {
                    result = db.Queryable<Location>().
                    Where(a => a.S_AREA_CODE.Trim() == area && a.N_LOCK_STATE == 0 && a.C_ENABLE == "Y" && a.N_CURRENT_NUM == 0)
                    .OrderBy(a => a.N_COL).OrderBy(a => a.N_ROW).First();
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("InWorkTransport:" + ex.Message + ex.StackTrace);
                LogHelper.Error("InWorkTransport:" + ex.Message, ex);
            }
            return result;
        }

        

        /// <summary>
        /// 物料下线/送检缓存区->常规送检区
        /// </summary>
        /// <param name="model.START_LOC">起点货位</param>
        /// <param name="model.END_AREA">终点货区</param>
        /// <param name="model.S_ITEM_CODE">物料（选填）</param>
        /// <returns></returns>
        internal static Results materialOffline(GetSubmitCheck model)
        {
            var result = new Results() { Code = "0", Message = "下线任务生成成功！", Data = null };
            var db = new SqlHelper<Location>().GetInstance();
            try
            {
                //校验起点货位是否存在/锁住
                var loc = db.Queryable<Location>().Where(a => a.S_CODE == model.START_LOC).First();
                if (loc == null || loc.N_LOCK_STATE != 0 || loc.C_ENABLE != "Y")
                {
                    return new Results { Code = "1", Message = $"{model.START_LOC}库位已被锁定!", Data = null };
                }
                //计算终点货位
                if (string.IsNullOrEmpty(model.END_AREA))
                {
                    return new Results { Code = "1", Message = "出库未传终点库区!", Data = null };
                }
                //如果是紧急送检区 紧凑型
                var reservoirs = Settings.ReservoirAreas.Where(s => s.areaName == "紧急送检区").FirstOrDefault();
                //如果是送检缓存区
                var reservoirs2 = Settings.ReservoirAreas.Where(s => s.areaName == "送检缓存区").FirstOrDefault();
                Location OutLoc = null;
                if (model.END_AREA.Equals(reservoirs.areaCode))
                {
                    LogHelper.Info($"紧急送检区==================");
                    OutLoc = CompactWorkTransport(model.END_AREA);
                }
                else if (model.END_AREA.Equals(reservoirs2.areaCode))
                {
                    LogHelper.Info($"送检缓存区==================");
                    OutLoc = InCgWorkTransport(model.START_LOC, model.END_AREA);
                }
                else
                {
                    LogHelper.Info($"其他==================");
                    OutLoc = InWorkTransport(model.END_AREA);
                }

                //没传物料的话默认一个
                string itemCode = null;
                string wlName = null;
                if (!string.IsNullOrEmpty(model.S_ITEM_CODE))
                {
                    itemCode = model.S_ITEM_CODE;
                    wlName = "布卷";
                    //wlName = db.Queryable<TN_Material>().Where(b => b.S_ITEM_CODE == model.S_ITEM_CODE).First().S_ITEM_NAME;
                }
                //创建托盘货位绑定关系
                string trayCode = ContainerHelper.GenerateCntrNo();
                //绑定起点货位(产线)和物料      不传的话这里没有绑物料托盘表 只绑了托盘货位表
                ContainerHelper.BindLocCntrs(model.START_LOC, trayCode, itemCode, wlName);

                var reservoirs1 = Settings.ReservoirAreas.Where(s => s.areaName == "常规送检区").FirstOrDefault();
                //创建任务
                LogHelper.Info($"创建任务 起点:{model.START_LOC}终点:{OutLoc.S_CODE}", OutLoc.S_CODE == reservoirs1.areaCode ? "常规送检" : "物料下线");
                var res = TaskProcess.CreateTransport(model.START_LOC, OutLoc.S_CODE, OutLoc.S_CODE == reservoirs1.areaCode ? "常规送检" : "物料下线", trayCode, 1, 1);

                if (!res)
                {
                    return new Results { Code = "1", Message = "下线任务生成失败!", Data = null };

                }
                return result;
            }
            catch (Exception ex)
            {
                Console.WriteLine("materialOffline:" + ex.Message + ex.StackTrace);
                LogHelper.Error("materialOffline:" + ex.Message, ex);
                throw;
            }
        }
        /// <summary>
        /// 呼叫空托
        /// </summary>
        /// <param name="model.START_LOC">起点类型(拆托机)</param>
        /// <param name="model.END_LOC">终点货位(产线)</param>
        /// <returns></returns>
        internal static Results CallEmptyTray(GetSubmitCheck model)
        {
            var result = new Results() { Code = "0", Message = "呼叫空托任务生成成功！", Data = null };
            var db = new SqlHelper<Location>().GetInstance();
            try
            {
                //必填参数校验
                if (string.IsNullOrEmpty(model.START_LOC))
                {
                    return new Results { Code = "1", Message = "呼叫空托未传起点库位!", Data = null };
                }
                if (string.IsNullOrEmpty(model.END_LOC))
                {
                    return new Results { Code = "1", Message = "呼叫空托未传终点库位!", Data = null };
                }
                //校验终点货位是否存在/锁定
                var loc = db.Queryable<Location>().Where(a => a.S_CODE == model.END_LOC).First();
                if (loc == null || loc.N_LOCK_STATE != 0 || loc.C_ENABLE != "Y")
                {
                    return new Results { Code = "1", Message = $"{model.END_LOC}库位已被锁定!", Data = null };
                }
                ////从配置根据拆托机类型找到出口货位
                //var reservoirs = Settings.linePlcInfos.Where(s => s.code == model.S_TYPE).FirstOrDefault();
                //string OutLocStr = reservoirs.outLoca;

                //如果终点和产线下线是同一个货位 终点也不绑托盘
                string trayCode = ContainerHelper.GenerateCntrNo();
                //创建任务
                LogHelper.Info($"创建任务 起点:{model.START_LOC}终点:{model.END_LOC}", "呼叫空托");
                var res = TaskProcess.CreateTransport(model.START_LOC, model.END_LOC, "呼叫空托", trayCode, 1, 1);
                if (!res)
                {
                    return new Results { Code = "1", Message = "呼叫空托任务生成失败!", Data = null };

                }
                return result;
            }
            catch (Exception ex)
            {
                Console.WriteLine("CallEmptyTray:" + ex.Message + ex.StackTrace);
                LogHelper.Error("CallEmptyTray:" + ex.Message, ex);
                throw;
            }
        }
        /// <summary>
        /// 送检  常规送检区-->紧急送检区
        /// </summary>
        /// <param name="model.START_LOC">起点货位（选填）</param>
        /// <param name="model.S_ITEM_CODE">物料（选填）</param>
        /// <returns></returns>
        internal static Results submitCheck(GetSubmitCheck model)
        {
            var result = new Results() { Code = "0", Message = "送检任务生成成功！", Data = null };
            var db = new SqlHelper<Location>().GetInstance();
            try
            {
                string startloc = "";
                //物料不为空则根据物料找起点货位
                if (!string.IsNullOrEmpty(model.S_ITEM_CODE))
                {
                    //根据物料找货位
                    var cgreservoirs = Settings.ReservoirAreas.Where(s => s.areaName == "常规送检区").FirstOrDefault();
                    startloc = getLocByMaterial(model.S_ITEM_CODE, cgreservoirs.areaCode).S_CODE;
                    if (startloc == null)
                    {
                        return new Results { Code = "1", Message = $"{model.S_ITEM_CODE}未找到该物料!", Data = null };
                    }
                }
                //如果传了起点
                if (!string.IsNullOrEmpty(model.START_LOC))
                {
                    var loc = db.Queryable<Location>().Where(a => a.S_CODE == model.START_LOC).First();
                    if (loc == null || loc.N_LOCK_STATE != 0 || loc.C_ENABLE != "Y")
                    {
                        return new Results { Code = "1", Message = $"{model.START_LOC}库位已被锁定!", Data = null };
                    }
                    startloc = loc.S_CODE;
                }
                //计算紧急送检区终点货位
                var reservoirs = Settings.ReservoirAreas.Where(s => s.areaName == "紧急送检区").FirstOrDefault();
                Location OutLoc = TaskProcess.CompactWorkTransport(reservoirs.areaCode);
                if (OutLoc == null)
                {
                    return new Results { Code = "1", Message = $"终点库区紧急送检区未找到空货位!", Data = null };
                }
                //创建送检任务
                var locCntrRel = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE == model.START_LOC).First();

                LogHelper.Info($"创建任务 起点:{startloc}终点:{OutLoc.S_CODE}", "送检");
                var res = TaskProcess.CreateTransport(startloc, OutLoc.S_CODE, "送检", locCntrRel.S_CNTR_CODE, 1, 1);
                if (!res)
                {
                    return new Results { Code = "1", Message = "送检任务生成失败!", Data = null };

                }
                return result;
            }
            catch (Exception ex)
            {
                Console.WriteLine("submitCheck:" + ex.Message + ex.StackTrace);
                LogHelper.Error("submitCheck:" + ex.Message, ex);
                throw;
            }
        }

        /// <summary>
        /// 根据物料找货位  根据CntrItemDetail时间 先进先出  连表查判断货位有没有锁
        /// </summary>
        /// <param name="itemCode">物料</param>
        /// <returns></returns>
        public static Location getLocByMaterial(string itemCode, string areaCode)
        {
            Location result = null;
            try
            {
                var db = new SqlHelper<object>().GetInstance();
                //两表联查查出有该物料的货位编号  （现场没有物料表）
                var locCntrs = db.Queryable<LocCntrRel>().LeftJoin<CntrItemDetail>((p, m) => p.S_CNTR_CODE == m.S_CNTR_CODE)
                .Where((p, m) => m.S_ITEM_CODE == itemCode)
                .OrderBy((p, m) => p.T_CREATE)  //按创建时间顺序
                .Select((p, m) => p.S_LOC_CODE) // 选择托盘物料表的数据
                .ToList();
                LogHelper.Info($"有物料{itemCode}的货位编号{JsonConvert.SerializeObject(locCntrs)}");
                //找常规送检区内含有查出物料货位的货位
                var locList = db.Queryable<Location>()
                    .Where(p => p.S_AREA_CODE == areaCode && p.N_LOCK_STATE == 0 && p.C_ENABLE == "Y")
                    .Where(s => locCntrs.Contains(s.S_CODE.Trim()))
                    .ToList();

                if (!locList.Any())
                {
                    return null;
                }
                result = locList.FirstOrDefault();
            }
            catch (Exception ex)
            {
                Console.WriteLine("getLocByMaterial:" + ex.Message + ex.StackTrace);
                LogHelper.Error("getLocByMaterial:" + ex.Message, ex);
            }
            return result;
        }

        //存摄像头调用接口空满状态   货位，空满状态
        private static string monitorStatus = null;
        /// <summary>
        /// 摄像头监测接口   
        /// </summary>
        /// <param name="models.PointCode">监测货位</param>
        /// <param name="models.PointStatus">监测空满状态0空闲1占用3异常</param>
        /// <returns></returns>
        internal static Results UpdateFullStatus(List<CameraMonitor> models)
        {
            var result = new Results() { Code = "0", Message = "操作成功", Data = null };
            var db = new SqlHelper<object>().GetInstance();
            //校验与内存是否一致
            if (monitorStatus != null)
            {
                try
                {
                    //string转成list
                    var jsonList = JsonConvert.DeserializeObject<List<CameraMonitor>>(monitorStatus);
                    //找两个List的交集
                    var intersection = jsonList.Where(j => models.Any(m =>
                        m.PointCode == j.PointCode && m.PointStatus == j.PointStatus)).ToList();
                    LogHelper.Info($"摄像头与上次调用一致数据：{JsonConvert.SerializeObject(intersection)}");
                    foreach (var model in intersection)
                    {
                        //找到该点位的库区
                        var loc = db.Queryable<Location>().Where(a => a.S_CODE == model.PointCode).First();
                        //没锁再继续走
                        if (loc.N_LOCK_STATE == 0 && loc.C_ENABLE == "Y" && loc != null)
                        {
                            var reservoirs = Settings.ReservoirAreas.Where(s => s.areaName == "送检入库区").FirstOrDefault();
                            //如果是送检入库区
                            if (reservoirs.areaCode.Equals(loc.S_AREA_CODE))
                            {
                                var locCntrRel = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE == model.PointCode).First();
                                var container = new Container();
                                if (locCntrRel == null)
                                {
                                    //第一次自己绑定一个托盘
                                    string trayCode = ContainerHelper.GenerateCntrNo();
                                    ContainerHelper.BindLocCntrs(model.PointCode, trayCode, null, null);
                                    container = db.Queryable<Container>().Where(a => a.S_CODE == trayCode).First();
                                    container.C_FULL = "2";
                                }
                                else
                                {
                                    //查数据库空满状态 跟缓存不一样则更新
                                    //找到这个货位的容器 空满状态C_FULL改成2满  0 -- 空 1 -- 有货 2 -- 满
                                    container = db.Queryable<Container>().Where(a => a.S_CODE == locCntrRel.S_CNTR_CODE).First();
                                    if (container.C_FULL != model.PointStatus.ToString())
                                    {
                                        container.C_FULL = "2";
                                    }
                                }
                                var res = db.Updateable(container).UpdateColumns(it => it.C_FULL).ExecuteCommand() > 0;
                                if (res)
                                {
                                    LogHelper.Info($"修改{model.PointCode}货位空满状态成功", "摄像头监测");
                                }
                                else
                                {
                                    LogHelper.Info($"修改{model.PointCode}货位空满状态失败", "摄像头监测");
                                }
                            }
                            else
                            {
                                //如果是空托缓存区  判断拆托机是否有空位 空托缓存区满了且拆托机入口有空则创建任务
                                var reservoirs1 = Settings.ReservoirAreas.Where(s => s.areaName == "3min空托区").FirstOrDefault();
                                var reservoirs2 = Settings.ReservoirAreas.Where(s => s.areaName == "6min空托区").FirstOrDefault();
                                if (loc.S_AREA_CODE.Equals(reservoirs1.areaCode) || loc.S_AREA_CODE.Equals(reservoirs2.areaCode))//三寸空托
                                {
                                    ProcessEmptyTrayAreas(db, loc, reservoirs1.areaCode, reservoirs2.areaCode);
                                }
                            }
                        }
                        else
                        {
                            LogHelper.Info($"{model.PointCode}货位任务已经生成", "摄像头监测");
                        }

                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine("UpdateFullStatus:" + ex.Message + ex.StackTrace);
                    LogHelper.Error("UpdateFullStatus:" + ex.Message, ex);
                    throw;
                }
            }
            //list转string 存到内存
            monitorStatus = JsonConvert.SerializeObject(models);

            return result;
        }
        //摄像头监测空托缓存区
        private static void ProcessEmptyTrayAreas(SqlSugar.ISqlSugarClient db, Location loc, string areaCode1, string areaCode2)
        {
            var plcDeviceTable = S7Helper.plcDeviceTables;
            if (plcDeviceTable != null)
            {
                string endLoc = null;
                bool request = false;
                if (loc.S_AREA_CODE.Equals(areaCode1))
                {
                    request = plcDeviceTable.requestPut1;
                    endLoc = Settings.linePlcInfos.Where(s => s.code == "拆托机1").FirstOrDefault().inLoca;
                }
                else if (loc.S_AREA_CODE.Equals(areaCode2))//六寸空托
                {
                    request = plcDeviceTable.requestPut2;
                    endLoc = Settings.linePlcInfos.Where(s => s.code == "拆托机2").FirstOrDefault().inLoca;
                }
                //判断是否允许放框
                if (request)
                {
                    //创建任务 从空托缓存区到拆托机
                    var list = db.Queryable<Location>().Where(a => a.S_AREA_CODE.Trim() == loc.S_AREA_CODE
                    && a.N_CURRENT_NUM > 0 && a.N_LOCK_STATE == 0 && a.C_ENABLE == "Y").OrderByDescending(a => a.N_ROW)
                    .OrderByDescending(a => a.N_COL).First();
                    var startLoc = list.S_CODE;

                    string trayCode = ContainerHelper.GenerateCntrNo();

                    LogHelper.Info($"创建任务 起点:{startLoc}终点:{endLoc}", "拆托");
                    var res = TaskProcess.CreateTransport(startLoc, endLoc, "拆托", trayCode, 1, 1);
                    if (res)
                    {
                        LogHelper.Info($"起点:{startLoc}终点:{endLoc}任务创建成功", "拆托");
                    }
                    else
                    {
                        LogHelper.Info($"起点:{startLoc}终点:{endLoc}任务创建失败", "拆托");
                    }
                }
            }
            else
            {
                LogHelper.Info($"未读取到拆托机信号", "拆托");

            }

        }
        /// <summary>
        /// 抽检主动呼叫    起点：送检缓存区
        /// </summary>
        /// <param name="model.S_ITEM_CODE">物料</param>
        /// <param name="model.END_LOC">终点货位</param>
        /// <returns></returns>
        internal static Results activeCall(GetSubmitCheck model)
        {
            var result = new Results() { Code = "0", Message = "抽检主动呼叫任务生成成功！", Data = null };
            var db = new SqlHelper<Location>().GetInstance();
            try
            {
                //根据物料找某库区的货位
                var cgreservoirs = Settings.ReservoirAreas.Where(s => s.areaName == "送检缓存区").FirstOrDefault();
                var startloc = getLocByMaterial(model.S_ITEM_CODE, cgreservoirs.areaCode);
                if (startloc == null)
                {
                    return new Results { Code = "1", Message = $"未找到包含物料{model.S_ITEM_CODE}的货位", Data = null };
                }
                //终点
                var endloc = db.Queryable<Location>().Where(a => a.S_CODE == model.END_LOC).First();
                if (endloc == null || endloc.N_LOCK_STATE != 0 || endloc.C_ENABLE != "Y")
                {
                    return new Results { Code = "1", Message = $"{model.END_LOC}库位已被锁定!", Data = null };
                }
                //创建任务
                var locCntrRel = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE == startloc.S_CODE).First();

                LogHelper.Info($"创建任务 起点:{startloc.S_CODE}终点:{endloc.S_CODE}", "抽检主动呼叫");
                var res = TaskProcess.CreateTransport(startloc.S_CODE, endloc.S_CODE, "抽检主动呼叫", locCntrRel.S_CNTR_CODE, 1, 1);
                if (!res)
                {
                    return new Results { Code = "1", Message = "抽检主动呼叫任务生成失败!", Data = null };

                }
                return result;
            }
            catch (Exception ex)
            {
                Console.WriteLine("submitCheck:" + ex.Message + ex.StackTrace);
                LogHelper.Error("submitCheck:" + ex.Message, ex);
                throw;
            }
        }
        /// <summary>
        /// 主动物料绑定
        /// </summary>
        /// <param name="model.S_ITEM_CODE">物料编码(选填)</param>
        /// <param name="model.BIND_LOC">绑定货位</param>
        /// <returns></returns>
        internal static Results bindMaterial(GetSubmitCheck model)
        {
            var result = new Results() { Code = "0", Message = "物料绑定成功！", Data = null };
            var db = new SqlHelper<object>().GetInstance();
            try
            {
                var loc = db.Queryable<Location>().Where(a => a.S_CODE == model.BIND_LOC).First();
                if (loc == null || loc.N_LOCK_STATE != 0 || loc.C_ENABLE != "Y")
                {
                    return new Results { Code = "1", Message = $"绑定货位不存在或已被锁", Data = null };

                }
                string cntrStr = ContainerHelper.GenerateCntrNo();
                var locCntrRel = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE == model.BIND_LOC).First();
                if (locCntrRel != null)
                {
                    cntrStr = locCntrRel.S_CNTR_CODE;
                }
                var res = ContainerHelper.BindLocCntrs(model.BIND_LOC, cntrStr, model.S_ITEM_CODE, "布卷");
                if (!res)
                {
                    return new Results { Code = "1", Message = $"物料{model.S_ITEM_CODE}货位{model.BIND_LOC}绑定失败", Data = null };
                }
                loc.N_CURRENT_NUM++;
                var res2 = db.Updateable(loc).UpdateColumns(it => it.N_CURRENT_NUM).ExecuteCommand() > 0;
                if (!res2)
                {
                    return new Results { Code = "1", Message = $"货位{model.BIND_LOC}当前数量自增失败", Data = null };
                }
                return result;
            }
            catch (Exception ex)
            {
                Console.WriteLine("bindMaterial:" + ex.Message + ex.StackTrace);
                LogHelper.Error("bindMaterial:" + ex.Message, ex);
                throw;
            }
        }
        /// <summary>
        /// 整排物料绑定
        /// </summary>
        /// <param name="bondLoc">绑定货位</param>
        /// <returns></returns>
        internal static Results multBindMaterial(string bondLoc)
        {
            var result = new Results() { Code = "0", Message = "整排物料绑定成功！", Data = null };
            var db = new SqlHelper<object>().GetInstance();
            try
            {
                var location = db.Queryable<Location>().Where(a => a.S_CODE == bondLoc).First();
                //查出这一排的货位
                var loclist = db.Queryable<Location>()
                    .Where(a => a.S_AREA_CODE == location.S_AREA_CODE && a.N_ROW == location.N_ROW).ToList();
                foreach (var loc in loclist)
                {
                    //没锁的且没货的才绑
                    if (loc.N_LOCK_STATE == 0 && loc.N_CURRENT_NUM < loc.N_CAPACITY)
                    {


                    }

                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("multBindMaterial:" + ex.Message + ex.StackTrace);
                LogHelper.Error("multBindMaterial:" + ex.Message, ex);
                throw;
            }


            return result;
        }
        /// <summary>
        /// 按钮盒调用下线
        /// </summary>
        /// <param name="startLoc">起点货位</param>
        /// <param name="endArea">终点货区</param>
        /// <returns></returns>
        internal static bool tcpOffline(string startLoc, string endArea)
        {
            var db = new SqlHelper<Location>().GetInstance();

            LogHelper.Info($"tcpOffline=====参数:起点货位{startLoc}终点库区{endArea}");
            try
            {
                //校验起点货位是否存在/锁住
                var loc = db.Queryable<Location>().Where(a => a.S_CODE == startLoc).First();
                if (loc == null || loc.N_LOCK_STATE != 0 || loc.C_ENABLE != "Y")
                {
                    LogHelper.Info("起点货位不存在或已锁" + startLoc);
                    return false;
                }
                //计算终点货位
                //if (string.IsNullOrEmpty(endArea))
                //{
                //    return new Results { Code = "1", Message = "出库未传终点库区!", Data = null };
                //}
                //如果是紧凑型
                var reservoirs = Settings.ReservoirAreas.Where(s => s.areaName == "紧急送检区").FirstOrDefault();
                Location OutLoc = null;
                if (endArea.Equals(reservoirs.areaCode))
                {
                    OutLoc = CompactWorkTransport(endArea);
                }
                else
                {
                    OutLoc = InWorkTransport(endArea);
                }
                //创建托盘货位绑定关系
                string trayCode = ContainerHelper.GenerateCntrNo();
                //没传物料的话默认一个
                string itemCode = null;
                string wlName = null;
                //if (!string.IsNullOrEmpty(model.S_ITEM_CODE))
                //{
                //    itemCode = model.S_ITEM_CODE;
                //    wlName = db.Queryable<TN_Material>().Where(b => b.S_ITEM_CODE == model.S_ITEM_CODE).First().S_ITEM_NAME;
                //}
                if (OutLoc == null)
                {
                    LogHelper.Info($"终点货位不存在", "按钮盒下线");
                    return false;
                }
                ContainerHelper.BindLocCntrs(OutLoc.S_CODE, trayCode, itemCode, wlName);
                //创建任务
                LogHelper.Info($"创建任务 起点:{startLoc}终点:{OutLoc.S_CODE}", "按钮盒下线");
                return TaskProcess.CreateTransport(startLoc, OutLoc.S_CODE, "按钮盒下线", trayCode, 1, 1);

            }
            catch (Exception ex)
            {
                Console.WriteLine("tcpOffline:" + ex.Message + ex.StackTrace);
                LogHelper.Error("tcpOffline:" + ex.Message, ex);
                throw;
            }
        }
        /// <summary>
        /// 按钮盒调用空托
        /// </summary>
        /// <param name="startLoc">起点货位</param>
        /// <param name="endLoc">终点货位</param>
        /// <returns></returns>
        internal static bool tcpEmptyTray(string startLoc, string endLoc)
        {
            var db = new SqlHelper<Location>().GetInstance();
            try
            {
                //校验终点货位是否锁
                var endloc = db.Queryable<Location>().Where(a => a.S_CODE == endLoc).First();
                if (endloc == null || endloc.N_LOCK_STATE != 0 || endloc.C_ENABLE != "Y")
                {
                    LogHelper.Info("终点货位已锁" + endLoc);
                    return false;
                }
                //创建托盘货位绑定关系
                string trayCode = ContainerHelper.GenerateCntrNo();
                //创建任务
                LogHelper.Info($"创建任务 起点:{startLoc}终点:{endLoc}", "按钮盒调用空托");
                return TaskProcess.CreateTransport(startLoc, endLoc, "按钮盒调用空托", trayCode, 1, 1);

            }
            catch (Exception ex)
            {
                Console.WriteLine("materialOffline:" + ex.Message + ex.StackTrace);
                LogHelper.Error("materialOffline:" + ex.Message, ex);
                throw;
            }
        }


        /// <summary>
        /// 安全交互
        /// </summary>
        /// <param name="model.STATION_NAME">请求点位</param>
        /// <param name="model.APPLY_CODE">请求码</param>
        /// <returns></returns>
        internal static safeResult safetyInteraction(SafetyInteraction model)
        {
            //0允许进入 1不允许进入
            var result = new safeResult() { code = "1", msg = "success" };
            try
            {
                var reservoirs = Settings.SafeInteractions.Where(s => s.location == model.STATION_NAME).FirstOrDefault();//y0-0000 y1-0001  on-FF00  off-0000
                //var rgvSafeInteraction = DeviceProcess.rgvSafeInteraction;
                var plcDeviceTable = S7Helper.plcDeviceTables;
                if (plcDeviceTable != null)
                {
                    //RGV
                    if (reservoirs.type.Equals("RGV"))
                    {
                        LogHelper.Info($"RGV安全交互  请求点位：{model.STATION_NAME}请求码：{model.APPLY_CODE}");
                        //处理信号
                        var res = int.Parse(plcDeviceTable.RGVAllowUnload[reservoirs.code].ToString().Substring(1, 1));
                        //根据ip读状态
                        LogHelper.Info($"RGV安全交互缓存信号{res}，{JsonConvert.SerializeObject(plcDeviceTable.RGVAllowUnload)}");
                        //卸货请求进入
                        if (model.APPLY_CODE.Equals("5"))
                        {
                            //1允许卸货 
                            if (res == 1)
                            {
                                LogHelper.Info($"RGV安全交互 允许卸货");
                                return new safeResult() { code = "0", msg = "success" };
                            }
                        }
                        //卸货后已离开
                        else if (model.APPLY_CODE.Equals("8"))
                        {
                            //发送卸货完成、复位信号
                            //卸货完成信号
                            S7Helper.WriteInt(50, reservoirs.code * 2 - 2, (short)(reservoirs.code * 10 + 1));

                            // 启动后台任务处理延迟复位
                            Task.Run(async () =>
                            {
                                //10秒后复位
                                await Task.Delay(10000);
                                S7Helper.WriteInt(50, reservoirs.code * 2 - 2, (short)(reservoirs.code * 10));
                                LogHelper.Info($"RGV安全交互 复位完成");
                            });
                            //10秒后复位
                            //S7Helper.WriteInt(50, reservoirs.code * 2 - 2, (short)(reservoirs.code * 10));
                            //safeAssistant(reservoirs.code, res);
                            LogHelper.Info($"RGV安全交互 卸货完成");
                            return new safeResult() { code = "0", msg = "success" };
                        }


                    }
                    //拆托机
                    else if (reservoirs.type.Equals("CTJ"))
                    {
                        LogHelper.Info($"拆托机安全交互  请求点位：{model.STATION_NAME}请求码：{model.APPLY_CODE}");
                        //找到线体 根据线体找内存里的状态
                        var reservoirs1 = Settings.ConveyorLinesInfos.Where(s => s.location == model.STATION_NAME).FirstOrDefault();

                        LogHelper.Info($"拆托机安全交互参数{JsonConvert.SerializeObject(plcDeviceTable)}");
                        if (model.APPLY_CODE.Equals("1"))
                        {
                            //0-脱机状态，1-待机状态，2-运行中    待机且有托盘且请求取框才走
                            if ((reservoirs1.deviceNo == "1" && plcDeviceTable.requestTake1) ||
                                (reservoirs1.deviceNo == "2" && plcDeviceTable.requestTake2))
                            {
                                LogHelper.Info($"拆托机安全交互 允许取框");
                                return new safeResult() { code = "0", msg = "success" };
                            }

                        }
                        else if (model.APPLY_CODE.Equals("5"))
                        {
                            //0-脱机状态，1-待机状态，2-运行中    待机且无托盘且允许放框才走
                            if ((reservoirs1.deviceNo == "1" && plcDeviceTable.requestPut1) ||
                                (reservoirs1.deviceNo == "2" && plcDeviceTable.requestPut2))
                            {
                                LogHelper.Info($"拆托机安全交互 允许放框");
                                return new safeResult() { code = "0", msg = "success" };
                            }
                        }
                        //取货离开
                        else if (model.APPLY_CODE.Equals("4"))
                        {
                            int offsetAddr = 8;
                            if (reservoirs1.deviceNo == "1")
                            {
                                offsetAddr = 1;
                            }
                            else if (reservoirs1.deviceNo == "2")
                            {
                                offsetAddr = 3;
                            }
                            LogHelper.Info($"拆托机安全交互写入{reservoirs1.deviceNo}，{offsetAddr}");
                            S7Helper.WriteDouble(reservoirs1.deviceNo, 9, 182, offsetAddr, 1);
                            LogHelper.Info($"拆托机安全交互 取框离开");
                            return new safeResult() { code = "0", msg = "success" };
                        }
                        //卸货离开
                        else if (model.APPLY_CODE.Equals("8"))
                        {
                            int offsetAddr = 8;//随便给一个
                            if (reservoirs1.deviceNo == "1")
                            {
                                offsetAddr = 0;
                            }
                            else if (reservoirs1.deviceNo == "2")
                            {
                                offsetAddr = 2;
                            }
                            LogHelper.Info($"拆托机安全交互写入{reservoirs1.deviceNo}，{offsetAddr}");
                            S7Helper.WriteDouble(reservoirs1.deviceNo, 9, 182, offsetAddr, 1);
                            LogHelper.Info($"拆托机安全交互 取框离开");
                            return new safeResult() { code = "0", msg = "success" };
                        }

                    }
                }
                return result;
            }
            catch (Exception ex)
            {
                Console.WriteLine("safetyInteraction:" + ex.Message + ex.StackTrace);
                LogHelper.Error("safetyInteraction:" + ex.Message, ex);
                throw;
            }
        }
        //循环发送信号
        private static void safeAssistant(int code, int res)
        {
            Thread.Sleep(10000);
            S7Helper.WriteInt(50, code * 2 - 2, (short)(code * 10));
            LogHelper.Info($"RGV安全交互 复位完成");
            ////2卸货完成确认
            //if (res != 2)
            //{
            //    //卸货完成信号
            //    S7Helper.WriteInt(50, code * 2 - 2, (short)(code * 10 + 1));
            //    Thread.Sleep(3000);
            //    safeAssistant(code, res);
            //}
            //else
            //{
            //    S7Helper.WriteInt(50, code * 2 - 2, (short)(code * 10));
            //}

        }

        /// <summary>
        /// 按钮控制服务开关
        /// </summary>
        /// <param name="isusing.S_STATUS">服务状态</param>
        /// <param name="isusing.S_TYPE">服务类型</param>
        /// <returns></returns>
        internal static Results switchButton(Isusing isusing)
        {
            var db = new SqlHelper<object>().GetInstance();
            var result = new Results() { Code = "1", Message = $"服务状态失败！", Data = null };
            var isusinglist = db.Queryable<Isusing>().Where(a => a.S_TYPE == isusing.S_TYPE).First();
            isusinglist.S_STATUS = isusing.S_STATUS;
            var res = db.Updateable(isusinglist).UpdateColumns(it => it.S_STATUS).ExecuteCommand() > 0;
            if (res)
            {
                return new Results() { Code = "0", Message = $"服务状态修改成功！", Data = null };

            }
            return result;
        }
        //tcp发送信号 测试用
        internal static Results tcpSend(string str)
        {
            var reservoirs = Settings.SafeInteractions.Where(s => s.code == 1).FirstOrDefault();
            //测试用
            LogHelper.Info($"RGV安全交互发送信号{reservoirs.ip},{str}");
            //无状态信号
            bool res = PlcHelper.SendHex(reservoirs.ip, str);
            if (res)
            {
                return new Results() { Code = "0", Message = $"发送成功", Data = null };
            }

            return new Results() { Code = "1", Message = $"发送失败", Data = null };
        }

        #endregion

        /// <summary>
        /// 大件
@@ -1779,7 +889,7 @@
            try
            {
                var startLoc = new Location();
                var endLoc = new Location();
                string endLocStr = null;
                string Message = null;
                switch (model.ts_name)
                {
@@ -1789,12 +899,7 @@
                        {
                            Message = $"{model.parameter.src}库位已被锁定!";
                        }

                        endLoc = db.Queryable<Location>().Where(a => a.S_CODE == model.parameter.dst).First();
                        if (startLoc == null || startLoc.N_LOCK_STATE != 0 || startLoc.C_ENABLE != "Y")
                        {
                            Message = $"{model.parameter.dst}库位已被锁定!";
                        }
                        endLocStr = model.parameter.dst;

                        break;
                    case "p2a":
@@ -1803,31 +908,56 @@
                        {
                            Message = $"{model.parameter.src}库位已被锁定!";
                        }
                        endLoc = InWorkTransport(model.parameter.dst);
                        var endLoc = InWorkTransport(model.parameter.dst_area);
                        if (endLoc==null)
                        {
                            Message = $"{model.parameter.dst}库区没有可入货位!";
                            //如果没找到就等第一条
                            endLocStr = db.Queryable<Location>().Where(a => a.S_AREA_CODE.Trim() == model.parameter.dst).OrderByDescending(a => a.N_ROW).ToList()[0].S_CODE;

                        }
                        break;
                    case "a2p":
                        startLoc = OutWorkTransport(model.parameter.src);
                        startLoc = OutWorkTransport(model.parameter.src_area);
                        if (startLoc==null)
                        {
                            Message = $"{model.parameter.dst}库区没有可出货位!";
                        }

                        endLoc = db.Queryable<Location>().Where(a => a.S_CODE == model.parameter.dst).First();
                        if (startLoc == null || startLoc.N_LOCK_STATE != 0 || startLoc.C_ENABLE != "Y")
                        endLocStr = model.parameter.dst;
                        break;
                    case "a2a":
                        startLoc = OutWorkTransport(model.parameter.src_area);
                        if (startLoc == null)
                        {
                            Message = $"{model.parameter.dst}库位已被锁定!";
                            Message = $"{model.parameter.src}库区没有可出货位!";
                        }
                        var endLoc1 = InWorkTransport(model.parameter.dst_area);
                        if (endLoc1 == null)
                        {
                            //如果没找到就等第一条
                            endLocStr = db.Queryable<Location>().Where(a => a.S_AREA_CODE.Trim() == model.parameter.dst).OrderByDescending(a => a.N_ROW).ToList()[0].S_CODE;

                        }
                        break;
                    case "p2u":
                        startLoc = OutWorkTransport(model.parameter.src);
                        if (startLoc == null)
                        {
                            Message = $"{model.parameter.src}库区没有可出货位!";
                        }
                        endLocStr = "";
                        break;
                }

                //创建托盘货位绑定关系
                string trayCode = ContainerHelper.GenerateCntrNo();
                //绑定起点货位(产线)和物料
                ContainerHelper.BindLocCntrs(startLoc.S_CODE, trayCode, model.parameter.sku, "");

                var locCntrRel = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE == startLoc.S_CODE).First();
                //创建任务
                LogHelper.Info($"创建任务 起点:{startLoc.S_CODE}终点:{endLoc.S_CODE}", model.ts_name);
                var res = TaskProcess.CreateTransport(startLoc.S_CODE, endLoc.S_CODE, model.ts_name, locCntrRel.S_CNTR_CODE, 1, 1);
                LogHelper.Info($"创建任务 起点:{startLoc.S_CODE}终点:{endLocStr}", model.ts_name);
                var res = TaskProcess.CreateTransport(startLoc.S_CODE, endLocStr, model.ts_name, locCntrRel.S_CNTR_CODE, 1, 1);
                if (!res)
                {
                    return new TaskResponse