using Microsoft.Win32;
|
using System;
|
using System.Collections.Generic;
|
using System.IO;
|
using System.Text;
|
using log4net;
|
using log4net.Appender;
|
using log4net.Layout;
|
using log4net.Repository.Hierarchy;
|
using DIT.SharedMemory;
|
|
namespace SHARP_CLAS_UI
|
{
|
public class Alarm_Manager:IDisposable
|
{
|
#region Define
|
readonly string file_name = "Alarm_List.csv";
|
#endregion
|
|
#region Logger
|
/// <summary>
|
/// Alarm Log
|
/// </summary>
|
private ILog Alarm_Log = LogManager.GetLogger("Alarm");
|
|
/// <summary>
|
/// Alarm Log Write
|
/// </summary>
|
/// <param name="Methodname">Method name of exception that occurred</param>
|
/// <param name="ex">exception</param>
|
private void Write_Alarm_Log(string message)
|
{
|
if (Alarm_Log != null) Alarm_Log.Debug($"{message}");
|
}
|
|
/// <summary>
|
/// Create excepton logger
|
/// </summary>
|
private void Create_Alarm_logger()
|
{
|
Hierarchy hierarchy = (Hierarchy)LogManager.GetRepository();
|
RollingFileAppender rollingAppender = new RollingFileAppender();
|
|
PatternLayout layout = new PatternLayout();
|
hierarchy.Configured = true;
|
|
rollingAppender.Name = "Alarm_RoolingFile";
|
rollingAppender.LockingModel = new RollingFileAppender.MinimalLock();
|
rollingAppender.File = @"D:\Logger\Alarm\";
|
rollingAppender.AppendToFile = true;
|
rollingAppender.DatePattern = "yyyy\\\\MM\\\\'Alarm_'dd'.csv'";
|
rollingAppender.RollingStyle = RollingFileAppender.RollingMode.Composite;
|
rollingAppender.MaxSizeRollBackups = 10;
|
rollingAppender.MaximumFileSize = "100MB";
|
rollingAppender.StaticLogFileName = false;
|
rollingAppender.Encoding = Encoding.UTF8;
|
rollingAppender.PreserveLogFileNameExtension = true;
|
layout = new PatternLayout("%d{yyyy/MM/dd HH:mm:ss.fff},%m%n");
|
layout.ActivateOptions();
|
rollingAppender.Layout = layout;
|
rollingAppender.ActivateOptions();
|
|
hierarchy.GetLogger("Alarm");
|
ILog log = LogManager.GetLogger("Alarm");
|
Logger l = (Logger)log.Logger;
|
l.Level = log4net.Core.Level.Debug;
|
l.AddAppender(rollingAppender);
|
|
Alarm_Log = LogManager.GetLogger("Alarm");
|
}
|
#endregion
|
|
#region Property
|
private static readonly Lazy<Alarm_Manager> _instatnce = new Lazy<Alarm_Manager>(() => new Alarm_Manager());
|
|
public static Alarm_Manager Instance
|
{
|
get
|
{
|
return _instatnce.Value;
|
}
|
}
|
|
public List<Alarm_Occurred> Occured_List { get; private set; }
|
#endregion
|
|
#region Field
|
bool IsDisposed;
|
string file_path;
|
|
public SortedList<En_Alarm_List, Alarm> Alarm_List;
|
public En_Alarm_Status Alarm_Status;
|
public Queue<Alarm_Occurred> Occured_Alarm = new Queue<Alarm_Occurred>();
|
public SharedMemory sm;
|
List<SharedmemoryAddressInfo> lst_alarm_memory = new List<SharedmemoryAddressInfo>();
|
#endregion
|
|
#region Construct
|
public Alarm_Manager()
|
{
|
sm = new SharedMemory("SHARP_CLAS", 10000, true);
|
sm.Open();
|
Create_Alarm_logger();
|
|
IsDisposed = false;
|
Alarm_Status = En_Alarm_Status.NONE;
|
|
Get_File_Path();
|
|
Initialize_Alarm_List();
|
|
Occured_List = new List<Alarm_Occurred>();
|
Occured_List.Clear();
|
}
|
#endregion
|
|
#region Function
|
private void Get_File_Path()
|
{
|
RegistryKey rkk = Registry.CurrentUser.OpenSubKey(Equipment.Registry_Path, true);
|
|
try
|
{
|
if (rkk == null)
|
{
|
rkk = Registry.CurrentUser.CreateSubKey(Equipment.Registry_Path);
|
|
rkk.SetValue("ALARM_INFO_PATH", @"C:\SHARP_CLAS\Config\SETTING\");
|
file_path = @"C:\SHARP_CLAS\Config\SETTING\";
|
}
|
else
|
{
|
object value = rkk.GetValue("ALARM_INFO_PATH");
|
if (value == null)
|
{
|
rkk.SetValue("ALARM_INFO_PATH", @"C:\SHARP_CLAS\Config\SETTING\");
|
file_path = @"C:\SHARP_CLAS\Config\SETTING\";
|
}
|
else
|
{
|
file_path = value.ToString();
|
}
|
}
|
|
if (!Directory.Exists(file_path))
|
{
|
Directory.CreateDirectory(file_path);
|
}
|
}
|
finally
|
{
|
rkk.Close();
|
}
|
}
|
|
private void Initialize_Alarm_List()
|
{
|
Alarm_List = new SortedList<En_Alarm_List, Alarm>();
|
Alarm_List.Clear();
|
|
SortedList<En_Alarm_List, Alarm> alarm_datas = Get_Alarm_Info();
|
|
foreach (En_Alarm_List list in Enum.GetValues(typeof(En_Alarm_List)))
|
{
|
if(alarm_datas.ContainsKey(list))
|
{
|
Alarm_List.Add(list, alarm_datas[list]);
|
}
|
else
|
{
|
Alarm_List.Add(list, new Alarm(list));
|
}
|
}
|
|
Save_Alarm_List();
|
lst_alarm_memory.AddRange(Alarm_Memory_Address.Get_Address_Infos());
|
}
|
|
private SortedList<En_Alarm_List, Alarm> Get_Alarm_Info()
|
{
|
string file = file_path + file_name;
|
|
SortedList<En_Alarm_List, Alarm> alarm_list = new SortedList<En_Alarm_List, Alarm>();
|
|
alarm_list.Clear();
|
|
if (File.Exists(file))
|
{
|
foreach(string line in File.ReadAllLines(file))
|
{
|
if (line == "") continue;
|
|
string[] items = line.Split(',');
|
|
if (items.Length < 4) continue;
|
En_Alarm_List list;
|
if (Enum.TryParse(items[0], out list))
|
{
|
if(!alarm_list.ContainsKey(list))
|
{
|
Alarm alarm = new Alarm(list);
|
|
alarm.Set_Heavy(items[1]);
|
alarm.Set_Discription(items[2]);
|
alarm.Set_Use(items[3]);
|
|
alarm_list.Add(list, alarm);
|
}
|
}
|
}
|
}
|
else
|
{
|
File.Create(file);
|
|
foreach (En_Alarm_List list in Enum.GetValues(typeof(En_Alarm_List)))
|
{
|
Alarm alarm = new Alarm(list);
|
alarm_list.Add(list, alarm);
|
}
|
}
|
|
return alarm_list;
|
}
|
|
public void Save_Alarm_List()
|
{
|
string file = file_path + file_name;
|
if (Alarm_List == null) return;
|
|
StringBuilder sb = new StringBuilder();
|
|
string[] lines = new string[Alarm_List.Count];
|
|
foreach(Alarm data in Alarm_List.Values)
|
{
|
sb.AppendLine($"{data.Code},{data.Heavy},{data.Description},{data.Use}");
|
}
|
|
File.WriteAllText(file, sb.ToString());
|
}
|
|
public bool Get_Alarm_Info(int Code, out Alarm info)
|
{
|
info = null;
|
|
En_Alarm_List eCode = (En_Alarm_List)Code;
|
|
if (Alarm_List.Count <= 0) return false;
|
|
if (Code < 0 || Alarm_List.Count < Code)
|
return false;
|
|
if (Alarm_List[eCode].Code == eCode)
|
{
|
info = Alarm_List[eCode];
|
return true;
|
}
|
else
|
{
|
foreach (Alarm ainfo in Alarm_List.Values)
|
{
|
if (ainfo.Code == eCode)
|
{
|
info = ainfo;
|
return true;
|
}
|
}
|
}
|
|
return false;
|
}
|
|
public SortedList<En_Alarm_List, Alarm> Clone()
|
{
|
SortedList<En_Alarm_List, Alarm> list = new SortedList<En_Alarm_List, Alarm>();
|
|
foreach(Alarm alarm in Alarm_List.Values)
|
{
|
Alarm data = alarm.Clone();
|
list.Add(data.Code, data);
|
}
|
|
return list;
|
}
|
|
public List<Alarm_Occurred> Clone_Occurred()
|
{
|
List<Alarm_Occurred> list = new List<Alarm_Occurred>();
|
list.Clear();
|
|
foreach (Alarm_Occurred alarm in Occured_List)
|
{
|
list.Add(alarm);
|
}
|
|
return list;
|
}
|
|
public void Occurred(En_Alarm_List list)
|
{
|
Alarm alarm = Alarm_List[list].Clone();
|
|
if(alarm.Use)
|
{
|
if(!Occured_List.Exists(x => x.Code == alarm.Code))
|
{
|
Write_Alarm_Log($"{alarm.Code.ToString()},{alarm.Description}");
|
if ((int)list < lst_alarm_memory.Count)
|
{
|
sm.Set_Bit(lst_alarm_memory[(int)list], true);
|
}
|
|
Occured_Alarm.Enqueue(new Alarm_Occurred(alarm));
|
Occured_List.Add(new Alarm_Occurred(alarm));
|
}
|
|
if(Occured_List.Exists(x => x.Heavy))
|
{
|
Alarm_Status = En_Alarm_Status.HEAVY;
|
}
|
else
|
{
|
Alarm_Status = En_Alarm_Status.LIGHT;
|
}
|
}
|
}
|
|
public void Alarm_Clear()
|
{
|
foreach(SharedmemoryAddressInfo sa in lst_alarm_memory)
|
{
|
sm.Set_Bit(sa, false);
|
}
|
|
Occured_List.Clear();
|
Alarm_Status = En_Alarm_Status.NONE;
|
}
|
|
public void Alarm_Clear(En_Alarm_List list)
|
{
|
if(Occured_List.Exists(x => x.Code == list))
|
{
|
foreach(Alarm_Occurred alarm in Occured_List)
|
{
|
if (alarm.Code == list)
|
{
|
Occured_List.Remove(alarm);
|
return;
|
}
|
}
|
}
|
}
|
|
public void Dispose()
|
{
|
IsDisposed = true;
|
sm.Close();
|
}
|
#endregion
|
}
|
}
|
