/// <summary>
/// Установка значений в поля размер считывания и начальный адрес
/// </summary>
private void SetValues()
{
if (_HexAddressCoding)
{
if (this._Address == 0)
{
this.tbStartAddress.Text = "0x00";
}
else
{
this.tbStartAddress.Text = "0x" + AppliedMath.DecToHex(this._Address);
}
}
else
{
this.tbStartAddress.Text = "" + this._Address;
}
if (_HexSizeCoding)
{
this.tbReadingSize.Text = "0x" + AppliedMath.DecToHex(this._Size);
}
else
{
this.tbReadingSize.Text = "" + this._Size;
}
}
/// <summary>
/// Формирование значения переменной для отображения
/// </summary>
/// <param name="address"></param>
/// <returns></returns>
private string BuildDisplayValue(byte[] buffer, int size, bool hasSign)
{
if (buffer == null || size == 0)
{
return("Ошибка");
}
byte[] Buffer = buffer;
long Value = 0;
if (_engine.Parameters.InverseByteOrder)
{
Array.Reverse(Buffer);
}
Value = AppliedMath.BytesToLong(Buffer);
//Определение типа переменной
if (hasSign)
{
switch (size)
{
case 1: Value = (sbyte)Value; break;
case 2: Value = (Int16)Value; break;
case 4: Value = (Int32)Value; break;
}
}
else
{
switch (size)
{
case 1: Value = (Byte)Value; break;
case 2: Value = (UInt16)Value; break;
case 4: Value = (UInt32)Value; break;
}
}
//Формирвание прочитанного значения
String m_StrVar = this._EditCellText;
switch (codingType)
{
case 16:
String m_Str = Convert.ToString(Value, codingType);
if (m_Str.Length > size * 2)
{
int m_CutIndex = m_Str.Length - size * 2;
m_Str = m_Str.Substring(m_CutIndex);
}
m_Str = "0x" + Utils.AddChars('0', m_Str, 8 /*(int)m_row.ItemArray[4] * 2*/);
m_StrVar = m_Str.ToUpper();
break;
default:
m_StrVar = Convert.ToString(Value, codingType).ToUpper();
break;
}
return(m_StrVar.Replace('X', 'x'));
}
/// <summary>
/// Возвращает масив байт который обрузует блок из 4 переменных
/// </summary>
/// <param name="Vars">Список всех переменных, которые попадают в заданый блок</param>
/// <param name="VarSize">Размер переменной, относительно который вычисляется блок</param>
private int[] CreateVarBytesArray(List <ControllerEmbeddedVar> Vars, int VarSize, bool InverseByteOrder)
{
int[] res = new int[4];
switch (VarSize)
{
case 1:
res[0] = (int)Vars[0].Value;
res[1] = (int)Vars[3].Value;
res[2] = (int)Vars[4].Value;
res[3] = (int)Vars[6].Value;
break;
case 2:
res[0] = !InverseByteOrder?AppliedMath.Hi((int)Vars[1].Value) : AppliedMath.Low((int)Vars[1].Value);
res[1] = !InverseByteOrder?AppliedMath.Low((int)Vars[1].Value) : AppliedMath.Hi((int)Vars[1].Value);
res[2] = !InverseByteOrder?AppliedMath.Hi((int)Vars[5].Value) : AppliedMath.Low((int)Vars[5].Value);
res[3] = !InverseByteOrder?AppliedMath.Low((int)Vars[5].Value) : AppliedMath.Hi((int)Vars[5].Value);
break;
case 4:
byte[] tmp = InverseByteOrder ? Utils.ReflectArray(AppliedMath.IntToBytes((int)Vars[2].Value)) : AppliedMath.IntToBytes((int)Vars[2].Value);
for (int i = 0; i < 4; i++)
{
res[i] = tmp[i];
}
break;
}
return(res);
}
/// <summary>
/// Событие при потере фокуса полем "Начальный адрес"
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void StartAddress_Leave(object sender, EventArgs e)
{
try
{
if (this.tbStartAddress.Text[0] == '0' && this.tbStartAddress.Text[1] == 'x')
{
_Address = AppliedMath.HexToDec(this.tbStartAddress.Text);
_HexAddressCoding = true;
}
else
{
_Address = int.Parse(this.tbStartAddress.Text);
_HexAddressCoding = false;
}
}
catch
{
SetValues();
return;
}
if (this._Address == 0 && this.ddlMemoryType.Text == "SD Card")
{
this._Address = 1;
}
if (this._Address >= MaxMemoryValue())
{
this._Address = MaxMemoryValue() - 1;
}
if (this._Size + this._Address > MaxMemoryValue())
{
this._Size = MaxMemoryValue() - this._Address;
}
_engine.Parameters.ViewMemoryAddress = _Address;
this.SetValues();
}
/// <summary>
/// Устанавливает новые значения переменных заводских установок при изменении значения какой либо одной
/// </summary>
public void SetEmbeddedVarValue(string VarName, long value, bool InverseByteOrder)
{
ControllerEmbeddedVar WorkingVar = this.GetVarByName(VarName);
if (WorkingVar == null)
{
return;
}
WorkingVar.Value = value;
List <ControllerEmbeddedVar> vars = this.GetAllAssignedEmbeddedVars(VarName);
int[] ibytes = this.CreateVarBytesArray(vars, WorkingVar.Size, InverseByteOrder);
byte[] bytes = { (byte)ibytes[0], (byte)ibytes[1], (byte)ibytes[2], (byte)ibytes[3] };
// Установка значений однобайтных переменных
vars[0].Value = ibytes[0];
vars[3].Value = ibytes[1];
vars[4].Value = ibytes[2];
vars[6].Value = ibytes[3];
// Установка значений двухбайтных переменных
if (WorkingVar != vars[1])
{
vars[1].Value = AppliedMath.BytesToInt(InverseByteOrder ? Utils.ReflectArray <byte>(Utils.GetSubArray <byte>(bytes, 0, 2)) : Utils.GetSubArray <byte>(bytes, 0, 2));
}
if (WorkingVar != vars[5])
{
vars[5].Value = AppliedMath.BytesToInt(InverseByteOrder ? Utils.ReflectArray <byte>(Utils.GetSubArray <byte>(bytes, 2)) : Utils.GetSubArray <byte>(bytes, 2));
}
// Установка значений четырехбайтной переменной
if (WorkingVar != vars[2])
{
vars[2].Value = (uint)AppliedMath.BytesToInt(InverseByteOrder ? Utils.ReflectArray <byte>(bytes) : bytes);
}
}
/// <summary>
/// Вычисление массива data по значению датчика
/// </summary>
private void ComputeData()
{
byte[] b = new byte[2];
b = AppliedMath.IntToBytes((int)this.nudValue.Value);
switch (data.Length)
{
case 1:
this.data[0] = b[3];
break;
case 2:
if (this.singleByte)
{
this.data[0] = b[3];
this.data[1] = 0;
}
else
{
b = AppliedMath.IntToBytes((int)(this.nudValue.Value));
this.data[0] = b[2];
this.data[1] = b[3];
//this.data[0] = b[3];
//this.data[1] = b[2];
}
break;
}
if (this.InverseByteOrder)
{
Array.Reverse(this.data);
}
}
/// <summary>
/// Выполняет инициализацию полей класса
/// </summary>
/// <param name="ModuleNumber">Физический номер модуля</param>
protected void Init(int ModuleNumber)
{
this.ModuleNumber = ModuleNumber;
this.GenerateVarsNames(this.ModuleNumber);
this.Req10msDefinition = "0x" + Utils.AddChars('0', AppliedMath.DecToHex(this.ModuleNumber), 4);
foreach (ModuleVarDescription VarDescription in this.VarNames)
{
this.Req10msDefinition += ", (unsigned int)&" + VarDescription.DisplayName;
}
this.Req10msDefinition += ", (unsigned int)&E" + this.VarNames[0].DisplayName;
}
/// <summary>
/// Для заданной переменной преобразует ее значение из массива байт в целое число
/// </summary>
private long GetVarValue(DebuggerParameters.VarDescription var, byte[] data)
{
if (this.debuggerEngine.Parameters.InverseByteOrder)
{
data = Utils.ReflectArray <byte>(data);
}
long res = AppliedMath.BytesToLong(data);
switch (var.Size)
{
case 1:
if (var.HasSign)
{
res = (sbyte)res;
}
else
{
res = (byte)res;
}
break;
case 2:
if (var.HasSign)
{
res = (short)res;
}
else
{
res = (ushort)res;
}
break;
case 4:
if (var.HasSign)
{
res = (int)res;
}
else
{
res = (uint)res;
}
break;
}
return(res);
}
/// <summary>
/// Событие при смене типа памяти
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void MemoryType_SelectedValueChanged(object sender, EventArgs e)
{
_Address = AppliedMath.HexToDec(this.tbStartAddress.Text);
if (this._Address == 0 && this.ddlMemoryType.Text == "SD Card")
{
this._Address = 1;
}
if (this._Address >= MaxMemoryValue())
{
this._Address = MaxMemoryValue() - 1;
}
if (this._Size + this._Address > MaxMemoryValue())
{
this._Size = MaxMemoryValue() - this._Address;
}
this.SetValues();
_engine.Parameters.ViewMemoryType = GetMemoryType(this.ddlMemoryType.Text);
}
/// <summary>
/// Читает размер буффера с контроллера на базе процессора MB90F347
/// </summary>
/// <param name="port">Порт, через который осуществляется чтение; должен быть уже открыт</param>
private int ReadMB90F347BufferSize(Relkon37SerialPort port)
{
byte[] addresses = { 340, 344 };
int res = int.MaxValue;
for (int i = 0; i < 2; i++)
{
byte[] response = port.ReadEEPROM(addresses[i], 2);
if (this.Parameters.InverseByteOrder)
{
Array.Reverse(response);
}
int SRX = AppliedMath.BytesToInt(response);
response = port.ReadEEPROM(addresses[i] + 4, 2);
if (this.InverseByteOrder)
{
Array.Reverse(response);
}
NRX = AppliedMath.BytesToInt(response);
res = Math.Min(res, NRX - SRX + 1);
}
return(res);
}
/// <summary>
/// Событие при потере фокуса полем "Размер считывания"
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void ReadingSize_Leave(object sender, EventArgs e)
{
try
{
if (this.tbReadingSize.Text[0] == '0' && this.tbReadingSize.Text[1] == 'x')
{
this._Size = AppliedMath.HexToDec(this.tbReadingSize.Text);
_HexSizeCoding = true;
}
else
{
_Size = int.Parse(this.tbReadingSize.Text);
_HexSizeCoding = false;
}
}
catch
{
SetValues();
return;
}
if (this._Size == 0)
{
this._Size = 1;
}
int m_size = 32767 / this.heMemory.SymbolHeight * this.heMemory.SegmentSize;
if (this._Size > m_size)
{
this._Size = m_size;
}
if (this._Size + _Address > MaxMemoryValue())
{
this._Size = MaxMemoryValue() - this._Address;
}
_engine.Parameters.ReadingSize = _Size;
this.SetValues();
}
/// <summary>
/// По массиву data вычисляет значение датчика
/// </summary>
private int ComputeValue()
{
byte[] b = this.InverseByteOrder ? Utils.ReflectArray <byte>(this.data) : this.data;
return(this.SigleByte ? b[0] : AppliedMath.BytesToInt(b));
}
/// <summary>
/// Событие при оканчании редактирования значения переменной
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void dgVars_CellEndEdit(object sender, DataGridViewCellEventArgs e)
{
try
{
//Определение правильности введенного значения
bool m_error = false;
//Определение изменяемой переменной
Kontel.Relkon.Classes.ControllerVar m_newVar = _solution.Vars.GetVarByName((String)this.dgVars[0, e.RowIndex].Value);
DataRow m_CurrentRow = (DataRow)this.Table.Rows[this.dgVars.CurrentRow.Index];
for (int i = 0; i < this.Table.Rows.Count; i++)
{
if ((String)this.Table.Rows[i][0] == this._EditVar)
{
m_CurrentRow = (DataRow)this.Table.Rows[i];
break;
}
}
//Определения правльности входных данных. Формирование массива для записи
Byte[] m_Vars = new Byte[4];
Byte[] m_WriteVars = new Byte[m_newVar.Size];
int m_SignValue = 0;
if (m_newVar is ControllerUserVar && ((ControllerUserVar)m_newVar).Array)
{
String m_ArrayVar = (String)this.dgVars[e.ColumnIndex, e.RowIndex].Value;
String m_CurrentVar = "";
for (int i = 0; i < m_newVar.Size; i++)
{
if (m_ArrayVar.IndexOf(' ') > 0)
{
m_CurrentVar = m_ArrayVar.Substring(0, m_ArrayVar.IndexOf(' '));
m_ArrayVar = m_ArrayVar.Substring(m_ArrayVar.IndexOf(' ') + 1);
}
else
{
m_CurrentVar = m_ArrayVar;
m_ArrayVar = "";
}
if (this.codingType == 16)
{
try { if (!((Convert.ToInt64(Convert.ToByte(AppliedMath.HexToDec(m_CurrentVar))) <= long.Parse(m_CurrentRow[2].ToString())) && ((Convert.ToInt64(Convert.ToByte(AppliedMath.HexToDec(m_CurrentVar)))) >= long.Parse(m_CurrentRow[3].ToString()))))
{
m_error = true;
}
}
catch { m_error = true; }
if ((AppliedMath.IsValidHexNumber(m_CurrentVar)) && (!m_error))
{
m_WriteVars[i] = Convert.ToByte(AppliedMath.HexToDec(m_CurrentVar));
}
else
{
m_error = true; break;
}
}
else
{
if ((AppliedMath.IsValidDecNumber(m_CurrentVar)) && ((Convert.ToInt64(m_CurrentVar) <= long.Parse(m_CurrentRow[2].ToString())) && (Convert.ToInt64(m_CurrentVar) >= long.Parse(m_CurrentRow[3].ToString()))))
{
m_WriteVars[i] = Convert.ToByte(m_CurrentVar);
}
else
{
m_error = true; break;
}
}
if ((m_ArrayVar.Trim() == "") && (i < m_newVar.Size - 1))
{
m_error = true;
break;
}
}
}
else
{
String m_CurrentValue = "";
if (this.codingType == 10)
{
m_CurrentValue = (String)(this.dgVars[e.ColumnIndex, e.RowIndex].Value);
}
else
{
if (m_newVar.Size == 4)
{
m_CurrentValue = Convert.ToString((UInt32)(AppliedMath.HexToDec((String)this.dgVars[e.ColumnIndex, e.RowIndex].Value)));
}
else
{
m_CurrentValue = Convert.ToString(AppliedMath.HexToDec((String)this.dgVars[e.ColumnIndex, e.RowIndex].Value));
}
}
try { long i = long.Parse(m_CurrentValue); }
catch { m_error = true; }
if ((!m_error) && ((Convert.ToInt64(m_CurrentValue) <= long.Parse(m_CurrentRow[2].ToString())) && (Convert.ToInt64(m_CurrentValue) >= long.Parse(m_CurrentRow[3].ToString()))))
{
//Преобразование
if (this.codingType == 10)
{
if (m_newVar.HasSign)
{
m_SignValue = Convert.ToInt32(this.dgVars[e.ColumnIndex, e.RowIndex].Value);
}
else
{
if (m_newVar.Size == 4)
{
UInt32 m_Value = 0;
m_Value = Convert.ToUInt32(this.dgVars[e.ColumnIndex, e.RowIndex].Value);
for (int i = 0; i < 4; i++)
{
m_Vars[i] = (Byte)(m_Value % 256);
m_Value = m_Value / 256;
}
Array.Reverse(m_Vars);
m_SignValue = AppliedMath.BytesToInt(m_Vars);
}
else
{
m_SignValue = Convert.ToInt32(this.dgVars[e.ColumnIndex, e.RowIndex].Value);
}
}
}
else
{
m_SignValue = Convert.ToInt32(AppliedMath.HexToDec((String)this.dgVars[e.ColumnIndex, e.RowIndex].Value));
}
m_Vars = AppliedMath.IntToBytes(m_SignValue);
//закоментированный вариант корректно опрашивает только с обратным порядокм байт
//if (_engine.Parameters.InverseByteOrder) Array.Reverse(m_Vars);
//for (int i = 0; i < m_WriteVars.Length; i++) m_WriteVars[i] = m_Vars[i];
for (int i = 0; i < m_WriteVars.Length; i++)
{
m_WriteVars[i] = m_Vars[i + (4 - m_WriteVars.Length)];
}
if (_engine.Parameters.InverseByteOrder)
{
Array.Reverse(m_WriteVars);
}
}
else
{
m_error = true;
}
}
if (m_error)
{
this.dgVars[e.ColumnIndex, e.RowIndex].Value = this._EditCellText;
}
else
{
//Запись переменной в память
_engine.AddWriteItem(m_newVar.Address, m_newVar.Memory, m_WriteVars, "vars_write_" + m_newVar.Name, null, null);
}
this._EditVar = "";
}
catch (Exception ex)
{
this.dgVars[e.ColumnIndex, e.RowIndex].Value = this._EditCellText;
this._EditVar = "";
Utils.ErrorMessage("dgVars_CellEndEdit: " + ex.Message);
return;
}
}
/// <summary>
/// Построение прочитанног значения в зависимости от кодировки
/// </summary>
/// <param name="row"></param>
private void BuildDisplayValue(DataRow row)
{
DataRow m_row = row;
byte[] Buffer = (byte[])m_row.ItemArray[8];
bool real = (bool)row.ItemArray[9];
int size = (int)row.ItemArray[4];
long Value = 0;
double dValue = 0;
if (_engine.Parameters.InverseByteOrder && !real)
{
Array.Reverse(Buffer);
}
if (real)
{
if (size == 8)
{
dValue = BitConverter.ToDouble(Buffer, 0);
}
else
{
dValue = (double)BitConverter.ToSingle(Buffer, 0);
}
}
else
{
Value = AppliedMath.BytesToLong(Buffer);
if (_vars[m_row.ItemArray[0].ToString()].HasSign)
{
switch ((int)m_row.ItemArray[4])
{
case 1: Value = (sbyte)Value; break;
case 2: Value = (Int16)Value; break;
case 4: Value = (Int32)Value; break;
}
}
else
{
switch ((int)m_row.ItemArray[4])
{
case 1: Value = (Byte)Value; break;
case 2: Value = (UInt16)Value; break;
case 4: Value = (UInt32)Value; break;
}
}
}
//Добавление прочитанного значения
String m_StrVar = this._EditCellText;
String varName = m_row.ItemArray[0].ToString();
bool array = false;
array = _vars[varName] is ControllerUserVar && ((ControllerUserVar)_vars[varName]).Array;
if (!array)
{
array = _vars[varName] is ControllerSystemVar && ((ControllerSystemVar)_vars[varName]).Array;
}
if (array)
{//обработка значения если это массив
switch (codingType)
{
case 16:
String m_Str = "";
String m_Byte = "";
foreach (Byte m_byte in Buffer)
{
m_Byte = Convert.ToString(m_byte, codingType);
switch (m_Byte.Length)
{
case 0: m_Byte = "00" + m_Byte; break;
case 1: m_Byte = "0" + m_Byte; break;
default: break;
}
m_Str += m_Byte + " ";
}
m_StrVar = m_Str.ToUpper();
break;
default:
String m_Str1 = "";
foreach (Byte m_byte in Buffer)
{
m_Str1 += Convert.ToString(m_byte, codingType) + " ";
}
m_StrVar = m_Str1.ToUpper();
break;
}
}
else
{
switch (codingType)
{
case 16:
String m_Str = Convert.ToString(Value, codingType);
if (m_Str.Length > (int)m_row.ItemArray[4] * 2)
{
int m_CutIndex = m_Str.Length - (int)m_row.ItemArray[4] * 2;
m_Str = m_Str.Substring(m_CutIndex);
}
m_Str = "0x" + Utils.AddChars('0', m_Str, 8 /*(int)m_row.ItemArray[4] * 2*/);
m_StrVar = m_Str.ToUpper();
break;
default:
if (real)
{
m_StrVar = dValue.ToString("F2");
}
else
{
m_StrVar = Convert.ToString(Value, codingType).ToUpper();
}
break;
}
}
m_row[1] = m_StrVar.Replace('X', 'x');
}
/// <summary>
/// Генерирует h-файл с определениями модулей
/// </summary>
private string GenerateModulesHeader()
{
int count = 0;
int[] groupesReqTime = new int[8];
List <IOModule>[] groupes = new List <IOModule> [8];
List <IOModule> Req1msMod = new List <IOModule>();
List <IOModule> Req5msMod = new List <IOModule>();
List <IOModule> Req10msMod = new List <IOModule>();
List <IOModule> Req100msMod = new List <IOModule>();
for (int i = 0; i < 8; i++)
{
groupes[i] = new List <IOModule>();
}
foreach (IOModule mod in this.codeModel.IOModules.Values)
{
switch (mod.Period)
{
case 1:
Req1msMod.Add(mod);
break;
case 5:
Req5msMod.Add(mod);
break;
case 10:
Req10msMod.Add(mod);
break;
case 100:
Req100msMod.Add(mod);
break;
}
}
foreach (IOModule mod in Req1msMod)
{
for (int i = 0; i < groupes.Length; i++)
{
groupes[i].Add(mod);
}
}
count = 0;
foreach (IOModule mod in Req5msMod)
{
if (count == 0)
{
for (int i = 0; i < 8; i = i + 2)
{
groupes[i].Add(mod);
}
}
else
{
for (int i = 1; i < 8; i = i + 2)
{
groupes[i].Add(mod);
}
}
count++;
if (count == 2)
{
count = 0;
}
}
count = 0;
foreach (IOModule mod in Req10msMod)
{
groupes[count].Add(mod);
groupes[count + 4].Add(mod);
count++;
if (count == 4)
{
count = 0;
}
}
count = 0;
foreach (IOModule mod in Req100msMod)
{
groupes[count].Add(mod);
count++;
if (count == 8)
{
count = 0;
}
}
for (int i = 0; i < groupes.Length; i++)
{
double totalReqTime = 0.2;
double totalRepTime = 2;
foreach (IOModule m in groupes[i])
{
totalReqTime += m.RequestTime;
totalRepTime += m.ReplyTime;
}
int t1 = totalReqTime > (int)totalReqTime ? ((int)totalReqTime) + 1 : (int)totalReqTime;
int t2 = totalRepTime > (int)totalRepTime ? ((int)totalRepTime) + 1 : (int)totalRepTime;
groupesReqTime[i] = t1 + t2;
}
int d = MaxValueInArray(groupesReqTime);
foreach (IOModule mod in Req1msMod)
{
mod.RealPeriod = d;
}
int[] p = new int[4];
p[0] = groupesReqTime[0] + groupesReqTime[1];
p[1] = groupesReqTime[2] + groupesReqTime[3];
p[2] = groupesReqTime[4] + groupesReqTime[5];
p[3] = groupesReqTime[6] + groupesReqTime[7];
d = MaxValueInArray(p);
foreach (IOModule mod in Req5msMod)
{
mod.RealPeriod = d;
}
p = new int[2];
p[0] = groupesReqTime[0] + groupesReqTime[1] + groupesReqTime[2] + groupesReqTime[3];
p[1] = groupesReqTime[4] + groupesReqTime[5] + groupesReqTime[6] + groupesReqTime[7];
d = MaxValueInArray(p);
foreach (IOModule mod in Req10msMod)
{
mod.RealPeriod = d;
}
d = 0;
for (int i = 0; i < 8; i++)
{
d += groupesReqTime[i];
}
foreach (IOModule mod in Req100msMod)
{
mod.RealPeriod = d;
}
StringBuilder modulesh = new StringBuilder();
StringBuilder iodefinesh = new StringBuilder();
StringBuilder DIODefines = new StringBuilder();
StringBuilder AIODefines = new StringBuilder();
foreach (IOModule module in this.codeModel.IOModules.Values)
{
if (module is DigitalModule)
{
DIODefines.AppendLine("#define " + module.VarNames[0].DisplayName + " " + module.VarNames[0].SystemName);
}
else
{
AnalogModule amodule = (AnalogModule)module;
for (int i = 0; i < amodule.VarNames.Length; i++)
{
AIODefines.AppendLine("#define " + amodule.VarNames[i].DisplayName + " " + amodule.VarNames[i].SystemName);
AIODefines.AppendLine("#define " + amodule.SingleByteVarNames[i].DisplayName + " (" + amodule.VarNames[i].SystemName + ">>8)");
}
}
}
iodefinesh.AppendLine(DIODefines.ToString());
iodefinesh.AppendLine(AIODefines.ToString());
modulesh.AppendLine("const unsigned char mod_table[]={");
for (int i = 0; i < groupes.Length; i++)
{
if (groupes[i].Count != 0)
{
foreach (IOModule mod in groupes[i])
{
modulesh.Append("0x" + Utils.AddChars('0', AppliedMath.DecToHex(mod.ModuleNumber), 2) + ", ");
}
modulesh.AppendLine("0x00,");
}
}
modulesh.Append("0x00");
modulesh.AppendLine("};");
try
{
File.WriteAllText(this.solution.DirectoryName + "\\iodefines.h", iodefinesh.ToString());
}
catch (Exception ex)
{
this.Errors.Add(new CompilationError(ex.Message, this.codeModel.FileName, -1, false));
}
return(modulesh.ToString());
}
/// <summary>
/// Формирование адреса для отображения
/// </summary>
/// <param name="address"></param>
/// <returns></returns>
private string BuildDisplayAddress(int address)
{
return(("0x00000000".Insert("0x00000000".Length - ("" + AppliedMath.DecToHex(address)).Length, "" + AppliedMath.DecToHex(address))).Substring(0, 10));
}
/// <summary>
/// Событтие при двойном щелчке по дереву не прочитаннх переменных
/// (формировани запроса на их чтение)
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void tvVars_NodeMouseDoubleClick(object sender, System.Windows.Forms.TreeNodeMouseClickEventArgs e)
{
if ((e.Node.Nodes.Count == 0) && ((e.Node.Text.CompareTo("Системные переменные") != 0) && (e.Node.Text.CompareTo("Пользовательские переменные") != 0) && (e.Node.Text.CompareTo("Заводские установки") != 0)))
{
Kontel.Relkon.Classes.ControllerVar m_newVar = _solution.Vars.GetVarByName(e.Node.Text);
if (m_newVar == null)
{
return;
}
if (!_vars.ContainsKey(e.Node.Text))
{
_vars.Add(e.Node.Text, m_newVar);
//Добавление записи с читаемой переменной
Int64 m_Max = 0;
Int64 m_Min = 0;
if (m_newVar.HasSign)
{
switch (m_newVar.Size)
{
case 1: m_Max = sbyte.MaxValue; m_Min = sbyte.MinValue; break;
case 2: m_Max = Int16.MaxValue; m_Min = Int16.MinValue; break;
case 4: m_Max = Int32.MaxValue; m_Min = Int32.MinValue; break;
default: m_Max = sbyte.MaxValue; m_Min = sbyte.MinValue; break;
}
}
else
{
switch (m_newVar.Size)
{
case 1: m_Max = Byte.MaxValue; m_Min = Byte.MinValue; break;
case 2: m_Max = UInt16.MaxValue; m_Min = UInt16.MinValue; break;
case 4: m_Max = UInt32.MaxValue; m_Min = UInt32.MinValue; break;
default: m_Max = Byte.MaxValue; m_Min = Byte.MinValue; break;
}
}
DataRow m_row = this.Table.NewRow();
m_row[0] = m_newVar.Name;
m_row[2] = m_Max;
m_row[3] = m_Min;
m_row[4] = m_newVar.Size;
m_row[5] = m_newVar.Address;
m_row[6] = m_newVar.Memory;
m_row[7] = ("0x00000000".Insert("0x00000000".Length - ("" + AppliedMath.DecToHex(m_newVar.Address)).Length, "" + AppliedMath.DecToHex(m_newVar.Address))).Substring(0, 10);
m_row[8] = new byte[m_newVar.Size];
m_row[9] = m_newVar.Real;
this.BuildDisplayValue(m_row);
this.Table.Rows.Add(m_row);
//Запоминаем что читаем эту переменную в параметры отладчика
Kontel.Relkon.DebuggerParameters.VarDescription m_VarDescription = new Kontel.Relkon.DebuggerParameters.VarDescription();
m_VarDescription.Address = m_newVar.Address;
m_VarDescription.MemoryType = m_newVar.Memory;
m_VarDescription.Name = m_newVar.Name;
m_VarDescription.Size = m_newVar.Size;
m_VarDescription.Real = m_newVar.Real;
m_VarDescription.Type = e.Node.Parent.Index;
_engine.Parameters.ReadingVars.Add(m_VarDescription);
//Добавление переменной на опрос
if (this._IsReading)
{
for (int i = 0; i < this.Table.Rows.Count; i++)
{
if (this.Table.Rows[i][0].ToString() == m_newVar.Name)
{
try { _engine.AddReadItem(m_newVar.Address, m_newVar.Memory, m_newVar.Size, this.Table.Rows[i], null, CallBack); }
catch { }
}
}
}
}
this.tvVars.Nodes.Remove(e.Node);
}
}
/// <summary>
/// Записть измененного знаячения при завершении редактирования ячейки
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void dgv_askStructs_CellEndEdit(object sender, DataGridViewCellEventArgs e)
{
//Определение правильности введенного значения
bool m_error = false;
//Определение изменяемой переменной
DataRow m_CurrentRow = (DataRow)this.DisplayVarsTable.Rows[this.dgv_askStructs.CurrentRow.Index];
//Определения правльности входных данных. Формирование массива для записи
Byte[] m_Vars = new Byte[4];
Byte[] m_WriteVars = new Byte[(int)m_CurrentRow[7]];
int m_SignValue = 0;
String m_CurrentValue = "";
if (this.dgv_askStructs[e.ColumnIndex, e.RowIndex].Value.ToString().Trim() != "")
{
if (this.codingType == 10)
{
m_CurrentValue = (String)(this.dgv_askStructs[e.ColumnIndex, e.RowIndex].Value);
}
else
{
if ((int)m_CurrentRow[7] == 4)
{
m_CurrentValue = Convert.ToString((UInt32)(AppliedMath.HexToDec((String)this.dgv_askStructs[e.ColumnIndex, e.RowIndex].Value)));
}
else
{
m_CurrentValue = Convert.ToString(AppliedMath.HexToDec((String)this.dgv_askStructs[e.ColumnIndex, e.RowIndex].Value));
}
if (this.dgv_askStructs[e.ColumnIndex, e.RowIndex].Value.ToString().Contains("-"))
{
m_error = true;
}
}
try { long i = long.Parse(m_CurrentValue); }
catch { m_error = true; }
}
else
{
m_error = true;
}
if ((!m_error) && ((Convert.ToInt64(m_CurrentValue) <= (long)m_CurrentRow[8]) && (Convert.ToInt64(m_CurrentValue) >= (long)m_CurrentRow[9])))
{
//Преобразование
if (!((long)m_CurrentRow[9] < 0 || (int)m_CurrentRow[7] == 4))
{
UInt32 m_Value = 0;
m_Value = Convert.ToUInt32(m_CurrentValue);
for (int i = 0; i < 4; i++)
{
m_Vars[i] = (Byte)(m_Value % 256);
m_Value = m_Value / 256;
}
Array.Reverse(m_Vars);
m_SignValue = AppliedMath.BytesToInt(m_Vars);
}
else
{
m_SignValue = Convert.ToInt32(m_CurrentValue);
}
m_Vars = AppliedMath.IntToBytes(m_SignValue);
Array.Reverse(m_Vars);
for (int i = 0; i < m_WriteVars.Length; i++)
{
m_WriteVars[i] = m_Vars[i];
}
if (!_engine.Parameters.InverseByteOrder)
{
Array.Reverse(m_WriteVars);
}
}
else
{
m_error = true;
}
if (m_error)
{
this.dgv_askStructs[e.ColumnIndex, e.RowIndex].Value = this._EditCellText;
}
else
{
//Запись переменной в память
_engine.AddWriteItem((int)m_CurrentRow[6], GetMemoryType(m_CurrentRow[5].ToString()), m_WriteVars, "vars_write_" + m_CurrentRow[1].ToString() + "_" + m_CurrentRow[0].ToString(), null, null);
}
this._EditRow = null;
}
public override void GeneratePultCode()
{
StringBuilder code = new StringBuilder();
IndentedTextWriter writer = new IndentedTextWriter(new StringWriter(code));
writer.WriteLine("/***********PultDataCI***************/");
for (int i = 0; i < this.pultModel.Rows.Count; i++)
{
writer.WriteLine("const unsigned char str" + (i + 1).ToString() + "[][" + this.pultModel.Type.SymbolsInRow + "] = {");
writer.Indent++;
foreach (View view in this.pultModel.Rows[i].Views)
{
if (!view.Enabled)
{
continue;
}
writer.WriteLine("\"" + this.ConvertStringToSTM32F107Format(view) + "\",");
}
if (this.pultModel.Rows[i].Views.Count > 0)
{
View view = this.pultModel.Rows[i].Views[this.pultModel.Rows[i].Views.Count - 1];
writer.WriteLine("\"" + this.ConvertStringToSTM32F107Format(view) + "\"");
}
writer.Indent--;
writer.WriteLine("};");
}
writer.WriteLine("void print_var(void)");
writer.WriteLine("{");
writer.Indent++;
for (int i = 1; i < this.pultModel.Rows.Count + 1; i++)
{
writer.WriteLine("switch(_Sys.S" + i + ")");
writer.WriteLine("{");
writer.Indent++;
for (int j = 0; j < this.pultModel.Rows[i - 1].EnabledViews.Count; j++)
{
View view = this.pultModel.Rows[i - 1].EnabledViews[j];
if (view.Vars.Count == 0)
{
continue;
}
view.Vars.Sort(PultVar.CompareByPosition);
writer.WriteLine("case " + j + ":");
writer.Indent++;
foreach (PultVar v in view.Vars)
{
int afterDot = Math.Min(3, GetNumberOfDigitsAfterDotInMask(v.Mask));
int s = afterDot == 0 ? v.Mask.Length : v.Mask.Length - 1;
s = Math.Min(7, s);
RelkonCodeVarDefenition var = solution.GetRelkonCodeVarDefenitionByName(v.Name);
if (var != null)
{
if (v.ReadOnly)
{
if (var.Type == "float")
{
writer.WriteLine("print_float(" + v.Name + ", " + i + ", " + (v.Position + 1).ToString() + ", "
+ s + ", " + afterDot + ");");
}
else
{
writer.WriteLine("print_long((long)" + v.Name + ", " + i + ", " + (v.Position + 1).ToString() + ", "
+ s
+ ", " + afterDot + ");");
}
}
else
{
writer.WriteLine("print_edit((void*)&" + var.Name + ", " + i
+ ", " + ++v.Position + ", "
+ s
+ ", " + afterDot + ", 0x" + AppliedMath.DecToHex(GetTypeCodeOfVar(var, v.HasSign)) + ");");
}
}
else
{
if (v.Name == "HOUR" ||
v.Name == "MIN" ||
v.Name == "SEC" ||
v.Name == "DATE" ||
v.Name == "MONTH" ||
v.Name == "YEAR")
{
if (v.ReadOnly)
{
writer.WriteLine("print_long((long)" + "times." + v.Name.ToLower() + ", " + i + ", " + (v.Position + 1).ToString() + ", "
+ s
+ ", " + afterDot + ");");
}
else
{
writer.WriteLine("print_time(" + i + "," + (v.Position + 1).ToString() + "," + v.Name + "_TYPE);");
}
continue;
}
Match m = Regex.Match(v.Name, @"\bEE(\d+)");
if (m.Success)
{
if (v.ReadOnly)
{
writer.WriteLine("print_long((long)" + v.Name + ", " + i + ", " + (v.Position + 1).ToString() + ", "
+ s
+ ", " + afterDot + ");");
}
else
{
writer.WriteLine("print_edit_ee(" + int.Parse(m.Groups[1].Value) + ", " + i
+ ", " + ++v.Position + ", "
+ s
+ ", " + afterDot + ", 0x" + AppliedMath.DecToHex(GetTypeCodeOfEEVar(v.Name, v.HasSign)) + ");");
}
continue;
}
for (int k = 1; k < 9; k++)
{
v.Name = Regex.Replace(v.Name, @"\bADC" + k + "\b", "_Sys_ADC[" + (k - 1).ToString() + "]");
//Match m = Regex.Match(v.Name, );
//v.Name = v.Name.Replace("ADC" + k, "_Sys_ADC[" + (k - 1).ToString() + "]");
}
if (v.ReadOnly)
{
writer.WriteLine("print_long((long)" + v.Name + ", " + i + ", " + (v.Position + 1).ToString() + ", "
+ (afterDot == 0 ? v.Mask.Length : v.Mask.Length - 1).ToString()
+ ", " + afterDot + ");");
}
else
{
if (v.Name.Contains("ADC") || v.Name.Contains("DAC"))
{
writer.WriteLine("print_edit((void*)&" + v.Name + ", " + i
+ ", " + ++v.Position + ", "
+ (afterDot == 0 ? v.Mask.Length : v.Mask.Length - 1).ToString()
+ ", " + afterDot + ", 0x02);");
}
else
{
writer.WriteLine("print_edit((void*)&" + v.Name + ", " + i
+ ", " + ++v.Position + ", "
+ (afterDot == 0 ? v.Mask.Length : v.Mask.Length - 1).ToString()
+ ", " + afterDot + ", 0x01);");
}
}
}
}
writer.WriteLine("break;");
writer.Indent--;
}
writer.WriteLine("default: break;");
writer.Indent--;
writer.WriteLine("}");
}
writer.Indent--;
writer.WriteLine("}");
writer.WriteLine("");
writer.Close();
try
{
using (StreamWriter wr = new StreamWriter(this.solution.DirectoryName + "\\fc_u.c", true, Encoding.Default))
{
wr.Write(code.ToString());
}
}
catch (Exception ex)
{
this.Errors.Add(new Kontel.Relkon.Classes.CompilationError(ex.Message, this.solution.DirectoryName + "\\fc_u.c", -1, false));
}
}
