int speed = 60; //szybkosc przesylania
public void rote(int skoki, byte[] buff)
{
int loops = (degree * 10) / 50 * skoki; //7.5 stopnia na skok //jezeli półkrokowe do 2*50 -> 360/7.5=50
int steps = 4 * skoki; //wysokie na wyjsciu RS232 potrzebne do wykonania obrotu, w przypadku krokowego przesylane jest 4 a polkrokowego przesylanie jest 8 sygnalow
Int32 bytesToWrite = 1;
UInt32 bytesWritten = 0;
byte[][] controlByte = new byte[steps][];
for (int i = 0; i < steps; i++)
{
controlByte[i] = new byte[] { buff[i] }
}
;
for (int k = 0, i = steps - 1; k < loops; k++)
{
ftstatus = device.Write(controlByte[i], bytesToWrite, ref bytesWritten); //przesłanie odpowiedniej kombinacji bitowej do sterownika
System.Threading.Thread.Sleep(1000 / speed);
if (i == 0)
{
i = steps - 1;
}
else
{
i--;
}
}
ftstatus = device.Write(stop, 1, ref bytesWritten); //zaprzestanie wysylania stanów wysokich do silnika krokowego
}
public int Write(byte[] bytes)
{
uint written = 0;
status = this.ftdiPort.Write(bytes, (uint)bytes.Length, ref written);
return((int)written);
}
public byte ReadByte()
{
byte[] buf = new byte[1];
uint read = 0;
status = this.ftdiPort.Read(buf, 1, ref read);
return(buf[0]);
}
private void koniec()
{
byte[] zero = { 0x00 };
Int32 bytesToWrite = 1;
UInt32 bytesWritten = 0;
ftstatus = device.Write(zero, bytesToWrite, ref bytesWritten);
}
protected FtdiMpsseI2CResult CheckResult(FTD2XX_NET.FTDI.FT_STATUS status)
{
if (status != FTD2XX_NET.FTDI.FT_STATUS.FT_OK)
{
throw new I2CNotConnectedException(Convert(status));
}
return(FtdiMpsseI2CResult.Ok);
}
public uint[] getListLocIdPlacas()
{
FTD2XX_NET.FTDI.FT_STATUS ftStatus = FTDI.FT_STATUS.FT_OK;
uint ftdiDeviceCount = 0;
FTDI acesso = new FTDI();
acesso.GetNumberOfDevices(ref ftdiDeviceCount);
FTDI.FT_DEVICE_INFO_NODE[] infos = new FTDI.FT_DEVICE_INFO_NODE[ftdiDeviceCount];
acesso.GetDeviceList(infos);
uint[] placas = new uint[ftdiDeviceCount];
for (int c = 0; c < infos.Length; c++)
{
placas[c] = infos[c].LocId;
executaComando(infos[c].LocId, Tipos.Inicia, Codigos.Inicia);
}
return(placas);
}
public void Connect()
{
ftstatus = device.GetDeviceList(devicelist);
try
{
//sprawdzenie czy urzadzenie zostalo podlaczone
ftstatus = device.OpenByDescription(devicelist[0].Description);
ftstatus = device.SetBitMode(0xff, 1); //pozwala na przesylanie danych do ukladu
Console.WriteLine("Status: " + ftstatus.ToString());
}
catch (Exception e)
{
Console.WriteLine("Urzadzenie nie zostao podlaczone!\nNacisnij [ENTER] aby zamknac program");
Console.ReadLine();
Environment.Exit(0);
}
}
public bool OpenAny(uint baudRate = 38400)
{
try
{
this.ftdiPort = new FTD2XX_NET.FTDI();
uint count = 0;
this.status = this.ftdiPort.GetNumberOfDevices(ref count);
if (count == 1)
{
status = this.ftdiPort.OpenByIndex(0);
status = this.ftdiPort.SetBaudRate(baudRate);
return(true);
}
}
catch
{
return(false);
}
return(false);
}
protected void Write(byte [] data)
{
if (_working && _driver != null && _driver.IsOpen)
{
try
{
uint written = 0;
FTD2XX_NET.FTDI.FT_STATUS status = _driver.Write(data, data.Length, ref written);
if (status != FTD2XX_NET.FTDI.FT_STATUS.FT_OK)
{
throw new Exception(string.Format("Device returned status: {0}.", status));
}
if (data.Length != written)
{
throw new Exception(string.Format("Wrong number of written bytes, {0} <> {1}.", data.Length, written));
}
#if DEBUG
string s = "";
for (int i = 0; i < data.Length; i++)
{
s += "0x" + data[i].ToString("X2") + " ";
}
string t = string.Format("Wysłano dane do '{0}': {1}", DeviceTypeName, s);
if (Log != null)
{
Log.Log(Module, t);
}
else
{
Debug.WriteLine(t);
}
#endif
}
catch (Exception ex)
{
Log.Log(Module, ex.ToString());
}
}
}
private void enablebtn_Click(object sender, EventArgs e)
{
try
{
UInt32 ftdiDeviceCount = 0;
device.GetNumberOfDevices(ref ftdiDeviceCount);
FTD2XX_NET.FTDI.FT_DEVICE_INFO_NODE[] devicelist = new FTD2XX_NET.FTDI.FT_DEVICE_INFO_NODE[ftdiDeviceCount];
device.GetDeviceList(devicelist);
ftstatus = device.OpenBySerialNumber(devicelist[0].SerialNumber);
ftstatus = device.SetBitMode(0xff, 1);
Console.WriteLine("Urzadzenie: " + ftstatus.ToString());
stepLeftbtn.Enabled = true;
stepRightbtn.Enabled = true;
}
catch (Exception ee)
{
Console.WriteLine("Urzadzenie nie zostalo podlaczone!\nNacisnij [ENTER] aby zamknac program");
Console.ReadLine();
Environment.Exit(0);
}
}
public void executaComando(uint location, int tp, byte idRele)
{
FTDI acesso = new FTDI();
FTD2XX_NET.FTDI.FT_STATUS ftStatus = FTDI.FT_STATUS.FT_OK;
ftStatus = acesso.OpenByLocation(location);
if (tp == Tipos.Inicia || tp == Tipos.Finaliza)
{
saida = idRele;
}
else if (tp == Tipos.Liga)
{
saida = (byte)(saida | idRele);
}
else
{
saida = (byte)(saida & idRele);
}
ftStatus = acesso.SetBitMode(saida, FTDI.FT_BIT_MODES.FT_BIT_MODE_CBUS_BITBANG);
ftStatus = acesso.Close();
}
private void Polacz()
{
ftstatus = device.GetDeviceList(devicelist);
ftstatus = device.OpenByDescription(devicelist[0].Description);
ftstatus = device.SetBitMode(0xff, 1);
}
private void disablebtn_Click(object sender, EventArgs e)
{
stepLeftbtn.Enabled = false;
stepRightbtn.Enabled = false;
ftstatus = device.Close();
}
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);
}
private void WorkingThread()
{
try
{
// opóźnienie startu
Thread.Sleep(3000);
// skasowanie listy urządzeń
Globals.Instance.ClearDevices();
List <string> serialNumbers = new List <string>();
FTDI.FT_STATUS result = FTDI.FT_STATUS.FT_OK;
FTDI ftdi = new FTDI();
while (!_stop)
{
// łączenie z FSUIPC
if (!FS.FSUIPC.FS.IsConnected)
{
FS.FSUIPC.FS.Connect();
}
uint devCount = 0;
try
{
result = ftdi.GetNumberOfDevices(ref devCount);
}
catch { }
if (result == FTDI.FT_STATUS.FT_OK)
{
FTDI.FT_DEVICE_INFO_NODE[] deviceList = new FTDI.FT_DEVICE_INFO_NODE[devCount];
if (devCount > 0)
{
try
{
result = ftdi.GetDeviceList(deviceList);
}
catch (Exception)
{
}
}
else
{
result = FTDI.FT_STATUS.FT_OK;
}
if (result == FTDI.FT_STATUS.FT_OK)
{
// usunięcie urządzeń niepodpiętych
Device[] _devices = Globals.Instance.Devices;
{
int index = _devices.Length;
while (index-- > 0)
{
Device device = _devices[index];
if (device.SerialNumber != "FAKE" && Array.Find <FTDI.FT_DEVICE_INFO_NODE>(deviceList, delegate(FTDI.FT_DEVICE_INFO_NODE o)
{
return(o.SerialNumber == device.SerialNumber);
}) == null)
{
Globals.Instance.RemoveDevice(_devices[index]);
serialNumbers.Remove(device.SerialNumber);
device.TurnOff();
}
}
}
for (int i = 0; i < deviceList.Length; i++)
{
if (deviceList[i].Type == FTDI.FT_DEVICE.FT_DEVICE_232R)
{
string sn = deviceList[i].SerialNumber;
if (!serialNumbers.Contains(sn))
{
serialNumbers.Add(sn);
// otwarcie połączenia z urządzeniem
FTD2XX_NET.FTDI driver = new FTDI();
FTD2XX_NET.FTDI.FT_STATUS status = driver.OpenBySerialNumber(sn);
if (status != FTD2XX_NET.FTDI.FT_STATUS.FT_OK)
{
driver.Close();
driver = null;
continue;
}
// odczytanie EEPROM
FTD2XX_NET.FTDI.FT232R_EEPROM_STRUCTURE eeprom = new FTD2XX_NET.FTDI.FT232R_EEPROM_STRUCTURE();
status = driver.ReadFT232REEPROM(eeprom);
if (status != FTD2XX_NET.FTDI.FT_STATUS.FT_OK)
{
driver.Close();
driver = null;
continue;
}
// odczytanie producenta "simPROJECT"
if (eeprom.Manufacturer.ToUpperInvariant() != "SIMPROJECT")
{
driver.Close();
driver = null;
continue;
}
driver.Close();
driver = null;
Device device = DeviceFactory.CreateDevice(deviceList[i]);
if (device != null)
{
Globals.Instance.AddDevice(device);
device.SetPlane(Globals.Instance.CurrentPlane);
device.TurnOn();
}
}
}
}
}
}
Thread.Sleep(3000);
}
}
catch (ThreadAbortException)
{
}
catch (Exception ex)
{
Debug.WriteLine(string.Format("Błąd w wątku śledzącym urządzenia: {0}", ex));
}
finally
{
}
}
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();
}
}
public void funkcja()
{
//TODO
// Pytanie o okres
Polacz();
Console.WriteLine("Polaczono!");
Console.WriteLine("Wybierz tryb sterowania\n\t1 - jednofazowe\n\t2 - dwufazowe\n");
string linijka = Console.ReadLine();
int pom = int.Parse(linijka);
if (pom == 1)
{
control = sterowanie.Jednofazowe;
}
else if (pom == 2)
{
control = sterowanie.Dwufazowe;
}
Console.WriteLine("\t1 - kroki\n\t2 - kat\n");
linijka = Console.ReadLine();
int pom5 = int.Parse(linijka);
int loops = 0;
if (pom5 == 1)
{
Console.WriteLine("Ile krokow?");
linijka = Console.ReadLine();
int pom6 = int.Parse(linijka);
loops = pom6;
}
else
{
Console.WriteLine("jaki kat?");
linijka = Console.ReadLine();
int pom7 = int.Parse(linijka);
pom7 = przelicz(pom7);
loops = pom7;
}
// Ile krokow
Console.WriteLine("Ile czekac?");
linijka = Console.ReadLine();
int pom4 = int.Parse(linijka);
int okres = pom4;
int steps = 4;
switch (control)
{
case sterowanie.Jednofazowe:
{
Console.WriteLine("Ktora strona?\n\t1 - prawa\n\t2 - lewa\n");
linijka = Console.ReadLine();
int pom3 = int.Parse(linijka);
switch (pom3)
{
case 1:
{
byte[][] controlByte = new byte[steps][];
for (int i = 0; i < steps; i++)
{
controlByte[i] = new byte[] { dwufazowe[i] }
}
;
for (int k = 0, i = steps - 1; k < loops; k++)
{
Int32 bytesToWrite = 1;
UInt32 bytesWritten = 0;
ftstatus = device.Write(controlByte[i], bytesToWrite, ref bytesWritten);
System.Threading.Thread.Sleep(okres);
if (i == 0)
{
i = steps - 1;
}
else
{
i--;
}
}
koniec();
break;
}
case 2:
{
byte[][] controlByte = new byte[steps][];
for (int i = 0; i < steps; i++)
{
controlByte[i] = new byte[] { jednofazowe[i] }
}
;
for (int k = 0, i = 0; k < loops; k++)
{
Int32 bytesToWrite = 1;
UInt32 bytesWritten = 0;
ftstatus = device.Write(controlByte[i], bytesToWrite, ref bytesWritten);
System.Threading.Thread.Sleep(okres);
if (i == steps - 1)
{
i = 0;
}
else
{
i++;
}
}
koniec();
break;
}
}
koniec();
break;
}
case sterowanie.Dwufazowe:
{
Console.WriteLine("Ktora strona?\n\t1 - prawa\n\t2 - lewa\n");
linijka = Console.ReadLine();
int pom3 = int.Parse(linijka);
switch (pom3)
{
case 1:
{
byte[][] controlByte = new byte[steps][];
for (int i = 0; i < steps; i++)
{
controlByte[i] = new byte[] { dwufazowe[i] }
}
;
for (int k = 0, i = steps - 1; k < loops; k++)
{
Int32 bytesToWrite = 1;
UInt32 bytesWritten = 0;
ftstatus = device.Write(controlByte[i], bytesToWrite, ref bytesWritten);
System.Threading.Thread.Sleep(okres);
if (i == 0)
{
i = steps - 1;
}
else
{
i--;
}
}
koniec();
break;
}
case 2:
{
byte[][] controlByte = new byte[steps][];
for (int i = 0; i < steps; i++)
{
controlByte[i] = new byte[] { dwufazowe[i] }
}
;
for (int k = 0, i = 0; k < loops; k++)
{
Int32 bytesToWrite = 1;
UInt32 bytesWritten = 0;
ftstatus = device.Write(controlByte[i], bytesToWrite, ref bytesWritten);
System.Threading.Thread.Sleep(okres);
if (i == steps - 1)
{
i = 0;
}
else
{
i++;
}
}
koniec();
break;
}
}
koniec();
break;
}
}
}
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);
}
