ELK/Furnace/FurnaceRT/Equipments/CarrierRobots/CarrierRobotModuleDevice.cs

using System;
using System.Collections.Generic;
using System.Diagnostics;
using Aitex.Core.Common;
using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Device;
using Aitex.Core.RT.Device.Unit;
using Aitex.Core.RT.Event;
using Aitex.Core.RT.Fsm;
using Aitex.Core.RT.OperationCenter;
using Aitex.Core.RT.Routine;
using Aitex.Core.RT.SCCore;
using Aitex.Core.Utilities;
using Aitex.Sorter.Common;
using MECF.Framework.Common.Alarms;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.Event;
using MECF.Framework.Common.Schedulers;
using MECF.Framework.Common.SubstrateTrackings;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.LoadPorts;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.Robot;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.Robots;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.Robots.RobotBase;
using FurnaceRT.Equipments.Systems;
using FurnaceRT.Devices;
using IoDoor =  FurnaceRT.Devices.IoDoor;
using Aitex.Core.Util;

namespace FurnaceRT.Equipments.CarrierRobots
{
    public partial class CarrierRobotModule
    {
        private List<AlarmEventItem> _triggeredAlarmList = new List<AlarmEventItem>();
        private int _alarmNumber;
        public RobotBaseDevice CarrierRobotDevice { get; set; }
        public IoBufferMotor BufferDevice { get; set; }
        private IoTrigger _trigAlarmReset;
        private IoAlarmSignal _alarmSignaRobotAlarm;
        private R_TRIG _alarmSignaRobotAlarmTrig = new R_TRIG();
        public IoDoor DoorDevice { get; set; }
        public IoAlarmSignal AlarmSignaFOUPRobotTPStatusWarning { get; set; }

        public void InitDevice()
        {
            CarrierRobotDevice = DEVICE.GetDevice<RobotBaseDevice>($"{Module}");
            BufferDevice = DEVICE.GetDevice<IoBufferMotor>($"PM1.BufferServo");
            DoorDevice = DEVICE.GetDevice<IoDoor>($"PM1.AGVDoor");
            AlarmSignaFOUPRobotTPStatusWarning = DEVICE.GetDevice<IoAlarmSignal>($"PM1.AlarmSignaFOUPRobotTPStatusWarning");
            _alarmSignaRobotAlarm = DEVICE.GetDevice<IoAlarmSignal>($"PM1.AlarmSignaFOUPRobotAlarm");
            _trigAlarmReset = DEVICE.GetDevice<IoTrigger>($"PM1.TrigFOUPRobotAlarmReset");
            CarrierManager.Instance.SubscribeLocation(Module, 1, SC.GetValue<int>("System.CassetteSlotCount"));
            WaferManager.Instance.SubscribeLocation(Module, SC.GetValue<int>("System.CassetteSlotCount"));
            this.OnDeviceAlarmStateChanged += OnModuleDeviceAlarmStateChanged;
            CarrierRobotDevice.OnDeviceAlarmStateChanged += OnModuleDeviceAlarmStateChanged;
        }
        public void OnModuleDeviceAlarmStateChanged(string deviceId, AlarmEventItem alarmItem)
        {
            if (alarmItem.IsTriggered)
            {
                EventLevel level = alarmItem.Level;

                _triggeredAlarmList.Add(alarmItem);

                if (level == EventLevel.Alarm)
                {
                    try
                    {
                        EV.PostAlarmLog(Module, alarmItem);
                    }
                    catch (Exception ex)
                    {
                        EV.WriteEvent(ex.Message.ToString());
                    }
                }
                else
                {
                    EV.PostWarningLog(Module, alarmItem);
                }
            }
            else
            {
            }
        }
        public void SetCassetteRobotReset()
        {
            CarrierRobotDevice.RobotReset();
        }
        public bool SetCassetteRobotHome(out string reason)
        {
            reason = string.Empty;
            return CarrierRobotDevice.HomeModule(null);
        }
        public bool SetSpeed(int speed, out string reason)
        {
            reason = string.Empty;
            return CarrierRobotDevice.SetSpeed("SetSpeed", speed);
        }
        public bool RequestCassettePresent(Hand hand, out string reason)
        {
            reason = string.Empty;
            RobotArmEnum arm = hand == Hand.Blade1 ? RobotArmEnum.Blade1 : RobotArmEnum.Blade2;
            List<object> paras = new List<object>() { "CurrentStatus", arm };
            return CarrierRobotDevice.ReadParameter(paras.ToArray());
        }
        public bool RobotPick(ModuleName target, int targetSlot, Hand hand, out string reason)
        {
            reason = string.Empty;
            RobotArmEnum arm = hand == Hand.Blade1 ? RobotArmEnum.Blade1 : RobotArmEnum.Both;
            return CarrierRobotDevice.Pick(arm, target.ToString(), targetSlot);
        }
        public bool RobotPlace(ModuleName target, int targetSlot, Hand hand, out string reason)
        {
            reason = string.Empty;
            RobotArmEnum arm = hand == Hand.Blade1 ? RobotArmEnum.Blade1 : RobotArmEnum.Both;
            return CarrierRobotDevice.Place(arm, target.ToString(), targetSlot);
        }
        public bool RobotGoto(ModuleName target, int targetSlot, Hand hand, bool isPickReady, out string reason)
        {
            reason = string.Empty;
            RobotArmEnum arm = hand == Hand.Blade1 ? RobotArmEnum.Blade1 : RobotArmEnum.Blade2;
            List<object> paras = new List<object>() { arm, target, targetSlot, isPickReady ? "PickReady" : "PlaceReady" };
            return CarrierRobotDevice.GoTo(paras.ToArray());
        }

        public void Stop()
        {
            CarrierRobotDevice.Stop();
        }

        public void SetBufferTargetPosition(string module)
        {
            int.TryParse(module.Replace("Stocker", ""), out int target);
            BufferDevice.SetServoTargetPosition(target);
        }

        public bool SetBufferMoveTo()
        {
            return BufferDevice.SetServoMoveTo();
        }
        public bool CheckBufferTargetPosition(string module)
        {
            int.TryParse(module.Replace("Stocker", ""), out int target);
            return (int)(BufferDevice.ServoMovePositionSet + 0.00001) == target && BufferDevice.TargetPositionFb == target;
        }
    }
}