private byte?ReadBlocking()
{
uint rxWaiting = 0;
while (_looping)
{
rxWaiting = 0;
var status = _device.GetRxBytesAvailable(ref rxWaiting);
if (rxWaiting == 0 || status != FTD2XX_NET.FTDI.FT_STATUS.FT_OK)
{
Thread.Sleep(10);
continue;
}
break;
}
if (!_looping)
{
return(null);
}
uint readBytes = 0;
var bytes = new byte[1]; //this is based on reversed-code of CanToUsb.ocx, I may implement more efficient method later
var readStatus = _device.Read(bytes, 1, ref readBytes);
if (readBytes == 0 || readStatus != FTD2XX_NET.FTDI.FT_STATUS.FT_OK)
{
throw new InvalidOperationException("failed to read data");
}
return(bytes[0]);
}
protected bool ReadKeysState(FTD2XX_NET.FTDI driver, ref byte[] keys)
{
bool result = false;
uint available = 0;
byte[] data = new byte[3];
while (driver.GetRxBytesAvailable(ref available) == FTD2XX_NET.FTDI.FT_STATUS.FT_OK && available > 2)
{
uint red = 0;
if (driver.Read(data, 3, ref red) == FTD2XX_NET.FTDI.FT_STATUS.FT_OK && red == 3)
{
int type = (data[1] >> 4) & 0x0f;
int index = data[1] & 0x0f;
if (type == 1 && index < keys.Length)
{
keys[index] = data[2];
result = true;
}
#if DEBUG
Debug.WriteLine(string.Format("Odebrano dane z urządzenia ({0}): 0x{1} 0x{2} 0x{3}", this.ToString(), data[0].ToString("X2"), data[1].ToString("X2"), data[2].ToString("X2")));
#endif
}
}
return(result);
}
protected virtual void Process()
{
try
{
_driver = new FTD2XX_NET.FTDI();
// próba otwarcia urządzenia
FTD2XX_NET.FTDI.FT_STATUS status = _driver.OpenBySerialNumber(SerialNumber);
if (status != FTD2XX_NET.FTDI.FT_STATUS.FT_OK)
{
Log.Log(Module, string.Format("Cannot connect to device '{0}', SN: {1}.", Name, SerialNumber));
return;
}
// ustawienie parametrów komunikacji
status = _driver.SetBaudRate(_baudRate);
if (status != FTD2XX_NET.FTDI.FT_STATUS.FT_OK)
{
Log.Log(Module, string.Format("Cannot setup device '{0}', SN: {1}.", Name, SerialNumber));
return;
}
status = _driver.SetDataCharacteristics(FTD2XX_NET.FTDI.FT_DATA_BITS.FT_BITS_8, FTD2XX_NET.FTDI.FT_STOP_BITS.FT_STOP_BITS_1, FTD2XX_NET.FTDI.FT_PARITY.FT_PARITY_NONE);
if (status != FTD2XX_NET.FTDI.FT_STATUS.FT_OK)
{
Log.Log(Module, string.Format("Cannot setup device '{0}', SN: {1}.", Name, SerialNumber));
return;
}
status = _driver.SetFlowControl(FTD2XX_NET.FTDI.FT_FLOW_CONTROL.FT_FLOW_RTS_CTS, 0, 0);
if (status != FTD2XX_NET.FTDI.FT_STATUS.FT_OK)
{
Log.Log(Module, string.Format("Cannot setup device '{0}', SN: {1}.", Name, SerialNumber));
return;
}
if (_sendResetSequence)
{
// Reset communication state machine
Write(new byte[7] {
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
});
}
// wyczyszczenie urządzenia
ClearDevice();
// w pętli odbieranie danych
uint red = 0;
AutoResetEvent ev = new AutoResetEvent(false);
_driver.SetEventNotification(FTD2XX_NET.FTDI.FT_EVENTS.FT_EVENT_RXCHAR, ev);
while (_working)
{
status = _driver.GetRxBytesAvailable(ref red);
if (status != FTD2XX_NET.FTDI.FT_STATUS.FT_OK)
{
throw new Exception(string.Format("Getting number of available data returned status: '{0}', device '{1}', SN: {2}.", status, Name, SerialNumber));
}
if (red > 0)
{
byte [] data = new byte[red];
uint red2 = 0;
status = _driver.Read(data, red, ref red2);
if (status != FTD2XX_NET.FTDI.FT_STATUS.FT_OK)
{
throw new Exception(string.Format("Reading data number from device returned status: '{0}', device '{1}', SN: {2}.", status, Name, SerialNumber));
}
#if DEBUG
string s = "";
for (int i = 0; i < data.Length; i++)
{
s += "0x" + data[i].ToString("X2") + " ";
}
string t = string.Format("Odebrano dane '{0}': {1}", DeviceTypeName, s);
if (Log != null)
{
Log.Log(Module, t);
}
else
{
Debug.WriteLine(t);
}
#endif
if (_specialProcess)
{
ProcessData(data, _inputsByCode);
}
else
{
for (int i = 0; i < red2; i++)
{
int d = data[i];
// pominięcie potwierdzeń
if ((d & 0x80) == 0x00)
{
int code = d & 0x3f;
Input input = null;
if (_inputsByCode.TryGetValue(code, out input))
{
input.SetState((d & 0x40) == 0x00);
}
else
{
Log.Log(Module, string.Format("Unknown data '0x{0}' from device '{1}', SN: {2}.", d.ToString("X2"), Name, SerialNumber));
}
}
}
}
}
//Thread.Sleep(1);
ev.WaitOne(10, false);
}
}
catch (ThreadAbortException)
{
}
catch (Exception ex)
{
Log.Log(Module, ex.ToString());
}
finally
{
try
{
_working = true;
ClearDevice();
}
finally
{
_working = false;
}
CloseDriver();
}
}
protected FTD2XX_NET.FTDI OpenDevice(bool resetCommunication)
{
FTD2XX_NET.FTDI result = new FTD2XX_NET.FTDI();
if (result.OpenBySerialNumber(SerialNumber) == FTD2XX_NET.FTDI.FT_STATUS.FT_OK)
{
Debug.WriteLine(string.Format("Otwarto połączenie z urządzeniem: {0}", this));
if (result.ResetDevice() != FTD2XX_NET.FTDI.FT_STATUS.FT_OK)
{
result.Close();
result = null;
return(null);
}
// ustawienie parametrów połączenia
if (result.SetBaudRate(56700) != FTD2XX_NET.FTDI.FT_STATUS.FT_OK)
{
result.Close();
result = null;
return(null);
}
if (result.SetDataCharacteristics(8, 2, 0) != FTD2XX_NET.FTDI.FT_STATUS.FT_OK)
{
result.Close();
result = null;
return(null);
}
if (result.SetFlowControl(FTD2XX_NET.FTDI.FT_FLOW_CONTROL.FT_FLOW_NONE, 0, 0) != FTD2XX_NET.FTDI.FT_STATUS.FT_OK)
{
result.Close();
result = null;
return(null);
}
if (resetCommunication)
{
Debug.WriteLine(string.Format("Resetowanie urządzenia: {0}", this));
uint available = 0;
uint red = 0;
uint written = 0;
// wysłanie resetu
FTD2XX_NET.FTDI.FT_STATUS ret = result.GetRxBytesAvailable(ref available);
red = 0;
if (ret != FTD2XX_NET.FTDI.FT_STATUS.FT_OK)
{
result.Close();
result = null;
return(null);
}
if (available > 0)
{
byte[] tmp = new byte[available];
ret = result.Read(tmp, (uint)tmp.Length, ref red);
if (ret != FTD2XX_NET.FTDI.FT_STATUS.FT_OK)
{
result.Close();
result = null;
return(null);
}
}
available = 0;
int tries = 16;
while (available < 3 && tries-- > 0)
{
ret = result.Write(new byte[] { 254 }, 1, ref written);
if (ret != FTD2XX_NET.FTDI.FT_STATUS.FT_OK || written != 1)
{
result.Close();
result = null;
return(null);
}
Thread.Sleep(20);
ret = result.GetRxBytesAvailable(ref available);
red = 0;
if (ret != FTD2XX_NET.FTDI.FT_STATUS.FT_OK)
{
result.Close();
result = null;
return(null);
}
}
if (available < 3)
{
result.Close();
result = null;
return(null);
}
if ((available % 3) != 0)
{
Thread.Sleep(20);
ret = result.GetRxBytesAvailable(ref available);
red = 0;
if (ret != FTD2XX_NET.FTDI.FT_STATUS.FT_OK)
{
result.Close();
result = null;
return(null);
}
}
byte[] tmp3 = new byte[available];
ret = result.Read(tmp3, (uint)tmp3.Length, ref red);
if (ret != FTD2XX_NET.FTDI.FT_STATUS.FT_OK)
{
result.Close();
result = null;
return(null);
}
}
return(result);
}
return(null);
}
public static bool CheckDevice(FTD2XX_NET.FTDI.FT_DEVICE_INFO_NODE deviceInfo, DeviceType deviceType, bool resetCommunication)
{
FTD2XX_NET.FTDI driver = null;
try
{
// połączenie z urządzeniem
driver = new FTD2XX_NET.FTDI();
FTD2XX_NET.FTDI.FT_STATUS ret = driver.OpenByLocation(deviceInfo.LocId);
if (ret == FTD2XX_NET.FTDI.FT_STATUS.FT_OK)
{
ret = driver.ResetDevice();
//ret = driver.ResetPort();
ret = driver.SetBaudRate(56700);
ret = driver.SetDataCharacteristics(8, 2, 0);
ret = driver.SetFlowControl(FTD2XX_NET.FTDI.FT_FLOW_CONTROL.FT_FLOW_NONE, 0, 0);
uint available = 0;
uint red = 0;
uint written = 0;
// resetowanie urządzenia
if (resetCommunication)
{
// wysłanie resetu
ret = driver.GetRxBytesAvailable(ref available);
red = 0;
if (ret != FTD2XX_NET.FTDI.FT_STATUS.FT_OK)
{
driver.Close();
driver = null;
return(false);
}
if (available > 0)
{
byte[] tmp = new byte[available];
ret = driver.Read(tmp, (uint)tmp.Length, ref red);
if (ret != FTD2XX_NET.FTDI.FT_STATUS.FT_OK)
{
driver.Close();
driver = null;
return(false);
}
}
available = 0;
int tries = 16;
while (available < 3 && tries-- > 0)
{
ret = driver.Write(new byte[] { 254 }, 1, ref written);
if (ret != FTD2XX_NET.FTDI.FT_STATUS.FT_OK || written != 1)
{
driver.Close();
driver = null;
return(false);
}
Thread.Sleep(20);
ret = driver.GetRxBytesAvailable(ref available);
red = 0;
if (ret != FTD2XX_NET.FTDI.FT_STATUS.FT_OK)
{
driver.Close();
driver = null;
return(false);
}
}
if (available < 3)
{
driver.Close();
driver = null;
return(false);
}
if ((available % 3) != 0)
{
Thread.Sleep(20);
ret = driver.GetRxBytesAvailable(ref available);
red = 0;
if (ret != FTD2XX_NET.FTDI.FT_STATUS.FT_OK)
{
driver.Close();
driver = null;
return(false);
}
}
byte[] tmp3 = new byte[available];
ret = driver.Read(tmp3, (uint)tmp3.Length, ref red);
if (ret != FTD2XX_NET.FTDI.FT_STATUS.FT_OK)
{
driver.Close();
driver = null;
return(false);
}
}
// wysłanie rozkazu ciszy
byte[] data = new byte[3] {
255, 1, 204
};
written = 0;
ret = driver.Write(data, data.Length, ref written);
if (ret != FTD2XX_NET.FTDI.FT_STATUS.FT_OK)
{
return(false);
}
// odczytanie wszystkich danych
available = 0;
ret = driver.GetRxBytesAvailable(ref available);
red = 0;
if (ret != FTD2XX_NET.FTDI.FT_STATUS.FT_OK)
{
return(false);
}
if (available > 0)
{
byte[] tmp = new byte[available];
ret = driver.Read(tmp, (uint)tmp.Length, ref red);
if (ret != FTD2XX_NET.FTDI.FT_STATUS.FT_OK)
{
return(false);
}
}
// wysłanie zapytania o typ urządzenia
data = new byte[3] {
255, 1, 202
};
written = 0;
ret = driver.Write(data, data.Length, ref written);
if (ret == FTD2XX_NET.FTDI.FT_STATUS.FT_OK)
{
int count = 0;
while (count++ < 5)
{
Thread.Sleep(50);
ret = driver.GetRxBytesAvailable(ref available);
if (ret == FTD2XX_NET.FTDI.FT_STATUS.FT_OK && available > 2)
{
// odczytanie danych
data[0] = data[1] = data[2] = 0;
ret = driver.Read(data, (uint)data.Length, ref red);
if (ret == FTD2XX_NET.FTDI.FT_STATUS.FT_OK && red == data.Length)
{
// sprawdzenie czy jest to raport o typie urządzenia i czy typ zgadza się z przekazanym typem
if (data[0] == 2)
{
byte tmp = (byte)(data[1] & 0x0f);
return(tmp == (byte)deviceType);
}
}
}
}
}
}
}
catch { }
finally
{
if (driver != null && driver.IsOpen)
{
try
{
driver.Close();
}
catch { }
}
}
return(false);
}
