public void ACTUALIZE_valueAndLogIt(ref C_Value val, byte add_L, byte add_H, e_regByteType type)
{
val.Hex = GET_2bytesFromReg(add_L, add_H, type);
LOG_reg(string.Format(
"[{0}]-{1} actualized form motor! \t[{1}]", reg.GET_name(add_L), type, val.ToString()
));
}
public List <byte> GET_byteAddresses(e_regByteType regByteType)
{
List <byte> bys = new List <byte>();
//returns the list of with stated rw
foreach (C_RegByte regByte in reg)
{
// if seenValue -> return only those which can be read from motor
if (regByteType == e_regByteType.seenValue)
{
if (regByte.GET(regByteType).IS_readableActual() == true)
{
bys.Add(regByte.byteAddress);
}
}
// if sentValue -> return only those which can be written to motor
else if (regByteType == e_regByteType.sentValue)
{
if (regByte.GET(regByteType).IS_writableActual() == true)
{
bys.Add(regByte.byteAddress);
}
}
}
return(bys);
}
public byte ACTUALIZE_byteAndLogIt(byte add, e_regByteType type)
{
byte val = reg.GET(add, type).Val;
LOG_reg(string.Format(
"[{0}]-{1} actualized form motor! \t[{2}]", reg.GET_name(add), type, val.ToString()
));
return(val);
}
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#endregion LOG
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
public void ACTUALIZE_register(byte addressByte, byte byteValue, e_regByteType type)
{
if (reg.IS_writableShadow(addressByte) == true)
{
Reg.SET(addressByte, byteValue, type);
ACTUALIZE_registerBinding(addressByte);
MainWindow.REFRESH_motorData();
//REFRESH_motorData();
}
}
public void SET(byte _value, e_regByteType _type)
{
switch (_type)
{
case (e_regByteType.registerDefault): def.Val = _value; break;
case (e_regByteType.sentValue): sent.Val = _value; break;
case (e_regByteType.seenValue): seen.Val = _value; break;
}
}
public C_RegByteValue GET(e_regByteType _type)
{
switch (_type)
{
case (e_regByteType.registerDefault): return(def);
case (e_regByteType.sentValue): return(sent);
case (e_regByteType.seenValue): return(seen);
}
throw new Exception(string.Format(
"[{0}] is not a valid type of register byte!", _type));
}
public C_RegByteValue GET(int _add, e_regByteType _type)
{
lock (lock_reg)
{
if (_add < i_maxReg)
{
return(reg[_add].GET(_type));
}
else
{
throw new Exception(GET_outOfBoundsInfo(_add));
}
}
}
public void SET(int _add, byte _value, e_regByteType _type)
{
lock (lock_reg)
{
if (_add < i_maxReg)
{
reg[_add].SET(_value, _type);
}
else
{
throw new Exception(GET_outOfBoundsInfo(_add));
}
}
}
public C_MotorDataRow(byte _address, e_regByteType _regByteType)
{
dataType = e_motorDataType.regByteValue;
address = _address;
regByteType = _regByteType;
letter_regByteType = 'D';
if (_regByteType == e_regByteType.seenValue)
{
letter_regByteType = 'R';
}
if (_regByteType == e_regByteType.sentValue)
{
letter_regByteType = 'W';
}
name = string.Format("{0}", MainWindow.Ms.Yaw.Reg.GET_name(address));
motStrings = new string[3];
REFRESH();
}
public static void ACTUALIZE_motorRegister(e_rot rot, e_regByteType type, List <byte> pars)
{
if (pars.Count > 0)
{
byte addressByte = pars[0];
byte[] parValues = pars.Skip(1).ToArray();
C_Packet.LOG_statusPacket(string.Format(
"Status OK - actualizing mot[{0}] register type[{1}]: From address[{2}]=[{3}], these values[{4}]",
rot, type, addressByte, MainWindow.Ms[rot].Reg.GET_name(addressByte),
C_CONV.byteArray2strHex_space(parValues)));
foreach (byte byteValue in parValues)
{
C_SPI.LOG_unimportant(string.Format(
"going to acualize mot[{0}] register on address [{1}]",
rot, addressByte
));
MainWindow.Ms[rot].ACTUALIZE_register(addressByte, byteValue, type);
addressByte++;
}
}
}
public byte[] GET_2bytesFromReg(byte add_L, byte add_H, e_regByteType type)
{
return(new byte[] { reg.GET((int)add_L, type).Val, reg.GET((int)add_H, type).Val });
}
