//конвертируем из значения массив байт в соответствии структуре
public int[] ConvertToOutput(dynamic inputValue, RegStructure outputRegStruct)
{
#region output
//dynamic outputValue = 0;
if (RegTypeAttribute.GetRegType(outputRegStruct) == RegStructType._double)
{
double outputValue = (double)inputValue;
return(BytesToRegs(BitConverter.GetBytes(outputValue), outputRegStruct));
}
else if (RegTypeAttribute.GetRegType(outputRegStruct) == RegStructType._float)
{
float outputValue = (float)inputValue;
if (float.IsPositiveInfinity(outputValue))
{
outputValue = float.MaxValue;
}
else if (float.IsNegativeInfinity(outputValue))
{
outputValue = float.MinValue;
}
return(BytesToRegs(BitConverter.GetBytes(outputValue), outputRegStruct));
}
else //if (RegTypeAttribute.GetRegType(outputRegStruct) == RegStructType._long)
{
Int32 outputValue = (Int32)inputValue;
return(BytesToRegs(BitConverter.GetBytes(outputValue), outputRegStruct));
}
#endregion
}
//конвертируем из байт в значение в соответсвии со структурой
public dynamic ConvertFromInput(int[] regs, RegStructure inputRegStruct)
{
dynamic inputValue = 0;
if (RegTypeAttribute.GetRegType(inputRegStruct) == RegStructType._double)
{
//перевести в double а потом в байты
///переименовать в regs to bytes
var inputBytes = RegsToBytes(regs, inputRegStruct);
inputValue = ToDouble(inputBytes);
}
else if (RegTypeAttribute.GetRegType(inputRegStruct) == RegStructType._float)
{
var inputBytes = RegsToBytes(regs, inputRegStruct);
inputValue = ToFloat(inputBytes);
}
else if (RegTypeAttribute.GetRegType(inputRegStruct) == RegStructType._long)
{
var inputBytes = RegsToBytes(regs, inputRegStruct);
inputValue = ToLong(inputBytes);
}
return(inputValue);
}
/// <summary>
/// Переводи 4 регистра в double
/// </summary>
/// <param name="regs"></param>
/// <param name="doubleStructure"></param>
/// <returns></returns>
public byte[] RegsToBytes(int[] regs, RegStructure regStructure)
{
byte[] result = new byte[regs.Length * sizeof(int)];
//(AB CD EF GH)
if (regStructure == RegStructure.Double_AB_CD_EF_GH)
{
int j = regs.Length - 1;
for (int i = 0; i < regs.Length; i++)
{
result[2 * i] = BitConverter.GetBytes(regs[j])[0];
result[2 * i + 1] = BitConverter.GetBytes(regs[j])[1];
j--;
}
}
//(BA DC FE GH)
else if (regStructure == RegStructure.Double_BA_DC_FE_GH)
{
int j = regs.Length - 1;
for (int i = 0; i < regs.Length; i++)
{
result[2 * i] = BitConverter.GetBytes(regs[j])[1];
result[2 * i + 1] = BitConverter.GetBytes(regs[j])[0];
j--;
}
}
/////(GH EF CD AB)
else if (regStructure == RegStructure.Double_GH_EF_CD_AB)
{
for (int i = 0; i < regs.Length; i++)
{
result[2 * i] = BitConverter.GetBytes(regs[i])[0];
result[2 * i + 1] = BitConverter.GetBytes(regs[i])[1];
}
}
/////(HG FE DC BA)
else if (regStructure == RegStructure.Double_HG_FE_DC_BA)
{
for (int i = 0; i < regs.Length; i++)
{
result[2 * i] = BitConverter.GetBytes(regs[i])[1];
result[2 * i + 1] = BitConverter.GetBytes(regs[i])[0];
}
}
else if (regStructure == RegStructure.Float_AB_CD || regStructure == RegStructure.Long_AB_CD)
{
int j = regs.Length - 1;
for (int i = 0; i < regs.Length; i++)
{
result[2 * i] = BitConverter.GetBytes(regs[j])[0];
result[2 * i + 1] = BitConverter.GetBytes(regs[j])[1];
j--;
}
}
else if (regStructure == RegStructure.Float_BA_DC || regStructure == RegStructure.Long_BA_DC)
{
int j = regs.Length - 1;
for (int i = 0; i < regs.Length; i++)
{
result[2 * i] = BitConverter.GetBytes(regs[j])[1];
result[2 * i + 1] = BitConverter.GetBytes(regs[j])[0];
j--;
}
}
else if (regStructure == RegStructure.Float_CD_AB || regStructure == RegStructure.Long_CD_AB)
{
for (int i = 0; i < regs.Length; i++)
{
result[2 * i] = BitConverter.GetBytes(regs[i])[0];
result[2 * i + 1] = BitConverter.GetBytes(regs[i])[1];
}
}
else if (regStructure == RegStructure.Float_DC_BA || regStructure == RegStructure.Long_DC_BA)
{
for (int i = 0; i < regs.Length; i++)
{
result[2 * i] = BitConverter.GetBytes(regs[i])[1];
result[2 * i + 1] = BitConverter.GetBytes(regs[i])[0];
}
}
else
{
throw new Exception("!!!!!!!!!!!");
}
return(result);
}
public int[] BytesToRegs(byte[] regs, RegStructure regStructure)
{
foreach (var b in regs)
{
Console.WriteLine(b);
}
if (regStructure == RegStructure.Float_CD_AB || regStructure == RegStructure.Long_CD_AB)
{
byte[] highRegisterBytes = { regs[2], regs[3], 0, 0 };
byte[] lowRegisterBytes = { regs[0], regs[1], 0, 0 };
int[] returnValue =
{
BitConverter.ToInt32(lowRegisterBytes, 0),
BitConverter.ToInt32(highRegisterBytes, 0)
};
return(returnValue);
}
else if (regStructure == RegStructure.Float_DC_BA || regStructure == RegStructure.Long_DC_BA)
{
byte[] highRegisterBytes = { regs[3], regs[2], 0, 0 };
byte[] lowRegisterBytes = { regs[1], regs[0], 0, 0 };
int[] returnValue =
{
BitConverter.ToInt32(lowRegisterBytes, 0),
BitConverter.ToInt32(highRegisterBytes, 0)
};
return(returnValue);
}
else if (regStructure == RegStructure.Float_AB_CD || regStructure == RegStructure.Long_AB_CD)
{
byte[] highRegisterBytes = { regs[0], regs[1], 0, 0 };
byte[] lowRegisterBytes = { regs[2], regs[3], 0, 0 };
int[] returnValue =
{
BitConverter.ToInt32(lowRegisterBytes, 0),
BitConverter.ToInt32(highRegisterBytes, 0)
};
return(returnValue);
}
else if (regStructure == RegStructure.Float_BA_DC || regStructure == RegStructure.Long_BA_DC)
{
byte[] highRegisterBytes = { regs[1], regs[0], 0, 0 };
byte[] lowRegisterBytes = { regs[3], regs[2], 0, 0 };
int[] returnValue =
{
BitConverter.ToInt32(lowRegisterBytes, 0),
BitConverter.ToInt32(highRegisterBytes, 0)
};
return(returnValue);
}
///
else if (regStructure == RegStructure.Double_GH_EF_CD_AB)
{
byte[] highRegisterBytes = { regs[6], regs[7], 0, 0 };
byte[] highLowRegisterBytes = { regs[4], regs[5], 0, 0 };
byte[] lowHighRegisterBytes = { regs[2], regs[3], 0, 0 };
byte[] lowRegisterBytes = { regs[0], regs[1], 0, 0 };
int[] returnValue =
{
BitConverter.ToInt32(lowRegisterBytes, 0),
BitConverter.ToInt32(lowHighRegisterBytes, 0),
BitConverter.ToInt32(highLowRegisterBytes, 0),
BitConverter.ToInt32(highRegisterBytes, 0)
};
return(returnValue);
}
else if (regStructure == RegStructure.Double_HG_FE_DC_BA)
{
byte[] highRegisterBytes = { regs[7], regs[6], 0, 0 };
byte[] highLowRegisterBytes = { regs[5], regs[4], 0, 0 };
byte[] lowHighRegisterBytes = { regs[4], regs[2], 0, 0 };
byte[] lowRegisterBytes = { regs[1], regs[0], 0, 0 };
int[] returnValue =
{
BitConverter.ToInt32(lowRegisterBytes, 0),
BitConverter.ToInt32(lowHighRegisterBytes, 0),
BitConverter.ToInt32(highLowRegisterBytes, 0),
BitConverter.ToInt32(highRegisterBytes, 0)
};
return(returnValue);
}
else if (regStructure == RegStructure.Double_AB_CD_EF_GH)
{
byte[] highRegisterBytes = { regs[0], regs[1], 0, 0 };
byte[] highLowRegisterBytes = { regs[2], regs[3], 0, 0 };
byte[] lowHighRegisterBytes = { regs[4], regs[5], 0, 0 };
byte[] lowRegisterBytes = { regs[6], regs[7], 0, 0 };
int[] returnValue =
{
BitConverter.ToInt32(lowRegisterBytes, 0),
BitConverter.ToInt32(lowHighRegisterBytes, 0),
BitConverter.ToInt32(highLowRegisterBytes, 0),
BitConverter.ToInt32(highRegisterBytes, 0)
};
return(returnValue);
}
else if (regStructure == RegStructure.Double_BA_DC_FE_GH)
{
byte[] highRegisterBytes = { regs[1], regs[0], 0, 0 };
byte[] highLowRegisterBytes = { regs[3], regs[2], 0, 0 };
byte[] lowHighRegisterBytes = { regs[5], regs[4], 0, 0 };
byte[] lowRegisterBytes = { regs[7], regs[6], 0, 0 };
int[] returnValue =
{
BitConverter.ToInt32(lowRegisterBytes, 0),
BitConverter.ToInt32(lowHighRegisterBytes, 0),
BitConverter.ToInt32(highLowRegisterBytes, 0),
BitConverter.ToInt32(highRegisterBytes, 0)
};
return(returnValue);
}
///
else
{
throw new Exception("!!!!");
return(new int[] { 0, 0 });
}
}
public int[] Convert(int[] regs, RegStructure inputRegStruct, RegStructure outputRegStruct)
{
var inputValue = ConvertFromInput(regs, inputRegStruct);
return(ConvertToOutput(inputValue, outputRegStruct));
}
