public static object SwapADF(object[] arguments)
{
try
{
FsuipcSdk.Fsuipc fsuipc = new FsuipcSdk.Fsuipc();
int result = 0;
if (fsuipc.FSUIPC_Open(FsuipcSdk.Fsuipc.SIM_ANY, ref result))
{
// odczytanie ustawień ADF1
int adf1btoken = 0;
fsuipc.FSUIPC_Read(0x034C, 2, ref adf1btoken, ref result);
int adf1etoken = 0;
fsuipc.FSUIPC_Read(0x0356, 2, ref adf1etoken, ref result);
// odczytanie ustaiwń ADF2
int adf2btoken = 0;
fsuipc.FSUIPC_Read(0x02D4, 2, ref adf2btoken, ref result);
int adf2etoken = 0;
fsuipc.FSUIPC_Read(0x02D6, 2, ref adf2etoken, ref result);
fsuipc.FSUIPC_Process(ref result);
// pobranie wartości
short adf1b = 0;
fsuipc.FSUIPC_Get(ref adf1btoken, ref adf1b);
short adf1e = 0;
fsuipc.FSUIPC_Get(ref adf1etoken, ref adf1e);
short adf2b = 0;
fsuipc.FSUIPC_Get(ref adf2btoken, ref adf2b);
short adf2e = 0;
fsuipc.FSUIPC_Get(ref adf2etoken, ref adf2e);
// zamiana wartości
short tmp = 0;
tmp = adf1b;
adf1b = adf2b;
adf2b = tmp;
tmp = adf1e;
adf1e = adf2e;
adf2e = tmp;
// zapisanie
fsuipc.FSUIPC_Write(0x034C, adf1b, ref adf1btoken, ref result);
fsuipc.FSUIPC_Write(0x0356, adf1e, ref adf1etoken, ref result);
fsuipc.FSUIPC_Write(0x02D4, adf2b, ref adf2btoken, ref result);
fsuipc.FSUIPC_Write(0x02D6, adf2e, ref adf2etoken, ref result);
fsuipc.FSUIPC_Process(ref result);
fsuipc.FSUIPC_Close();
}
}
catch
{
}
return(true);
}
public static object GetOffsetValue(object [] arguments)
{
object result = (int)0;
int offset = (int)arguments[0];
int size = (int)arguments[1];
int type = 0;
if (arguments.Length > 2)
{
type = (int)arguments[2];
}
try
{
FsuipcSdk.Fsuipc fsuipc = new FsuipcSdk.Fsuipc();
int dwresult = 0;
if (fsuipc.FSUIPC_Open(FsuipcSdk.Fsuipc.SIM_ANY, ref dwresult))
{
int token = 0;
if (fsuipc.FSUIPC_Read(offset, size, ref token, ref dwresult))
{
if (fsuipc.FSUIPC_Process(ref dwresult))
{
switch (type)
{
// liczba
case 0:
switch (size)
{
case 1:
byte bv = 0;
fsuipc.FSUIPC_Get(ref token, ref bv);
return((int)bv);
case 2:
short sv = 0;
fsuipc.FSUIPC_Get(ref token, ref sv);
return((int)sv);
}
break;
}
}
}
fsuipc.FSUIPC_Close();
}
}
catch
{
}
return(result);
}
public override int SetValue(object value, FsuipcSdk.Fsuipc fsuipc)
{
//Debug.WriteLine(string.Format("FS Write: Offset = {0}, Value = {1}", Offset, value));
// przetworzenie wartości
int iv = (int)value;
int result = FsuipcSdk.Fsuipc.FSUIPC_ERR_OK;
switch (FSType)
{
case FSDataType.Byte:
byte b = (byte)iv;
if (_firstSet || Math.Abs(_bValue - b) >= Change)
{
_bValue = b;
bool rrr = fsuipc.FSUIPC_Write(Offset, _bValue, ref Token, ref result);
Debug.WriteLine(string.Format("FS Write (byte), {0}, {1}, {2}", Offset, _bValue, rrr));
}
break;
case FSDataType.Short:
short s = (short)iv;
if (_firstSet || Math.Abs(_sValue - s) >= Change)
{
_sValue = s;
bool rrr = fsuipc.FSUIPC_Write(Offset, _sValue, ref Token, ref result);
Debug.WriteLine(string.Format("FS Write (short), {0}, {1}, {2}", Offset, _sValue, rrr));
}
break;
case FSDataType.Int:
if (_firstSet || Math.Abs(_iValue - iv) >= Change)
{
_iValue = iv;
fsuipc.FSUIPC_Write(Offset, _iValue, ref Token, ref result);
}
break;
case FSDataType.Long:
long l = BitConverter.DoubleToInt64Bits((double)iv);
if (_firstSet || Math.Abs(_lValue - l) >= Change)
{
_lValue = l;
fsuipc.FSUIPC_Write(Offset, _lValue, ref Token, ref result);
}
break;
default:
throw new Exception();
}
_firstSet = false;
return(result);
}
public override int SetValue(object value, FsuipcSdk.Fsuipc fsuipc)
{
Debug.WriteLine(string.Format("FS Write: Offset = {0}", Offset));
// przetworzenie wartości
double dv = (double)value;
int result = FsuipcSdk.Fsuipc.FSUIPC_ERR_OK;
switch (FSType)
{
case FSDataType.Byte:
byte b = (byte)dv;
if (Math.Abs(_bValue - b) >= Change)
{
_bValue = b;
fsuipc.FSUIPC_Write(Offset, _bValue, ref Token, ref result);
}
break;
case FSDataType.Short:
short s = (short)dv;
if (Math.Abs(_sValue - s) >= Change)
{
_sValue = s;
fsuipc.FSUIPC_Write(Offset, _sValue, ref Token, ref result);
}
break;
case FSDataType.Int:
int i = (int)dv;
if (Math.Abs(_iValue - i) >= Change)
{
_iValue = i;
fsuipc.FSUIPC_Write(Offset, _iValue, ref Token, ref result);
}
break;
case FSDataType.Long:
long l = BitConverter.DoubleToInt64Bits(dv);
if (Math.Abs(_lValue - l) >= Change)
{
_lValue = l;
fsuipc.FSUIPC_Write(Offset, _lValue, ref Token, ref result);
}
break;
default:
throw new Exception();
}
return(result);
}
private static bool _MovePlaneToGateID(int id)
{
LoadGates();
Gate gate = __gates.Find(delegate(Gate o)
{
return(o.ID == id);
});
if (gate != null)
{
// ustawienie samolotu
// połączenie z FSUIPC itp.
try
{
FsuipcSdk.Fsuipc fsuipc = new FsuipcSdk.Fsuipc();
int result = 0;
if (fsuipc.FSUIPC_Open(FsuipcSdk.Fsuipc.SIM_ANY, ref result))
{
// włączenie SLEW MODE
int token = 0;
fsuipc.FSUIPC_Write(0x05dc, (short)1, ref token, ref result);
fsuipc.FSUIPC_Process(ref result);
// przeniesienie samolotu na wybraną pozycję
double off = 90d / (10001750d * 65536d * 65536d); // 42957189152768000d;
long lat = (long)(gate.Latitude / off);
off = 360d / (65536d * 65536d * 65536d * 65536d);
long lon = (long)(gate.Longitude / off);
fsuipc.FSUIPC_Write(0x0560, lat, ref token, ref result);
fsuipc.FSUIPC_Write(0x0568, lon, ref token, ref result);
fsuipc.FSUIPC_Write(0x0580, (uint)(gate.HeadingTrue / (360d / (65536d * 65536d))), ref token, ref result);
fsuipc.FSUIPC_Write(0x0570, long.MinValue, ref token, ref result);
fsuipc.FSUIPC_Process(ref result);
// wyłączenie SLEW MODE
fsuipc.FSUIPC_Write(0x05dc, (short)0, ref token, ref result);
fsuipc.FSUIPC_Process(ref result);
fsuipc.FSUIPC_Close();
return(true);
}
}
catch
{
}
}
return(false);
}
public override int SetValue(object value, FsuipcSdk.Fsuipc fsuipc)
{
if (_listenForChange)
{
_state = (bool)value != _lastState;
if (_state)
{
_lastState = (bool)value;
}
}
else
{
_state = (bool)value;
}
return(FsuipcSdk.Fsuipc.FSUIPC_ERR_OK);
}
public static object ChangeADF(object [] arguments)
{
int adfOffset = (int)arguments[0] < 1 ? 0x034C : 0x02D4;
int change = (int)arguments[1];
try
{
FsuipcSdk.Fsuipc fsuipc = new FsuipcSdk.Fsuipc();
int result = 0;
if (fsuipc.FSUIPC_Open(FsuipcSdk.Fsuipc.SIM_ANY, ref result))
{
// odczytanie ustawień ADF
int adfbtoken = 0;
fsuipc.FSUIPC_Read(adfOffset, 2, ref adfbtoken, ref result);
fsuipc.FSUIPC_Process(ref result);
// pobranie wartości
short adfb = 0;
fsuipc.FSUIPC_Get(ref adfbtoken, ref adfb);
int iv = HexToInt((int)adfb);
iv += change;
if (iv < 100)
{
iv += 700;
}
if (iv > 799)
{
iv -= 700;
}
adfb = (short)IntToHex(iv);
// zapisanie
fsuipc.FSUIPC_Write(adfOffset, adfb, ref adfbtoken, ref result);
fsuipc.FSUIPC_Process(ref result);
fsuipc.FSUIPC_Close();
}
}
catch
{
}
return(true);
}
public override int SetValue(object value, FsuipcSdk.Fsuipc fsuipc)
{
int result = FsuipcSdk.Fsuipc.FSUIPC_ERR_OK;
string sv = (string)value;
if (Change == 0d || _value != sv)
{
byte [] vb = Encoding.ASCII.GetBytes(sv);
if (vb.Length < Size)
{
byte[] vb2 = new byte[Size];
Array.Copy(vb, vb2, vb.Length);
fsuipc.FSUIPC_Write(Offset, Size, ref vb2, ref Token, ref result);
}
else
{
fsuipc.FSUIPC_Write(Offset, Size, ref vb, ref Token, ref result);
}
_value = sv;
}
return(result);
}
private void ProcessingMethod()
{
FsuipcSdk.Fsuipc fsuipc = null;
bool connected = false;
try
{
int ret = 0;
int interval = _configuration.Settings.Interval;
int fs = 0;
switch (_configuration.Settings.FSVersion)
{
case FSVersion.Dowolna:
fs = FsuipcSdk.Fsuipc.SIM_ANY;
break;
case FSVersion.FS2002:
fs = FsuipcSdk.Fsuipc.SIM_FS2K2;
break;
case FSVersion.FS2004:
fs = FsuipcSdk.Fsuipc.SIM_FS2K4;
break;
case FSVersion.FSX:
fs = FsuipcSdk.Fsuipc.SIM_FSX;
break;
default:
throw new Exception("Nieobsługiwana wersja symulatora '" + _configuration.Settings.FSVersion.ToString() + "'.");
}
_log.Log(this, "Próba połączenia z symulatorem w wersji '" + _configuration.Settings.FSVersion.ToString() + "'.");
fsuipc = new FsuipcSdk.Fsuipc();
while (_working)
{
if (fsuipc.FSUIPC_Open(fs, ref ret))
{
_log.Log(this, "Połączono z symulatorem w wersji '" + _configuration.Settings.FSVersion.ToString() + "'.");
connected = true;
break;
}
Thread.Sleep(100);
}
List <VariableToWrite> vars = new List <VariableToWrite>();
_signal.Set();
while (_working)
{
_signal.WaitOne();
if (!_working)
{
break;
}
// pobranie tablicy z wartościami do zapisu
lock (_syncQueue)
{
while (_writeQueue.Count > 0)
{
vars.Add(_writeQueue.Dequeue());
}
}
_signal.Reset();
if (vars.Count > 0)
{
int ile = 0;
while (vars.Count > 0)
{
VariableToWrite v = vars[0];
if (!(v.Variable is SpecialOutputVariable))
{
ile++;
}
ret = v.Variable.SetValue(v.Value, fsuipc);
if (ret != FsuipcSdk.Fsuipc.FSUIPC_ERR_OK)
{
_log.Log(this, string.Format("Błąd ({0}) podczas zapisywania wartości zmiennej o identyfikatorze '{1}'.", ret, v.Variable.ID));
}
vars.RemoveAt(0);
}
if (ile > 0 && (_autoFlush.State || _flush.State))
{
#if DEBUG
_log.Log(this, "FSUIPC_Process");
#endif
if (!fsuipc.FSUIPC_Process(ref ret))
{
_log.Log(this, string.Format("Błąd ({0}) podczas wysyłania wartości do symulatora.", ret));
}
_flush.Reset();
}
}
}
}
catch (ThreadAbortException)
{
}
catch (Exception ex)
{
_log.Log(this, ex.ToString());
}
finally
{
if (fsuipc != null)
{
try
{
fsuipc.FSUIPC_Close();
if (connected)
{
_log.Log(this, "Rozłączono z symulatorem '" + _configuration.Settings.FSVersion.ToString() + "'.");
}
}
catch { }
}
}
}
private void ProcessingMethod()
{
FsuipcSdk.Fsuipc fsuipc = null;
bool connected = false;
try
{
int ret = 0;
int interval = _configuration.Settings.Interval;
int fs = 0;
switch (_configuration.Settings.FSVersion)
{
case FSVersion.Dowolna:
fs = FsuipcSdk.Fsuipc.SIM_ANY;
break;
case FSVersion.FS2002:
fs = FsuipcSdk.Fsuipc.SIM_FS2K2;
break;
case FSVersion.FS2004:
fs = FsuipcSdk.Fsuipc.SIM_FS2K4;
break;
case FSVersion.FSX:
fs = FsuipcSdk.Fsuipc.SIM_FSX;
break;
default:
throw new Exception("Nieobsługiwana wersja symulatora '" + _configuration.Settings.FSVersion.ToString() + "'.");
}
_log.Log(this, "Próba połączenia z symulatorem w wersji '" + _configuration.Settings.FSVersion.ToString() + "'.");
fsuipc = new FsuipcSdk.Fsuipc();
while (_working)
{
if (fsuipc.FSUIPC_Open(fs, ref ret))
{
_log.Log(this, "Połączono z symulatorem w wersji '" + _configuration.Settings.FSVersion.ToString() + "'.");
connected = true;
break;
}
Thread.Sleep(100);
}
byte v1 = 0;
short v2 = 0;
int v4 = 0;
long v8 = 0;
object v = null;
bool ok = false;
while (_working)
{
//lock (FsuipcSdk.Fsuipc.__FSUIPC_LOCKER)
//FsuipcSdk.Fsuipc.__FSUIPC_EVENT.WaitOne();
//try
{
for (int i = 0; i < _spiesVariables.Length; i++)
{
if (!fsuipc.FSUIPC_Read(_spiesVariables[i].Offset, _spiesVariables[i].Size, ref _spiesVariables[i].Token, ref ret))
{
_log.Log(this, "Błąd (" + ret.ToString() + " podczas żądania odczytu wartości zmiennej o identyfikatorze '" + _spiesVariables[i].ID + "'.");
}
}
if (!fsuipc.FSUIPC_Process(ref ret))
{
_log.Log(this, "Błąd (" + ret.ToString() + ") podczas żądania odczytania żądanych wartości.");
}
else
{
for (int i = 0; i < _spiesVariables.Length; i++)
{
switch (_spiesVariables[i].FSType)
{
case FSDataType.Byte:
ok = fsuipc.FSUIPC_Get(ref _spiesVariables[i].Token, ref v1);
v = v1;
break;
case FSDataType.Short:
ok = fsuipc.FSUIPC_Get(ref _spiesVariables[i].Token, ref v2);
v = v2;
break;
case FSDataType.Int:
ok = fsuipc.FSUIPC_Get(ref _spiesVariables[i].Token, ref v4);
v = v4;
break;
case FSDataType.Long:
ok = fsuipc.FSUIPC_Get(ref _spiesVariables[i].Token, ref v8);
v = v8;
break;
case FSDataType.ByteArray:
byte[] buf = new byte[_spiesVariables[i].Size];
ok = fsuipc.FSUIPC_Get(ref _spiesVariables[i].Token, buf.Length, ref buf);
v = buf;
break;
}
if (ok)
{
_spiesVariables[i].SetValue(v);
}
else
{
_log.Log(this, "Błąd podczas pobierania wartości zmiennej o identyfikatorze '" + _spiesVariables[i].ID + "', Offset = 0x" + _spiesVariables[i].Offset.ToString("X4") + ".");
}
}
}
}
//finally
//{
// FsuipcSdk.Fsuipc.__FSUIPC_EVENT.Set();
//}
if (interval > 0)
{
Thread.Sleep(interval);
}
}
}
catch (ThreadAbortException)
{
}
catch (Exception ex)
{
_log.Log(this, ex.ToString());
}
finally
{
if (fsuipc != null)
{
try
{
fsuipc.FSUIPC_Close();
if (connected)
{
_log.Log(this, "Rozłączono z symulatorem '" + _configuration.Settings.FSVersion.ToString() + "'.");
}
}
catch { }
}
}
}
public abstract int SetValue(object value, FsuipcSdk.Fsuipc fsuipc);