public CustomAlarmSetControl(AlarmConfig ac)
{
InitializeComponent();
groupBox1.Text = ac.Name;
AlarmConfig = ac;
Init();
}
private void Scheduler_TimeChanged(object sender, EventArgs e)
{
Scheduler s = sender as Scheduler;
foreach (var item in ConfigData.AlarmConfigRoot.AlarmConfigs)
{
if (s.Time >= item.Starttime && s.Time <= item.Endtime)
{
item.InTime = true;
}
else
{
item.InTime = false;
}
}
List <AlarmConfig> currentAlarms = ConfigData.AlarmConfigRoot.AlarmConfigs.FindAll(ala => ala.InDate && ala.InTime);
if (currentAlarms != null && currentAlarms.Count > 0)
{
CurrentAlarmCfg = currentAlarms[currentAlarms.Count - 1];
}
else
{
SetAlarmNull();
}
}
public void ConnectToServer(string ip, string port, string connectionstring)
{
IP = ip;
Port = port;
ConnectionString = connectionstring;
ProcessConnectionServer = Activator.GetObject(typeof(IProcessConnectionServer), "tcp://" + IP + ":" + Port + "/" + ConnectionString) as IProcessConnectionServer;
AlarmConfig.LoadAlarmsConfigFile();
AlarmEvents.ClearAlarmEvents();
}
public static bool UpdateAcknowladgeFromHigherLevelIfExist(AlarmConfig alarmConfiguration, string lowerAlarmLevelName, string higherAlarmLevelName)
{
try
{
alarmConfiguration.AlarmTerminalSet.First(s => s.AlarmLevelName == lowerAlarmLevelName).Acknowledged = alarmConfiguration.AlarmTerminalSet.First(s => s.AlarmLevelName == higherAlarmLevelName).Acknowledged;
return(true);
}
catch (Exception)
{
return(false);
}
}
private bool CheckIfDisabled(AlarmConfig timer)
{
var enabled = timer.Enable;
if (!enabled)
{
return(true);
}
this.Log(LogLevel.Warning, "Configuring {0} is allowed only when it is disabled", timer);
return(false);
}
private static bool AlarmExist(AlarmConfig alarmConfiguration, string alarmLevelName)
{
try
{
var alarm = alarmConfiguration.AlarmTerminalSet.First(s => s.AlarmLevelName == alarmLevelName);
return(alarm != null);
}
catch (Exception)
{
return(false);
}
}
public static bool RemoveAlarmIfExist(PowerMonitoringModelContainer context, AlarmConfig alarmConfiguration, string alarmLevelName)
{
try
{
var alarm = alarmConfiguration.AlarmTerminalSet.First(s => s.AlarmLevelName == alarmLevelName);
context.DeleteObject(alarm);
return(true);
}
catch (Exception)
{
return(false);
}
}
private void NewItem(AlarmConfig item)
{
ToolStripMenuItem tsmItem = new ToolStripMenuItem(item.Name);
tsmItem.Name = item.Name;
menuStrip1.Items.Insert(0, tsmItem);
CustomAlarmSetControl scg = new CustomAlarmSetControl(item);
scg.Parent = panel1;
scg.Dock = DockStyle.Fill;
tsmItem.Tag = scg;
tsmItem.Click += TsmItem_Click;
}
public void loadJSON()
{
config = null;
menu.DirectoryCheck();
//ファイルがない場合: 初期設定ファイルの生成
if (!File.Exists(jsonPath))
{
config = new AlarmConfig();
makeJSON();
}
//ファイルの読込を試行
try
{
//ファイルの内容を一括読み出し
string jsonString = File.ReadAllText(jsonPath, new UTF8Encoding(false));
//設定クラスをJSONデコードして生成
config = JsonUtility.FromJson <AlarmConfig>(jsonString);
//ファイルのバージョンが古い場合は、デフォルト設定にして警告(nullの可能性も考慮してtry内)
if (config.jsonVer != jsonVerMaster)
{
menu.ShowDialogOKCancel(LanguageManager.config.jsonloaders.OLD_CONFIG_HEAD, "" + jsonPath + LanguageManager.config.jsonloaders.OLD_CONFIG_BODY, 3f, () => {
//OK
makeJSON();
}, () => {
//キャンセル
});
config = new AlarmConfig();
}
}
catch (System.Exception e)
{
//JSONデコードに失敗した場合
Debug.Log(e.ToString());
config = null;
}
//デコード失敗した場合は、デフォルト設定にして警告
if (config == null)
{
config = new AlarmConfig();
menu.ShowDialogOKCancel(LanguageManager.config.jsonloaders.CORRUPT_CONFIG_HEAD, "" + jsonPath + LanguageManager.config.jsonloaders.CORRUPT_CONFIG_BODY, 3f, () => {
//OK
makeJSON();
}, () => {
//キャンセル
});
}
}
public static bool UpdateAlarmAndReturnIsActive(float currentValue, AlarmConfig alarmConfiguration, string alarmLevelName, double alarmConfigurationLevelChange, bool alarmConfigurationEnable, Usporedi delegateUsporedi, PowerMonitoringModelContainer context)
{
AlarmTerminal alarmTerminal;
try
{
alarmTerminal = alarmConfiguration.AlarmTerminalSet.First(s => s.AlarmLevelName == alarmLevelName);
}
catch (Exception)
{
alarmTerminal = null;
}
if (delegateUsporedi(currentValue, alarmConfigurationLevelChange) && alarmConfigurationEnable)
{
if (alarmTerminal == null)
{
alarmTerminal = AlarmTerminal.CreateAlarmTerminal(-1, true, false, alarmLevelName, currentValue, DateTime.Now, DateTime.Now, alarmConfigurationLevelChange, 1, -1);
alarmConfiguration.AlarmTerminalSet.Add(alarmTerminal);
}
else
{
alarmTerminal.Active = true;
if (delegateUsporedi(currentValue, alarmTerminal.MaxValue))
{
alarmTerminal.MaxValue = currentValue;
alarmTerminal.MaxValueTime = DateTime.Now;
}
}
}
else
{
if (alarmTerminal != null)
{
alarmTerminal.Active = false;
if (alarmTerminal.Acknowledged)
{
context.AlarmTerminalSet.DeleteObject(alarmTerminal);
}
}
}
return(alarmTerminal != null && alarmTerminal.Active);
}
/// <su
public string GetCommandString()
{
try
{
string str = "TABLE:IO_PARA#IO_ADDRESS:" + IO_ADDRESS;
str += "#IO_ALERT_ENABLE:" + IO_ALERT_ENABLE;
str += "#IO_COMM_ID:" + IO_COMM_ID;
str += "#IO_DATATYPE:" + IO_DATATYPE;
str += "#IO_DEVICE_ID:" + IO_DEVICE_ID;
str += "#IO_ENABLEALARM:" + IO_ENABLEALARM;
str += "#IO_ENABLERANGECONVERSION:" + IO_ENABLERANGECONVERSION;
str += "#IO_HISTORY:" + IO_HISTORY;
str += "#IO_ID:" + IO_ID;
str += "#IO_INITALVALUE:" + IO_INITALVALUE;
str += "#IO_LABEL:" + IO_LABEL;
str += "#IO_MAXVALUE:" + IO_MAXVALUE;
str += "#IO_MINVALUE:" + IO_MINVALUE;
str += "#IO_NAME:" + IO_NAME;
str += "#IO_ONE:" + IO_ONE;
str += "#IO_OUTLIES:" + IO_OUTLIES;
str += "#IO_PARASTRING:" + IO_PARASTRING.Replace("#", "//").Replace(":", "\\");
str += "#IO_POINTTYPE:" + IO_POINTTYPE;
str += "#IO_RANGEMAX:" + IO_RANGEMAX;
str += "#IO_RANGEMIN:" + IO_RANGEMIN;
str += "#IO_SERVER_ID:" + IO_SERVER_ID;
str += "#IO_SYSTEM:" + IO_SYSTEM;
str += "#IO_UNIT:" + IO_UNIT;
str += "#IO_ZERO:" + IO_ZERO;
str += "#IO_FORMULA:" + IO_FORMULA;
str += "#IO_DATASOURCE:" + this.IO_DATASOURCE;
//增加报警信息的配置
str += "#" + AlarmConfig.GetCommandString2();//把报警信息一并传过来
return(str);
}
catch
{
return("");
}
}
void SetAlarm(AlarmConfig ac)
{
foreach (var fd in ConfigData.allFields)
{
fd.Alarm = ac.AlarmField.Find(af => af.Name == fd.Name);
}
foreach (ToolStripMenuItem item in menuStrip1.Items)
{
if (InvokeRequired)
{
this.Invoke(new Action(() =>
{
if (item.Name == ac.Name)
{
item.BackColor = Color.BlueViolet;
item.ForeColor = Color.White;
TsmItem_Click(item, null);
}
else
{
item.BackColor = Color.Transparent;
item.ForeColor = Color.Black;
}
}));
}
else
{
if (item.Name == ac.Name)
{
item.BackColor = Color.BlueViolet;
item.ForeColor = Color.White;
TsmItem_Click(item, null);
}
else
{
item.BackColor = Color.Transparent;
item.ForeColor = Color.Black;
}
}
}
}
public List <AlarmConfig> GetConfigs()
{
List <AlarmConfig> list = new List <AlarmConfig>();
foreach (RadListBoxItem item in listBoxSelectedSites.Items)
{
AlarmConfig c = new AlarmConfig();
c.SiteId = item.Value;
c.PhoneNr = TextBoxPhoneNr.Text;
c.Note = TextBoxDescription.Text;
c.Ena = CheckBoxEnable.Checked;
c.Ena2 = CheckBoxEnableDelay.Checked;
c.Ena3 = CheckBoxEnableDiff.Checked;
c.Ena4 = CheckBoxEnablePress.Checked;
if (!string.IsNullOrEmpty(c.PhoneNr))
{
list.Add(c);
}
}
return(list);
}
private void 确定ToolStripMenuItem1_Click(object sender, EventArgs e)
{
string name = null;
if (!string.IsNullOrWhiteSpace(toolStripTextBox2.Text))
{
name = toolStripTextBox2.Text;
}
else
{
return;
}
AlarmConfig ac = new AlarmConfig();
ac.AlarmField = new List <AlarmField>();
ac.AllDate = true;
ac.AllTime = true;
ac.Name = name;
listAlarm.Add(ac);
NewItem(ac);
toolStripComboBox1.Items.Add(ac);
Utils.ToFile(ConfigurationManager.AppSettings["预警配置文件"], ConfigData.AlarmConfigRoot);
}
public void UpdateVariableSingle(string name, float currentValue, DateTime timeStamp)
{
if (_time == null)
{
_longTimer = DateTime.UtcNow.Second;
_time = new Timer(1000);
_time.Elapsed += TimeElapsed;
_time.AutoReset = true;
_time.Start();
}
ServiceVariable serviceVariable;
//ako postoji variabla pod imenom na servisu updejtaj vrijednost ako ne postoji kreiraj
try
{
serviceVariable = (from v in ServiceVariables
where v.VariableDto.VariableName == name
select v).First();
serviceVariable.VariableDto.CurrentValue = currentValue.ToString(CultureInfo.InvariantCulture);
}
catch (Exception)
{
var variableDto = new VariableDto
{
CurrentValue = currentValue.ToString(CultureInfo.InvariantCulture),
VariableName = name,
};
serviceVariable = new ServiceVariable(variableDto);
ServiceVariables.Add(serviceVariable);
}
using (var context = new PowerMonitoringModelContainer())
{
//ako ne postoji entity na sevicu pogledaj dali variajbla postoji u bazi ako ne postoji kreiraj
// provaj je naći u bazi pod imenom ako ne postoji kreiraj
Variable variableEnty;
try
{
variableEnty = (from v in context.VariableSet
where v.Name == name
select v).First();
}
catch (Exception)
{
variableEnty = Variable.CreateVariable(-1, name, _singleTypeString, true);
context.AddToVariableSet(variableEnty);
context.SaveChanges();
}
if (variableEnty == null)
{
return;
}
//logiranje
if (variableEnty.DataLoggingEnabled)
{
if (variableEnty.Type == _singleTypeString)
{
variableEnty.SingleLogSet.Add(SingleLog.CreateSingleLog(-1, currentValue, timeStamp, -1));
}
if (variableEnty.Type == _doubleTypeString)
{
variableEnty.DoubleLogSet.Add(DoubleLog.CreateDoubleLog(-1, currentValue, timeStamp, -1));
}
}
context.SaveChanges();
AlarmConfig alarmConfiguration = variableEnty.AlarmConfigSet;
if (alarmConfiguration == null)
{
return;
}
//High
if (AlarmTools.UpdateAlarmAndReturnIsActive(currentValue, alarmConfiguration, "HI", alarmConfiguration.HI_LevelChange, alarmConfiguration.HI_Enable, AlarmTools.UsporediHi, context) == false)
{
AlarmTools.RemoveLowerAlarmIfHigherLevelExist(context, alarmConfiguration, "HI", "HIHI");
}
else
{
AlarmTools.UpdateAcknowladgeFromHigherLevelIfExist(alarmConfiguration, "HI", "HIHI");
}
if (AlarmTools.UpdateAlarmAndReturnIsActive(currentValue, alarmConfiguration, "HIHI", alarmConfiguration.HIHI_LevelChange, alarmConfiguration.HIHI_Enable, AlarmTools.UsporediHi, context))
{
AlarmTools.RemoveAlarmIfExist(context, alarmConfiguration, "HI");
}
//Low
if (AlarmTools.UpdateAlarmAndReturnIsActive(currentValue, alarmConfiguration, "LO", alarmConfiguration.LO_LevelChange, alarmConfiguration.LO_Enable, AlarmTools.UsporediLo, context) == false)
{
AlarmTools.RemoveLowerAlarmIfHigherLevelExist(context, alarmConfiguration, "LO", "LOLO");
}
else
{
AlarmTools.UpdateAcknowladgeFromHigherLevelIfExist(alarmConfiguration, "LO", "LOLO");
}
if (AlarmTools.UpdateAlarmAndReturnIsActive(currentValue, alarmConfiguration, "LOLO", alarmConfiguration.LOLO_LevelChange, alarmConfiguration.LOLO_Enabled, AlarmTools.UsporediLo, context))
{
AlarmTools.RemoveAlarmIfExist(context, alarmConfiguration, "LO");
}
context.SaveChanges();
}
}
public static bool RemoveLowerAlarmIfHigherLevelExist(PowerMonitoringModelContainer context, AlarmConfig alarmConfiguration, string lowerAlarmLevelName, string higherAlarmLevelName)
{
return(AlarmExist(alarmConfiguration, higherAlarmLevelName) && RemoveAlarmIfExist(context, alarmConfiguration, lowerAlarmLevelName));
}
UpdateAlarmConfigAsync(AlarmConfig data) => await UpdateDataAsync("alarm/config", data);
public STM32F4_RTC(Machine machine)
{
mainTimer = new TimerConfig(this);
alarmA = new AlarmConfig(this, mainTimer);
alarmB = new AlarmConfig(this, mainTimer);
AlarmIRQ = new GPIO();
ticker = new LimitTimer(machine.ClockSource, 1, this, nameof(ticker), 1, direction: Direction.Ascending, eventEnabled: true);
ticker.LimitReached += UpdateState;
ResetInnerTimers();
IFlagRegisterField syncFlag = null;
var registerMap = new Dictionary <long, DoubleWordRegister>
{
{ (long)Registers.TimeRegister, new DoubleWordRegister(this)
.WithValueField(0, 4, name: "SU",
writeCallback: (_, value) => UpdateMainTimer(Registers.TimeRegister, DateTimeSelect.Second, Rank.Units, value),
valueProviderCallback: _ => mainTimer.Read(DateTimeSelect.Second, Rank.Units))
.WithValueField(4, 3, name: "ST",
writeCallback: (_, value) => UpdateMainTimer(Registers.TimeRegister, DateTimeSelect.Second, Rank.Tens, value),
valueProviderCallback: _ => mainTimer.Read(DateTimeSelect.Second, Rank.Tens))
.WithReservedBits(7, 1)
.WithValueField(8, 4, name: "MU",
writeCallback: (_, value) => UpdateMainTimer(Registers.TimeRegister, DateTimeSelect.Minute, Rank.Units, value),
valueProviderCallback: _ => mainTimer.Read(DateTimeSelect.Minute, Rank.Units))
.WithValueField(12, 3, name: "MT",
writeCallback: (_, value) => UpdateMainTimer(Registers.TimeRegister, DateTimeSelect.Minute, Rank.Tens, value),
valueProviderCallback: _ => mainTimer.Read(DateTimeSelect.Minute, Rank.Tens))
.WithReservedBits(15, 1)
.WithValueField(16, 4, name: "HU",
writeCallback: (_, value) => UpdateMainTimer(Registers.TimeRegister, DateTimeSelect.Hour, Rank.Units, value),
valueProviderCallback: _ => mainTimer.Read(DateTimeSelect.Hour, Rank.Units))
.WithValueField(20, 2, name: "HT",
writeCallback: (_, value) => UpdateMainTimer(Registers.TimeRegister, DateTimeSelect.Hour, Rank.Tens, value),
valueProviderCallback: _ => mainTimer.Read(DateTimeSelect.Hour, Rank.Tens))
.WithFlag(22, name: "PM",
writeCallback: (_, value) =>
{
if (CheckIfInInitMode(Registers.TimeRegister) && CheckIfUnlocked(Registers.TimeRegister))
{
mainTimer.PM = value;
}
},
valueProviderCallback: _ => mainTimer.PM)
.WithReservedBits(23, 9) },
{ (long)Registers.DateRegister, new DoubleWordRegister(this, 0x2101)
.WithValueField(0, 4, name: "DU",
writeCallback: (_, value) => UpdateMainTimer(Registers.DateRegister, DateTimeSelect.Day, Rank.Units, value),
valueProviderCallback: _ => mainTimer.Read(DateTimeSelect.Day, Rank.Units))
.WithValueField(4, 2, name: "DT",
writeCallback: (_, value) => UpdateMainTimer(Registers.DateRegister, DateTimeSelect.Day, Rank.Tens, value),
valueProviderCallback: _ => mainTimer.Read(DateTimeSelect.Day, Rank.Tens))
.WithReservedBits(6, 2)
.WithValueField(8, 4, name: "MU",
writeCallback: (_, value) => UpdateMainTimer(Registers.DateRegister, DateTimeSelect.Month, Rank.Units, value),
valueProviderCallback: _ => mainTimer.Read(DateTimeSelect.Month, Rank.Units))
.WithValueField(12, 1, name: "MT",
writeCallback: (_, value) => UpdateMainTimer(Registers.DateRegister, DateTimeSelect.Month, Rank.Tens, value),
valueProviderCallback: _ => mainTimer.Read(DateTimeSelect.Month, Rank.Tens))
.WithValueField(13, 3, name: "WDU",
writeCallback: (_, value) =>
{
if (CheckIfInInitMode(Registers.DateRegister) && CheckIfUnlocked(Registers.DateRegister))
{
if (value == 0)
{
this.Log(LogLevel.Warning, "Writting value 0 to WeekDay register is forbidden");
return;
}
mainTimer.WeekDay = (DayOfTheWeek)value;
}
},
valueProviderCallback: _ => (uint)mainTimer.WeekDay)
.WithValueField(16, 4, name: "YU",
writeCallback: (_, value) => UpdateMainTimer(Registers.DateRegister, DateTimeSelect.Year, Rank.Units, value),
valueProviderCallback: _ => mainTimer.Read(DateTimeSelect.Year, Rank.Units))
.WithValueField(20, 4, name: "YT",
writeCallback: (_, value) => UpdateMainTimer(Registers.DateRegister, DateTimeSelect.Year, Rank.Tens, value),
valueProviderCallback: _ => mainTimer.Read(DateTimeSelect.Year, Rank.Tens))
.WithReservedBits(24, 8) },
{ (long)Registers.ControlRegister, new DoubleWordRegister(this)
.WithTag("WUCKSEL", 0, 3)
.WithTag("TSEDGE", 3, 1)
.WithTag("REFCKON", 4, 1)
.WithTag("BYPSHAD", 5, 1)
.WithFlag(6, name: "FMT",
writeCallback: (_, value) =>
{
if (CheckIfUnlocked(Registers.ControlRegister))
{
AMPMFormat = value;
mainTimer.ConfigureAMPM();
alarmA.ConfigureAMPM();
alarmB.ConfigureAMPM();
}
},
valueProviderCallback: _ => AMPMFormat)
.WithTag("DCE", 7, 1)
.WithFlag(8, name: "ALRAE",
writeCallback: (_, value) =>
{
if (CheckIfUnlocked(Registers.ControlRegister))
{
alarmA.Enable = value;
}
},
valueProviderCallback: _ => alarmA.Enable)
.WithFlag(9, name: "ALRBE",
writeCallback: (_, value) =>
{
if (CheckIfUnlocked(Registers.ControlRegister))
{
alarmB.Enable = value;
}
},
valueProviderCallback: _ => alarmB.Enable)
.WithTag("WUTE", 10, 1) // Wakeup Timer not supported
.WithTag("TSE", 11, 1) // Timestamp not supported
.WithFlag(12, name: "ALRAIE",
writeCallback: (_, value) =>
{
if (CheckIfUnlocked(Registers.ControlRegister))
{
alarmA.InterruptEnable = value;
}
},
valueProviderCallback: _ => alarmA.InterruptEnable)
.WithFlag(13, name: "ALRBIE",
writeCallback: (_, value) =>
{
if (CheckIfUnlocked(Registers.ControlRegister) && value)
{
alarmB.InterruptEnable = value;
}
},
valueProviderCallback: _ => alarmB.InterruptEnable)
.WithTag("WUTIE", 14, 1) // Wakeup Timer not supported
.WithTag("TSIE", 15, 1) // Timestamp not supported
.WithTag("ADD1H", 16, 1)
.WithTag("SUB1H", 17, 1)
.WithTag("BKP", 18, 1)
.WithTag("COSEL", 19, 1)
.WithTag("POL", 20, 1)
.WithTag("OSEL", 21, 2)
.WithTag("COE", 23, 1)
.WithReservedBits(24, 8) },
{ (long)Registers.ISR, new DoubleWordRegister(this, 0x7)
.WithFlag(0, FieldMode.Read, valueProviderCallback: _ => !alarmA.Enable, name: "ALRAWF")
.WithFlag(1, FieldMode.Read, valueProviderCallback: _ => !alarmB.Enable, name: "ALRBWF")
.WithTag("WUTWF", 2, 1)
.WithTag("SHPF", 3, 1)
.WithFlag(4, FieldMode.Read, valueProviderCallback: _ => mainTimer.TimeState.Year != 2000, name: "INITS")
.WithFlag(5, out syncFlag, FieldMode.Read | FieldMode.WriteZeroToClear, name: "RSF",
readCallback: (_, curr) =>
{
// this strange logic is required by the Zephyr driver;
// it wants to read 0 before reading 1, otherwise it times-out
if (!curr)
{
syncFlag.Value = true;
}
})
.WithFlag(6, FieldMode.Read, valueProviderCallback: _ => initMode, name: "INITF")
.WithFlag(7, FieldMode.Write, name: "INIT",
writeCallback: (_, value) =>
{
if (CheckIfUnlocked(Registers.ISR))
{
ticker.Enabled = !value;
initMode = value;
}
})
.WithFlag(8, FieldMode.WriteZeroToClear | FieldMode.Read, name: "ALRAF",
changeCallback: (_, __) =>
{
alarmA.Flag = false;
},
valueProviderCallback: _ => alarmA.Flag)
.WithFlag(9, FieldMode.WriteZeroToClear | FieldMode.Read, name: "ALRBF",
changeCallback: (_, __) =>
{
alarmB.Flag = false;
},
valueProviderCallback: _ => alarmB.Flag)
.WithTag("WUTF", 10, 1)
.WithTag("TSF", 11, 1)
.WithTag("TSOVF", 12, 1)
.WithTag("TAMP1F", 13, 1)
.WithTag("TAMP2F", 14, 1)
.WithReservedBits(15, 1)
.WithTag("RECALPF", 16, 1)
.WithReservedBits(17, 15) },
{ (long)Registers.PrescalerRegister, new DoubleWordRegister(this)
.WithTag("PREDIV_S", 0, 15)
.WithReservedBits(15, 1)
.WithTag("PREDIV_A", 16, 7)
.WithReservedBits(23, 9) },
{ (long)Registers.WakeupTimerRegister, new DoubleWordRegister(this, 0x7F00FF)
.WithTag("WUT", 0, 16)
.WithReservedBits(16, 16) },
{ (long)Registers.CalibrationRegister, new DoubleWordRegister(this)
.WithTag("DC", 0, 5)
.WithReservedBits(5, 2)
.WithTag("DCS", 7, 1)
.WithReservedBits(8, 24) },
{ (long)Registers.AlarmARegister, new DoubleWordRegister(this)
.WithValueField(0, 4, name: "SU",
writeCallback: (_, value) => UpdateTimerA(DateTimeSelect.Second, Rank.Units, value),
valueProviderCallback: _ => alarmA.Read(DateTimeSelect.Second, Rank.Units))
.WithValueField(4, 3, name: "ST",
writeCallback: (_, value) => UpdateTimerA(DateTimeSelect.Second, Rank.Tens, value),
valueProviderCallback: _ => alarmA.Read(DateTimeSelect.Second, Rank.Tens))
.WithFlag(7, name: "MSK1",
writeCallback: (_, value) =>
{
if (CheckIfDisabled(alarmA) && CheckIfUnlocked(Registers.AlarmARegister))
{
alarmA.SecondsMask = value;
}
},
valueProviderCallback: _ => alarmA.SecondsMask)
.WithValueField(8, 4, name: "MU",
writeCallback: (_, value) => UpdateTimerA(DateTimeSelect.Minute, Rank.Units, value),
valueProviderCallback: _ => alarmA.Read(DateTimeSelect.Minute, Rank.Units))
.WithValueField(12, 3, name: "MT",
writeCallback: (_, value) => UpdateTimerA(DateTimeSelect.Minute, Rank.Tens, value),
valueProviderCallback: _ => alarmA.Read(DateTimeSelect.Minute, Rank.Tens))
.WithFlag(15, name: "MSK2",
writeCallback: (_, value) =>
{
if (CheckIfDisabled(alarmA) && CheckIfUnlocked(Registers.AlarmARegister))
{
alarmA.MinutesMask = value;
}
}, valueProviderCallback: _ => alarmA.MinutesMask)
.WithValueField(16, 4, name: "HU",
writeCallback: (_, value) => UpdateTimerA(DateTimeSelect.Hour, Rank.Units, value),
valueProviderCallback: _ => alarmA.Read(DateTimeSelect.Hour, Rank.Units))
.WithValueField(20, 2, name: "HT",
writeCallback: (_, value) => UpdateTimerA(DateTimeSelect.Hour, Rank.Tens, value),
valueProviderCallback: _ => alarmA.Read(DateTimeSelect.Hour, Rank.Tens))
.WithFlag(22, name: "PM",
writeCallback: (_, value) =>
{
if (CheckIfDisabled(alarmA) && CheckIfUnlocked(Registers.AlarmARegister))
{
alarmA.PM = value;
}
},
valueProviderCallback: _ => alarmA.PM)
.WithFlag(23, name: "MSK3",
writeCallback: (_, value) =>
{
if (CheckIfDisabled(alarmA) && CheckIfUnlocked(Registers.AlarmARegister))
{
alarmA.HoursMask = value;
}
}, valueProviderCallback: _ => alarmA.HoursMask)
.WithValueField(24, 4, name: "DU",
writeCallback: (_, value) => UpdateTimerA(DateTimeSelect.Day, Rank.Units, value),
valueProviderCallback: _ => alarmA.Read(DateTimeSelect.Day, Rank.Units))
.WithValueField(28, 2, name: "DT",
writeCallback: (_, value) => UpdateTimerA(DateTimeSelect.Day, Rank.Tens, value),
valueProviderCallback: _ => alarmA.Read(DateTimeSelect.Day, Rank.Tens))
.WithTag("WDSEL", 30, 1) // Weekday instead of date units usupported
.WithFlag(31, name: "MSK4",
writeCallback: (_, value) =>
{
if (CheckIfDisabled(alarmA) && CheckIfUnlocked(Registers.AlarmARegister))
{
alarmA.DaysMask = value;
}
},
valueProviderCallback: _ => alarmA.DaysMask) },
{ (long)Registers.AlarmBRegister, new DoubleWordRegister(this)
.WithValueField(0, 4, name: "SU",
writeCallback: (_, value) => UpdateTimerB(DateTimeSelect.Second, Rank.Units, value),
valueProviderCallback: _ => alarmB.Read(DateTimeSelect.Second, Rank.Units))
.WithValueField(4, 3, name: "ST",
writeCallback: (_, value) => UpdateTimerB(DateTimeSelect.Second, Rank.Tens, value),
valueProviderCallback: _ => alarmB.Read(DateTimeSelect.Second, Rank.Tens))
.WithFlag(7, name: "MSK1",
writeCallback: (_, value) =>
{
if (CheckIfDisabled(alarmB) && CheckIfUnlocked(Registers.AlarmBRegister))
{
alarmB.SecondsMask = value;
}
},
valueProviderCallback: _ => alarmB.SecondsMask)
.WithValueField(8, 4, name: "MU",
writeCallback: (_, value) => UpdateTimerB(DateTimeSelect.Minute, Rank.Units, value),
valueProviderCallback: _ => alarmB.Read(DateTimeSelect.Minute, Rank.Units))
.WithValueField(12, 3, name: "MT",
writeCallback: (_, value) => UpdateTimerB(DateTimeSelect.Minute, Rank.Tens, value),
valueProviderCallback: _ => alarmB.Read(DateTimeSelect.Minute, Rank.Tens))
.WithFlag(15, name: "MSK2",
writeCallback: (_, value) =>
{
if (CheckIfDisabled(alarmB) && CheckIfUnlocked(Registers.AlarmBRegister))
{
alarmB.MinutesMask = value;
}
},
valueProviderCallback: _ => alarmB.MinutesMask)
.WithValueField(16, 4, name: "HU",
writeCallback: (_, value) => UpdateTimerB(DateTimeSelect.Hour, Rank.Units, value),
valueProviderCallback: _ => alarmB.Read(DateTimeSelect.Hour, Rank.Units))
.WithValueField(20, 2, name: "HT",
writeCallback: (_, value) => UpdateTimerB(DateTimeSelect.Hour, Rank.Tens, value),
valueProviderCallback: _ => alarmB.Read(DateTimeSelect.Hour, Rank.Tens))
.WithFlag(22, name: "PM",
writeCallback: (_, value) =>
{
if (CheckIfDisabled(alarmB) && CheckIfUnlocked(Registers.AlarmBRegister))
{
alarmB.PM = value;
}
},
valueProviderCallback: _ => alarmB.PM)
.WithFlag(23, name: "MSK3",
writeCallback: (_, value) =>
{
if (CheckIfDisabled(alarmB) && CheckIfUnlocked(Registers.AlarmBRegister))
{
alarmB.HoursMask = value;
}
},
valueProviderCallback: _ => alarmB.HoursMask)
.WithValueField(24, 4, name: "DU",
writeCallback: (_, value) => UpdateTimerB(DateTimeSelect.Day, Rank.Units, value),
valueProviderCallback: _ => alarmB.Read(DateTimeSelect.Day, Rank.Units))
.WithValueField(28, 2, name: "DT",
writeCallback: (_, value) => UpdateTimerB(DateTimeSelect.Day, Rank.Tens, value),
valueProviderCallback: _ => alarmB.Read(DateTimeSelect.Day, Rank.Tens))
.WithTag("WDSEL", 30, 1) // Weekday instead of date units usupported
.WithFlag(31, name: "MSK4",
writeCallback: (_, value) =>
{
if (CheckIfDisabled(alarmB) && CheckIfUnlocked(Registers.AlarmBRegister))
{
alarmB.DaysMask = value;
}
},
valueProviderCallback: _ => alarmB.DaysMask) },
{ (long)Registers.WriteProtectionRegister, new DoubleWordRegister(this)
.WithValueField(0, 8, name: "KEY",
writeCallback: (_, value) =>
{
if (value == UnlockKey1 && !firstStageUnlocked)
{
firstStageUnlocked = true;
}
else if (value == UnlockKey2 && firstStageUnlocked)
{
registersUnlocked = true;
}
else
{
firstStageUnlocked = false;
registersUnlocked = false;
}
},
valueProviderCallback: _ => 0)
.WithReservedBits(8, 24) },
{ (long)Registers.SubSecondRegister, new DoubleWordRegister(this)
.WithTag("SS", 0, 16)
.WithReservedBits(16, 16) },
{ (long)Registers.ShiftControlRegister, new DoubleWordRegister(this)
.WithTag("SUBFS", 0, 15)
.WithReservedBits(15, 16)
.WithTag("ADD1S", 31, 1) },
{ (long)Registers.TimestampTimeRegister, new DoubleWordRegister(this)
.WithTag("Second", 0, 7)
.WithReservedBits(7, 1)
.WithTag("Minute", 8, 7)
.WithReservedBits(15, 1)
.WithTag("Hour", 16, 6)
.WithTag("PM", 22, 1)
.WithReservedBits(23, 9) },
{ (long)Registers.TimestampDateRegister, new DoubleWordRegister(this)
.WithTag("Day", 0, 6)
.WithReservedBits(6, 2)
.WithTag("Month", 8, 5)
.WithTag("WDU", 13, 3)
.WithReservedBits(16, 16) },
{ (long)Registers.TimestampSubSecondRegister, new DoubleWordRegister(this)
.WithTag("SS", 0, 16)
.WithReservedBits(16, 16) },
{ (long)Registers.ClockCalibrationRegister, new DoubleWordRegister(this)
.WithTag("CALM", 0, 9)
.WithReservedBits(9, 4)
.WithTag("CALW16", 13, 1)
.WithTag("CALW8", 14, 1)
.WithTag("CALP", 15, 1)
.WithReservedBits(16, 16) },
{ (long)Registers.TamperAndAlternateFunctionConfigurationRegister, new DoubleWordRegister(this)
.WithTag("TAMP1E", 0, 1)
.WithTag("TAMP1TRG", 1, 1)
.WithTag("TAMPIE", 2, 1)
.WithTag("TAMP2E", 3, 1)
.WithTag("TAMP2TRG", 4, 1)
.WithReservedBits(5, 2)
.WithTag("TAMPTS", 7, 1)
.WithTag("TAMPFREQ", 8, 3)
.WithTag("TAMPFLT", 11, 2)
.WithTag("TAMPPRCH", 13, 2)
.WithTag("TAMPPUDIS", 15, 1)
.WithTag("TAMP1INSEL", 16, 1)
.WithTag("TSINSEL", 17, 1)
.WithTag("ALARMOUTTYPE", 18, 1)
.WithReservedBits(19, 13) },
{ (long)Registers.AlarmASubSecondRegister, new DoubleWordRegister(this)
.WithTag("SS", 0, 15)
.WithReservedBits(15, 9)
.WithTag("MASKSS", 24, 4)
.WithReservedBits(28, 4) },
{ (long)Registers.AlarmBSubSecondRegister, new DoubleWordRegister(this)
.WithTag("SS", 0, 15)
.WithReservedBits(15, 9)
.WithTag("MASKSS", 24, 4)
.WithReservedBits(28, 4) },
};
registers = new DoubleWordRegisterCollection(this, registerMap);
}
