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);
}
public static FT232HDetectorInformation Detect(string serialNumber = null)
{
var r = new FT232HDetectorInformation();
var ft232h = new FTD2XX_NET.FTDI();
UInt32 count = 0;
Ok(ft232h.GetNumberOfDevices(ref count));
if (count == 0)
{
Console.WriteLine("No FT232H device detected");
return(r);
}
FT_DEVICE_INFO_NODE ft232hDevice = null;
var devices = new FT_DEVICE_INFO_NODE[count];
ft232h.GetDeviceList(devices);
if (serialNumber == null)
{
ft232hDevice = devices[0];
}
else
{
ft232hDevice = devices.ToList().FirstOrDefault(d => d.SerialNumber == serialNumber);
}
r.SerialNumber = ft232hDevice.SerialNumber;
r.DeviceType = ft232hDevice.Type;
r.Description = ft232hDevice.Description;
if (ft232hDevice == null)
{
return(FT232HDetectorInformation.Failed);
}
Ok(ft232h.OpenBySerialNumber(ft232hDevice.SerialNumber));
var ee232h = new FT232H_EEPROM_STRUCTURE();
var rr = ft232h.ReadFT232HEEPROM(ee232h);
if (rr == FT_STATUS.FT_OK)
{
r.Description = ee232h.Description;
r.Properties = GetDictionary(ee232h);
}
ft232h.Close();
r.Ok = true;
return(r);
}
private void CloseDriver()
{
if (_driver != null)
{
#if DEBUG
Log.Log(Module, string.Format("Closing device {0} (SN: {1}): {2}", DeviceTypeName, SerialNumber, Name));
#endif
try
{
_driver.Close();
}
catch {}
_driver = null;
}
}
protected void WriteToDevice(FTD2XX_NET.FTDI driver, byte[] data)
{
uint written = 0;
if (driver.Write(data, data.Length, ref written) != FTD2XX_NET.FTDI.FT_STATUS.FT_OK || written != data.Length)
{
throw new Exception("Błąd wysyłania danych do urządzenia.");
}
#if DEBUG
List <string> tmp = new List <string>();
for (int i = 0; i < data.Length; i++)
{
tmp.Add("0x" + data[i].ToString("X2"));
}
Debug.WriteLine(string.Format("Wysłanie danych do urządzenia ({0}): {1}", this.ToString(), string.Join(" ", tmp.ToArray())));
#endif
}
private void Window_Loaded(object sender, RoutedEventArgs e)
{
//SerialPort serialPort = new SerialPort();
//string portName = serialPort.PortName = "COM10";
//FTD2XX_NET.FTDI fTDI = new FTD2XX_NET.FTDI();
//fTDI.SetBaudRate(9600);
//FTD2XX_NET.FTDI.FT_DEVICE_INFO_NODE[] test = new FTD2XX_NET.FTDI.FT_DEVICE_INFO_NODE[10];
//fTDI.GetDeviceList(test);
////FTD2XX_NET.FTDI.FT_DEVICE.FT_DEVICE_232R fT_DEVIC;
//fTDI.GetCOMPort(out portName);
//fTDI.OpenByIndex(0);
//fTDI.Rescan();
//FTD2XX.Device fTD2XX = new FTD2XX.Device(5);
//FTD2XX.DeviceNotOpenedException deviceNotOpenedException = new FTD2XX.DeviceNotOpenedException(FTD2XX.DeviceOpenPurpose.None);
//FTD2XX.DeviceNotFoundException deviceNotFoundException = new FTD2XX.DeviceNotFoundException();
////fTD2XX.Reset();
////fTD2XX.SetDataCharacteristics(FTD2XX.BitsPerWord.Seven, FTD2XX.StopBits.One, FTD2XX.Parity.None);
////var x = FTD2XX.Device.GetDevices();
////var y = FTD2XX.DeviceOperation.Read;
////var z = FTD2XX.DeviceOpenPurpose.Write;
//byte[] arr = new byte[10];
//fTD2XX.Open();
//fTD2XX.Flush();
//FTD2XX_NET.FTDI eject = new FTD2XX_NET.FTDI();
//eject.SetBaudRate(9600);
//eject.SetBreak(true);
//eject.SetDataCharacteristics(7, 0, 1);
//eject.SetDeadmanTimeout(1);
//eject.SetBitMode(1, 1);
//eject.SetRTS(true);
//eject.OpenByIndex(0);
//eject.RestartInTask();
//eject.ResetDevice();
//eject.Purge(0);
//eject.Reload(0, 0);
//eject.SetTimeouts(1, 1);
//FTD2XX_NET.FTDI.FT232B_EEPROM_STRUCTURE eeX = new FTD2XX_NET.FTDI.FT232B_EEPROM_STRUCTURE(); //bizim device bu
//eeX.Description = "1";
//eeX.Manufacturer = "1";
//eeX.ManufacturerID = "1";
//eeX.MaxPower = 1;
//eeX.ProductID = 0;
//eeX.PullDownEnable = true;
//eeX.RemoteWakeup = true;
//eeX.SelfPowered = true;
//eeX.SerialNumber = "1";
//eeX.SerNumEnable = false;
//eeX.USBVersion = 0x0200;
//eeX.USBVersionEnable = true;
//eeX.VendorID = 1;
//eject.ReadFT232BEEPROM(eeX);
//eject.WriteFT232BEEPROM(eeX);
FTD2XX_NET.FTDI eject = new FTD2XX_NET.FTDI();
//eject.SetBaudRate(9600);
//eject.SetDeadmanTimeout(5000);
//eject.InTransferSize(0x1000);
//eject.SetLatency(16);
//FTD2XX_NET.FTDI.FT_DEVICE_INFO_NODE[] deviceList = new FTD2XX_NET.FTDI.FT_DEVICE_INFO_NODE[5];
//eject.GetDeviceList(deviceList);
//FTD2XX_NET.FTDI.FT_EXCEPTION exeption = new FTD2XX_NET.FTDI.FT_EXCEPTION();
//FTD2XX_NET.FTDI.FT_EVENTS events = new FTD2XX_NET.FTDI.FT_EVENTS();
//FTD2XX_NET.FTDI.FT_DRIVE_CURRENT ftDrive = new FTD2XX_NET.FTDI.FT_DRIVE_CURRENT();
//FTD2XX_NET.FTDI.FT_EEPROM_DATA epromData = new FTD2XX_NET.FTDI.FT_EEPROM_DATA();
//FTD2XX_NET.FTDI.FT_FLOW_CONTROL control = new FTD2XX_NET.FTDI.FT_FLOW_CONTROL();
//FTD2XX_NET.FTDI.FT_XSERIES_CBUS_OPTIONS options = new FTD2XX_NET.FTDI.FT_XSERIES_CBUS_OPTIONS();
//FTD2XX_NET.FTDI.FT_FLAGS flags = new FTD2XX_NET.FTDI.FT_FLAGS();
//FTD2XX_NET.FTDI.FT232B_EEPROM_STRUCTURE deviceStructure = new FTD2XX_NET.FTDI.FT232B_EEPROM_STRUCTURE();
//FTD2XX_NET.FTDI.FT_PURGE purge = new FTD2XX_NET.FTDI.FT_PURGE();
var ftDeger = eject.OpenByIndex(0);
if (ftDeger == FTD2XX_NET.FTDI.FT_STATUS.FT_OK)
{
eject.CyclePort();
}
}
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);
}
