static void Main(string[] args)
{
UI Menu = new UI();
Menu.StartPage();
Menu.UserToSave(myFile);
UInt32 ftdiDeviceCount = 0;
FTDI.FT_STATUS ftStatus = FTDI.FT_STATUS.FT_OK;
// Create new instance of the FTDI device class
FTDI myFtdiDevice = new FTDI();
// Determine the number of FTDI devices connected to the machine
ftStatus = myFtdiDevice.GetNumberOfDevices(ref ftdiDeviceCount);
// Check status
if (ftStatus == FTDI.FT_STATUS.FT_OK)
{
Console.WriteLine("\nNumber of FTDI devices: " + ftdiDeviceCount.ToString());
Console.WriteLine("");
}
else
{
// Wait for a key press
Console.WriteLine("Failed to get number of devices (error " + ftStatus.ToString() + ")");
Console.ReadKey();
return;
}
// If no devices available, return
if (ftdiDeviceCount == 0)
{
// Wait for a key press
Console.WriteLine("Failed to get number of devices (error " + ftStatus.ToString() + ")");
Console.ReadKey();
return;
}
// Allocate storage for device info list
FTDI.FT_DEVICE_INFO_NODE[] ftdiDeviceList = new FTDI.FT_DEVICE_INFO_NODE[ftdiDeviceCount];
// Populate our device list
ftStatus = myFtdiDevice.GetDeviceList(ftdiDeviceList);
if (ftStatus == FTDI.FT_STATUS.FT_OK)
{
for (UInt32 i = 0; i < ftdiDeviceCount; i++)
{
Console.WriteLine("Device Index: " + i.ToString());
Console.WriteLine("Flags: " + String.Format("{0:x}", ftdiDeviceList[i].Flags));
Console.WriteLine("Type: " + ftdiDeviceList[i].Type.ToString());
Console.WriteLine("ID: " + String.Format("{0:x}", ftdiDeviceList[i].ID));
Console.WriteLine("Location ID: " + String.Format("{0:x}", ftdiDeviceList[i].LocId));
Console.WriteLine("Serial Number: " + ftdiDeviceList[i].SerialNumber.ToString());
Console.WriteLine("Description: " + ftdiDeviceList[i].Description.ToString());
Console.WriteLine("");
}
}
//Check which ftdi adapter to use
int inDevice = 0;
if (ftdiDeviceCount > 1)
{
Console.WriteLine("Input device index to use: ");
inDevice = (int)Console.ReadKey(true).KeyChar - '0';
}
// Open user selected device in our list by serial number(if only one device use first device in list)
ftStatus = myFtdiDevice.OpenBySerialNumber(ftdiDeviceList[inDevice].SerialNumber);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
// Wait for a key press
Console.WriteLine("Failed to open device (error " + ftStatus.ToString() + ")");
Console.ReadKey();
return;
}
// Set up device data parameters
// Set the Baud rate
Console.WriteLine("Baudrate: ");
UInt32 baud = UInt32.Parse(Console.ReadLine());
ftStatus = myFtdiDevice.SetBaudRate(baud);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
// Wait for a key press
Console.WriteLine("Failed to set Baud rate (error " + ftStatus.ToString() + ")");
Console.ReadKey();
return;
}
// Set data characteristics - Data bits, Stop bits, Parity
ftStatus = myFtdiDevice.SetDataCharacteristics(FTDI.FT_DATA_BITS.FT_BITS_8, FTDI.FT_STOP_BITS.FT_STOP_BITS_1, FTDI.FT_PARITY.FT_PARITY_NONE);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
// Wait for a key press
Console.WriteLine("Failed to set data characteristics (error " + ftStatus.ToString() + ")");
Console.ReadKey();
return;
}
// Set flow control - set RTS/CTS flow control
ftStatus = myFtdiDevice.SetFlowControl(FTDI.FT_FLOW_CONTROL.FT_FLOW_NONE, 0, 0);
//ftStatus = myFtdiDevice.SetFlowControl(FTDI.FT_FLOW_CONTROL.FT_FLOW_RTS_CTS, 0x11, 0x13);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
// Wait for a key press
Console.WriteLine("Failed to set flow control (error " + ftStatus.ToString() + ")");
Console.ReadKey();
return;
}
// Set read timeout to 5 seconds, write timeout to infinite
ftStatus = myFtdiDevice.SetTimeouts(5000, 0);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
// Wait for a key press
Console.WriteLine("Failed to set timeouts (error " + ftStatus.ToString() + ")");
Console.ReadKey();
return;
}
/*
* // Perform loop back - make sure loop back connector is fitted to the device
* // Write string data to the device
* string dataToWrite = "Hello world!";
* UInt32 numBytesWritten = 0;
* // Note that the Write method is overloaded, so can write string or byte array data
* ftStatus = myFtdiDevice.Write(dataToWrite, dataToWrite.Length, ref numBytesWritten);
* if (ftStatus != FTDI.FT_STATUS.FT_OK)
* {
* // Wait for a key press
* Console.WriteLine("Failed to write to device (error " + ftStatus.ToString() + ")");
* Console.ReadKey();
* return;
* }
*/
// Check the amount of data available to read
// In this case we know how much data we are expecting,
// so wait until we have all of the bytes we have sent.
do
{
while (!Console.KeyAvailable)
{
UInt32 numBytesAvailable = 0;
// do
// {
ftStatus = myFtdiDevice.GetRxBytesAvailable(ref numBytesAvailable);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
// Wait for a key press
Console.WriteLine("Failed to get number of bytes available to read (error " + ftStatus.ToString() + ")");
Console.ReadKey();
return;
}
//} while (numBytesAvailable < dataToWrite.Length);
// Now that we have the amount of data we want available, read it
string readData;
UInt32 numBytesRead = 0;
// Note that the Read method is overloaded, so can read string or byte array data
ftStatus = myFtdiDevice.Read(out readData, numBytesAvailable, ref numBytesRead);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
// Wait for a key press
Console.WriteLine("Failed to read data (error " + ftStatus.ToString() + ")");
Console.ReadKey();
return;
}
//Console.Write(readData);
// Format our data for diffent hardware inputs
/***Richards Hardware***/
int[] iData = null;
RichFormatInput(readData, iData);
/***Ben's Hardware***/
/*
* BenFormatInput(readData);
* Thread.Sleep(5);
*/
if (Menu.BSave)
{
//dirty check for null data TODO: add clean exception handler
if (iData != null)
{
myFile.SaveToFile(iData);
Console.WriteLine("Saved %hi Bytes to %s ", iData.Length, myFile.FilePath);
}
}
}
} while (Console.ReadKey().Key != ConsoleKey.Escape);
// Close our device connection
ftStatus = myFtdiDevice.Close();
// Wait for a key press
Console.WriteLine("Press any key to exit.");
Console.ReadKey();
return;
}
static void Main2(string[] args)
{
System.Diagnostics.Stopwatch sw2 = new System.Diagnostics.Stopwatch();
// device identification from the FTDI chip's EEPROM
// as reported by FTPROG utility
// note: DO NOT use FTPROG to write to Digilent devices, it will overwrite the license key for Xilinx tools
string devSearchString = "DIGILENT ADEPT USB DEVICE A"; // CMOD A7
// string devSearchString = "DIGILENT USB DEVICE A"; // other devices may use this description
// === identify suitable FTDI device ===
print("Enumerating FTDI devices..."); sw2.Reset(); sw2.Start();
FTDI myFtdiDevice = new FTDI();
UInt32 n = 0;
FTDI.FT_STATUS s = myFtdiDevice.GetNumberOfDevices(ref n); chk(s);
if (n == 0)
{
throw new Exception("no FTDI devices");
}
FTDI.FT_DEVICE_INFO_NODE[] ftdiDeviceList = new FTDI.FT_DEVICE_INFO_NODE[n];
s = myFtdiDevice.GetDeviceList(ftdiDeviceList); chk(s);
printLine(sw2.ElapsedMilliseconds + " ms");
printLine("Devices found:");
for (UInt32 i = 0; i < n; i++)
{
if (ftdiDeviceList[i] != null)
{
Console.WriteLine(">> '" + ftdiDeviceList[i].Description + "' SN:" + ftdiDeviceList[i].SerialNumber);
}
}
print("Scanning FTDI devices for name '" + devSearchString + "'..."); sw2.Reset(); sw2.Start();
int ixDev = -1;
for (UInt32 i = 0; i < n; i++)
{
if (ftdiDeviceList[i] == null)
{
continue;
}
if (ftdiDeviceList[i].Description.ToUpper().Contains(devSearchString))
{
ixDev = (int)i;
}
}
if (ixDev < 0)
{
throw new Exception("No suitable FTDI device found\nHint: is the device already claimed by a running instance of this program?\n");
}
printLine(sw2.ElapsedMilliseconds + " ms");
// === open FTDI device ===
print("Opening device..."); sw2.Reset(); sw2.Start();
s = myFtdiDevice.OpenBySerialNumber(ftdiDeviceList[ixDev].SerialNumber); chk(s);
printLine(sw2.ElapsedMilliseconds + " ms");
// === create FTDI MPSSE-level IO object ===
ftdi2_io io = new ftdi2_io(myFtdiDevice, maxTransferSize: 500000); // maxTransferSize can strongly affect roundtrip time / latency. Experiment!
// === create JTAG-level IO ===
uint clkDiv = 0;
//clkDiv = 10; Console.WriteLine("DEBUG: clkDiv="+clkDiv);
ftdi_jtag jtag = new ftdi_jtag(io, clkDiv: clkDiv);
byte[] bufa = null;
// === verify that there is exactly one chained device on the bus ===
print("(optional): testing bypass register..."); sw2.Reset(); sw2.Start();
bypassTest(jtag);
printLine(sw2.ElapsedMilliseconds + " ms");
// === internal test (largely SW) ===
print("(optional): testing internal split reads..."); sw2.Reset(); sw2.Start();
internalSplitReadTest(jtag);
printLine(sw2.ElapsedMilliseconds + " ms");
// === get IDCODE ===
print("getting IDCODE..."); sw2.Reset(); sw2.Start();
jtag.state_testLogicReset();
jtag.state_shiftIr();
// https://www.xilinx.com/support/documentation/user_guides/ug470_7Series_Config.pdf page 173 IDCODE == 0b001001
bufa = new byte[] { /* opcode for IDCODE */ 0x09 };
jtag.rwNBits(6, bufa, false); // 6-bit opcode length
bufa = new byte[4];
jtag.state_shiftDr();
jtag.rwNBits(32, bufa, true);
bufa = jtag.getReadCopy(jtag.exec());
bufa[3] &= 0x0F; // mask out revision bytes
UInt64 idCode = ((UInt64)bufa[3] << 24) | ((UInt64)bufa[2] << 16) | ((UInt64)bufa[1] << 8) | (UInt64)bufa[0];
printLine(sw2.ElapsedMilliseconds + " ms");
Console.WriteLine("IDCODE {0:X8}", idCode);
#if false
// === determine FPGA ===
// https://www.xilinx.com/support/documentation/user_guides/ug470_7Series_Config.pdf page 14
string bitstreamFile;
switch (idCode)
{
case 0x362E093: bitstreamFile = "XC7A15T.bit"; break;
case 0x362D093: bitstreamFile = "XC7A35T.bit"; break;
case 0x362C093: bitstreamFile = "XC7A50T.bit"; break;
case 0x3632093: bitstreamFile = "XC7A75T.bit"; break;
case 0x3631093: bitstreamFile = "XC7A100T.bit"; break;
case 0x3636093: bitstreamFile = "XC7A200T.bit"; break;
default: throw new Exception(String.Format("unsupported FPGA (unknown IDCODE 0x{0:X7})", idCode));
}
#else
string bitstreamFile = @"..\..\..\busBridge3_RTL\busBridge3_RTL.runs\impl_1\top.bit"; Console.WriteLine("DEBUG: Trying to open bitstream from " + bitstreamFile);
#endif
byte[] bitstream = System.IO.File.ReadAllBytes(bitstreamFile);
// === upload to FPGA ===
sw2.Reset(); sw2.Start();
uploadBitstream(jtag, bitstream);
Console.WriteLine("bitstream upload: " + sw2.ElapsedMilliseconds + " ms");
#if false
// === exercises the USERx opcode ===
// use this as template to work with user circuitry that is directly attached to the BSCANE2 component (without using the "higher" busbridge layers)
byte[] tmp = new byte[32];
for (int ix = 0; ix < tmp.Length; ++ix)
{
tmp[ix] = (byte)ix;
}
// === USERx instruction ===
byte[] buf1 = new byte[] { 0x02 }; // USER1 opcode
jtag.state_shiftIr();
jtag.rwNBits(6, buf1, false);
jtag.state_shiftDr();
jtag.rwNBits(tmp.Length * 8, tmp, true);
jtag.exec();
byte[] bRead = jtag.getReadCopy(tmp.Length);
foreach (byte b in bRead)
{
Console.WriteLine(String.Format("{0:X2}", b));
}
#endif
// === open memory interface ===
memIf_cl m = new memIf_cl(jtag);
#if false
int h = m.readUInt32(addr: 0x12345678, nWords: 2, addrInc: 1);
m.exec();
uint num = m.getUInt32(h);
Console.WriteLine(num);
#endif
// === self test ===
for (long count = 0; count > -1; ++count)
{
// === simple, byte-level demo on USER2 opcode (no bus interface, no protocol) ===
USER2_demo(jtag);
USER2_demo(jtag); // run twice
// === bus-interface based demo on USER1 opcode ===
int memSize = 16384;
uint ram = 0xF0000000;
sw2.Reset(); sw2.Start();
int nRep = 1000;
m.memTest32(memSize: 1, baseAddr: 0x87654321, nIter: nRep);
Console.WriteLine("roundtrip time " + (1000 * (double)sw2.ElapsedMilliseconds / (double)nRep) + " microseconds");
m.memTest8(memSize: memSize, baseAddr: ram, nIter: 40);
m.memTest16(memSize: memSize, baseAddr: ram, nIter: 20);
m.memTest32(memSize: memSize, baseAddr: ram, nIter: 10);
// === build one transaction (note: memTestxy has its own "exec()" internally) ===
m.write(addr: 0x12345678, data: (uint)count & 1);
m.queryMargin(); // reset timing margin tracker
// queue a read and check margin
m.readUInt32(addr: ram);
int handle = m.queryMargin();
// queue a read and check margin
m.readUInt32(addr: 0x12345678);
int handle2 = m.queryMargin();
// configure test register delay, read and check margin
// see RTL code
UInt32 regVarReadLen = 0x98765432;
m.write(addr: regVarReadLen, data: 14); // 14 is the limit for 30 MHz JTAG, ~65 MHz FPGA clock
int h0 = m.readUInt32(addr: regVarReadLen);
int handle3 = m.queryMargin();
// === run in hardware ===
m.exec();
// === determine for the reads, how many FPGA clock cycles were left before a read timeout ===
UInt16 margin = m.getUInt16(handle);
Console.WriteLine("readback margin 1: " + margin + " FPGA clock cycles");
if (margin < 1)
{
Console.WriteLine("WARNING: Read timed out. Slow down JTAG or increase FPGA clock frequency.");
}
UInt16 margin2 = m.getUInt16(handle2);
Console.WriteLine("margin 2: " + margin2 + " FPGA clock cycles");
if (margin2 < 1)
{
Console.WriteLine("WARNING: Read timed out. Slow down JTAG or increase FPGA clock frequency.");
}
UInt16 margin3 = m.getUInt16(handle3);
UInt16 m3 = m.getUInt16(h0);
Console.WriteLine("configured test register delay: " + m3 + " remaining margin: " + margin3 + " FPGA clock cycles");
if (margin3 < 1)
{
Console.WriteLine("INFO: Read of slow register timed out.");
}
if (count == 0)
{
Console.WriteLine("#########################################################################");
Console.WriteLine("### All tests passed. Press RETURN to proceed with continuous testing ###");
Console.WriteLine("#########################################################################");
Console.ReadLine();
}
Console.WriteLine("press CTRL-C or close console window to quit");
}
}
static void Main(string[] args)
{
string deviceSerialNumber = "33VRWQARA";
FTDI.FT_STATUS status = new FTDI.FT_STATUS();
FTDI device = new FTDI();
UInt32 numberOfDevices = 0;
int sleepTime = 100;
status = device.GetNumberOfDevices(ref numberOfDevices);
FTDI.FT_DEVICE_INFO_NODE[] devicelist = new FTDI.FT_DEVICE_INFO_NODE[numberOfDevices];
status = device.GetDeviceList(devicelist);
Thread.Sleep(sleepTime);
if (status == FTDI.FT_STATUS.FT_OK)
{
Console.WriteLine("We have {0} devices", numberOfDevices);
}
else
{
Console.WriteLine("Failed to get number of devices");
}
status = device.OpenBySerialNumber(deviceSerialNumber);
Thread.Sleep(sleepTime);
if (status == FTDI.FT_STATUS.FT_OK)
{
Console.WriteLine("Device {0} is opened", deviceSerialNumber);
}
else
{
Console.WriteLine("Failed to open {0} device", deviceSerialNumber);
}
status = device.SetBitMode(0xff, FTDI.FT_BIT_MODES.FT_BIT_MODE_RESET);
Thread.Sleep(sleepTime);
if (status == FTDI.FT_STATUS.FT_OK)
{
Console.WriteLine("BitMode is resetted");
}
else
{
Console.WriteLine("Failed to reset BitMode");
}
status = device.SetBitMode(0xff, FTDI.FT_BIT_MODES.FT_BIT_MODE_SYNC_FIFO);
Thread.Sleep(sleepTime);
if (status == FTDI.FT_STATUS.FT_OK)
{
Console.WriteLine("BitMode is {0}", FTDI.FT_BIT_MODES.FT_BIT_MODE_SYNC_FIFO);
}
else
{
Console.WriteLine("Failed to set BitMode");
}
byte latency = 2;
device.SetLatency(latency);
Thread.Sleep(sleepTime);
if (status == FTDI.FT_STATUS.FT_OK)
{
Console.WriteLine("Latency timer value is {0}", latency);
}
else
{
Console.WriteLine("Failed to set latency");
}
uint inTransferSize = 0x10000;
device.InTransferSize(inTransferSize);
Thread.Sleep(sleepTime);
if (status == FTDI.FT_STATUS.FT_OK)
{
Console.WriteLine("inTransferSize value is {0}", inTransferSize);
}
else
{
Console.WriteLine("Failed to set inTransferSize");
}
device.SetFlowControl(FTDI.FT_FLOW_CONTROL.FT_FLOW_RTS_CTS, 0x00, 0x00);
Thread.Sleep(sleepTime);
if (status == FTDI.FT_STATUS.FT_OK)
{
Console.WriteLine("FlowControl is {0}", FTDI.FT_FLOW_CONTROL.FT_FLOW_RTS_CTS);
}
else
{
Console.WriteLine("Failed to set FlowControl");
}
device.Purge(FTDI.FT_PURGE.FT_PURGE_RX);
uint numBytes = 0;
//int cycles = 0;
using (FileStream fs = new FileStream(fileName, FileMode.Create, FileAccess.Write, FileShare.None))
{
using (BinaryWriter bw = new BinaryWriter(fs))
{
while (Console.KeyAvailable == false)
{
device.GetRxBytesAvailable(ref numBytes);
if (numBytes >= 1)
{
//cycles++;
byte[] bBuf = new byte[numBytes];
device.Read(bBuf, numBytes, ref numBytes);
bw.Write(bBuf);
//if (cycles == 1)
//{
// cycles = 0;
// Console.WriteLine("{0}", bBuf.Length);
//}
}
if (numBytes >= 0x10000)
{
Console.WriteLine("Buffer overload!");
}
}
//Console.WriteLine("Press 'p' to erase control bytes, 'q' to quite");
//ConsoleKeyInfo cki = Console.ReadKey(false);
//if (cki.Key == ConsoleKey.Q)
// Environment.Exit(-1);
//if (cki.Key == ConsoleKey.P)
//{
//}
}
}
Console.WriteLine("Key is pressed, end of file writting");
}
public override bool Connect()
{
var foundDevices = new Dictionary <string, ArccDevice>();
try
{
var myFtdiDevice = new FTDI();
uint ftdiDeviceCount = 0;
var ftStatus = myFtdiDevice.GetNumberOfDevices(ref ftdiDeviceCount);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
return(false);
}
var ftdiDeviceList = new FTDI.FT_DEVICE_INFO_NODE[ftdiDeviceCount];
ftStatus = myFtdiDevice.GetDeviceList(ftdiDeviceList);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
return(false);
}
for (var i = 0; i < ftdiDeviceList.Length; i++)
{
const string descriptionPattern = "ARCC";
if (!ftdiDeviceList[i].Description.StartsWith(descriptionPattern))
{
continue;
}
ftStatus = myFtdiDevice.OpenByIndex((uint)i);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
continue;
}
string comPort;
var chipId = 0;
ftStatus = myFtdiDevice.GetCOMPort(out comPort);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
continue;
}
myFtdiDevice.Close();
FTChipID.ChipID.GetDeviceChipID(i, ref chipId);
var id = DevicePrefix + ":" + chipId.ToString("X");
var device = new ArccDevice(id, comPort);
foundDevices.Add(id, device);
}
}
catch (Exception)
{
return(false);
}
foreach (var arccDevice in foundDevices)
{
if (arccDevice.Value.Connect())
{
Devices.Add(arccDevice.Key, arccDevice.Value);
}
}
return(true);
}
private void AttemptConnect()
{
connected = false;
UInt32 DeviceCount = 0;
FTDI.FT_STATUS ftStatus = FTDI.FT_STATUS.FT_OK;
// Create new instance of the FTDI device class
ftdi = new FTDI();
// Determine the number of FTDI devices connected to the machine
ftStatus = ftdi.GetNumberOfDevices(ref DeviceCount);
// Check status
if (ftStatus != FTDI.FT_STATUS.FT_OK || DeviceCount == 0)
{
commStat = CommStatus.NoDevice;
return;
}
commStat = CommStatus.NoElev8;
// Allocate storage for device info list
FTDI.FT_DEVICE_INFO_NODE[] DeviceList = new FTDI.FT_DEVICE_INFO_NODE[DeviceCount];
try
{
// Populate our device list
ftStatus = ftdi.GetDeviceList(DeviceList);
bool FoundElev8 = false;
for (int i = 0; i < DeviceCount && FoundElev8 == false; i++)
{
if (DeviceList[i].Type != FTDI.FT_DEVICE.FT_DEVICE_X_SERIES)
{
continue;
}
ftStatus = ftdi.OpenBySerialNumber(DeviceList[i].SerialNumber);
if (ftStatus == FTDI.FT_STATUS.FT_OK)
{
string portName;
ftdi.GetCOMPort(out portName);
if (portName == null || portName == "")
{
ftdi.Close();
continue;
}
ftdi.SetBaudRate(115200);
ftdi.SetDataCharacteristics(8, 1, 0);
ftdi.SetFlowControl(FTDI.FT_FLOW_CONTROL.FT_FLOW_NONE, 0, 0);
txBuffer[0] = (byte)0; // Set it to MODE_None to stop it writing (reset in case it was disconnected)
txBuffer[1] = (byte)0xff; // Send 0xff to the Prop to see if it replies
uint written = 0;
for (int j = 0; j < 10 && FoundElev8 == false; j++) // Keep pinging until it replies, or we give up
{
ftdi.Write(txBuffer, 2, ref written);
System.Threading.Thread.Sleep(50);
uint bytesAvail = 0;
ftdi.GetRxBytesAvailable(ref bytesAvail); // How much data is available from the serial port?
if (bytesAvail > 0)
{
uint bytesRead = 0;
ftdi.Read(rxBuffer, 1, ref bytesRead); // If it comes back with 0xE8 it's the one we want
if (bytesRead == 1 && rxBuffer[0] == 0xE8)
{
FoundElev8 = true;
commStat = CommStatus.Connected;
break;
}
}
}
if (FoundElev8)
{
connected = true;
txBuffer[0] = 2; // MODE_Sensors
written = 0;
ftdi.Write(txBuffer, 1, ref written);
if (ConnectionStarted != null)
{
ConnectionStarted();
}
break;
}
else
{
ftdi.Close();
}
}
}
}
catch (Exception)
{
return;
}
}
public bool Initialize()
{
SystemInitialized = false;
UInt32 index = 0; // this is the index of the Lambda device found in the list of USB devices connected
// Determine the number of FTDI devices connected to the machine
ftStatus = myFtdiDevice.GetNumberOfDevices(ref ftdiDeviceCount);
// Check if devices found
if (ftStatus == FTDI.FT_STATUS.FT_OK)
{
if (ftdiDeviceCount == 0)
{
PostError("No USB devices found (Lambda Filter Controller)");
return(false); // no devices found
}
}
else
{
PostError("Error Communicating with FTDI Device");
return(false); // no devices found
}
// Allocate storage for device info list
FTDI.FT_DEVICE_INFO_NODE[] ftdiDeviceList = new FTDI.FT_DEVICE_INFO_NODE[ftdiDeviceCount];
// Populate our device list
ftStatus = myFtdiDevice.GetDeviceList(ftdiDeviceList);
// Search list for Lambda device
if (ftStatus == FTDI.FT_STATUS.FT_OK)
{
index = 100;
for (UInt32 i = 0; i < ftdiDeviceCount; i++)
{
if (ftdiDeviceList[i].Description.ToString().Contains("Lambda"))
{
index = i;
}
}
if (index == 100)
{
PostError("Lambda Filter Controller not found");
return(false); // no Lambda devices found
}
}
// Open the Lambda device found
ftStatus = myFtdiDevice.OpenBySerialNumber(ftdiDeviceList[index].SerialNumber);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
PostError("Failed to open Lambda Filter Controller");
return(false); // failed to open device
}
// Set up device data parameters
// Set Baud rate to 9600
ftStatus = myFtdiDevice.SetBaudRate(9600);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
PostError("Failed to set Lambda Filter Controller baud rate");
return(false); // failed to set baud rate
}
// Set data characteristics - Data bits, Stop bits, Parity
ftStatus = myFtdiDevice.SetDataCharacteristics(FTDI.FT_DATA_BITS.FT_BITS_8, FTDI.FT_STOP_BITS.FT_STOP_BITS_1, FTDI.FT_PARITY.FT_PARITY_NONE);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
PostError("Failed to Lambda Filter Controller data characteristics");
return(false); // failed to set data characteristics (data bits, stop bits, parity)
}
// Set flow control - set RTS/CTS flow control
ftStatus = myFtdiDevice.SetFlowControl(FTDI.FT_FLOW_CONTROL.FT_FLOW_RTS_CTS, 0x11, 0x13);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
PostError("Failed to set Lambda Filter Controller flow control");
return(false); // failed to set flow control
}
// Set read timeout to 5 seconds, write timeout to infinite
ftStatus = myFtdiDevice.SetTimeouts(5000, 0);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
PostError("Failed to set Lambda Filter Controller read/write timeout durations");
return(false); // failed to set read/write timeout durations
}
SystemInitialized = true;
PostMessage("Lambda Filter Controller initialized");
return(true);
}
public bool OpenDevice()
{
UInt32 ftdiDeviceCount = 0;
FTDI.FT_STATUS ftStatus = FTDI.FT_STATUS.FT_OK;
ftStatus = device.GetNumberOfDevices(ref ftdiDeviceCount);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
return(false);
}
if (ftdiDeviceCount == 0)
{
return(false);
}
// Allocate storage for device info list
FTDI.FT_DEVICE_INFO_NODE[] ftdiDeviceList = new FTDI.FT_DEVICE_INFO_NODE[ftdiDeviceCount];
// Populate our device list
ftStatus = device.GetDeviceList(ftdiDeviceList);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
return(false);
}
// Open first device in our list by serial number
ftStatus = device.OpenBySerialNumber(ftdiDeviceList[0].SerialNumber);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
return(false);
}
// Set up device data parameters
// Set baud rate
ftStatus = device.SetBaudRate(BAUD_RATE);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
return(false);
}
// Set data characteristics - Data bits, Stop bits, Parity
ftStatus = device.SetDataCharacteristics(FTDI.FT_DATA_BITS.FT_BITS_8, FTDI.FT_STOP_BITS.FT_STOP_BITS_1, FTDI.FT_PARITY.FT_PARITY_NONE);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
return(false);
}
// Set flow control - set RTS/CTS flow control
ftStatus = device.SetFlowControl(FTDI.FT_FLOW_CONTROL.FT_FLOW_RTS_CTS, 0x11, 0x13);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
return(false);
}
// Set read timeout to 5 seconds, write timeout to 5s
ftStatus = device.SetTimeouts(5000, 5000);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
return(false);
}
return(true);
}
protected void InitBase()
{
UInt32 ftdiDeviceCount = 0;
ftStatus = FTDI.FT_STATUS.FT_OK;
// Create new instance of the FTDI device class
if (myFtdiDevice != null && myFtdiDevice.IsOpen == true)
{
myFtdiDevice.Close();
myFtdiDevice = null;
}
myFtdiDevice = new FTDI();
// Determine the number of FTDI devices connected to the machine
ftStatus = myFtdiDevice.GetNumberOfDevices(ref ftdiDeviceCount);
// Check status
if (ftStatus == FTDI.FT_STATUS.FT_OK)
{
Log("Number of FTDI devices: " + ftdiDeviceCount.ToString());
// If no devices available, return
if (ftdiDeviceCount > 0)
{
// Allocate storage for device info list
FTDI.FT_DEVICE_INFO_NODE[] ftdiDeviceList = new FTDI.FT_DEVICE_INFO_NODE[ftdiDeviceCount];
// Populate our device list
ftStatus = myFtdiDevice.GetDeviceList(ftdiDeviceList);
if (ftStatus == FTDI.FT_STATUS.FT_OK)
{
for (UInt32 i = 0; i < ftdiDeviceCount; i++)
{
Log("Device Index: " + i.ToString());
Log("Flags: " + String.Format("{0:x}", ftdiDeviceList[i].Flags));
Log("Type: " + ftdiDeviceList[i].Type.ToString());
Log("ID: " + String.Format("{0:x}", ftdiDeviceList[i].ID));
Log("Location ID: " + String.Format("{0:x}", ftdiDeviceList[i].LocId));
Log("Serial Number: " + ftdiDeviceList[i].SerialNumber.ToString());
Log("Description: " + ftdiDeviceList[i].Description.ToString());
Log("");
}
}
ftStatus = myFtdiDevice.OpenByIndex(0);
if (ftStatus == FTDI.FT_STATUS.FT_OK)
{
Log("Set OpenByIndex");
}
else
{
Log("Not set OpenByIndex=" + ftStatus.ToString());
}
ftStatus = myFtdiDevice.SetBitMode(0xFF, FTD2XX_NET.FTDI.FT_BIT_MODES.FT_BIT_MODE_ASYNC_BITBANG);
if (ftStatus == FTDI.FT_STATUS.FT_OK)
{
Log("Set bit mode async bitbang");
}
else
{
Log("Not set bit mode async bitbang error=" + ftStatus.ToString());
}
ftStatus = myFtdiDevice.SetBaudRate(9600);
if (ftStatus == FTDI.FT_STATUS.FT_OK)
{
Log("Set SetBaudRate");
}
else
{
Log("Not set SetBaudRate=" + ftStatus.ToString());
}
DisposeThread();
thread = new Thread(new ThreadStart(OneRound));
thread.Start();
// Wait for a key press
Log("Press any key to continue.");
}
else
{
// Wait for a key press
Log("Failed to get number of devices (error " + ftStatus.ToString() + ")");
}
}
else
{
// Wait for a key press
Log("Failed to get number of devices (error " + ftStatus.ToString() + ")");
}
}
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
{
}
}
static void Main(string[] args)
{
UInt32 ftdiDeviceCount = 0;
FTDI.FT_STATUS ftStatus = FTDI.FT_STATUS.FT_OK;
// Create new instance of the FTDI device class
FTDI myFtdiDevice = new FTDI();
// Determine the number of FTDI devices connected to the machine
ftStatus = myFtdiDevice.GetNumberOfDevices(ref ftdiDeviceCount);
// Check status
if (ftStatus == FTDI.FT_STATUS.FT_OK)
{
Console.WriteLine("Number of FTDI devices: " + ftdiDeviceCount.ToString());
Console.WriteLine("");
}
else
{
// Wait for a key press
Console.WriteLine("Failed to get number of devices (error " + ftStatus.ToString() + ")");
Console.ReadKey();
return;
}
// If no devices available, return
if (ftdiDeviceCount == 0)
{
// Wait for a key press
Console.WriteLine("Failed to get number of devices (error " + ftStatus.ToString() + ")");
Console.ReadKey();
return;
}
// Allocate storage for device info list
FTDI.FT_DEVICE_INFO_NODE[] ftdiDeviceList = new FTDI.FT_DEVICE_INFO_NODE[ftdiDeviceCount];
// Populate our device list
ftStatus = myFtdiDevice.GetDeviceList(ftdiDeviceList);
if (ftStatus == FTDI.FT_STATUS.FT_OK)
{
for (UInt32 i = 0; i < ftdiDeviceCount; i++)
{
Console.WriteLine("Device Index: " + i.ToString());
Console.WriteLine("Flags: " + String.Format("{0:x}", ftdiDeviceList[i].Flags));
Console.WriteLine("Type: " + ftdiDeviceList[i].Type.ToString());
Console.WriteLine("ID: " + String.Format("{0:x}", ftdiDeviceList[i].ID));
Console.WriteLine("Location ID: " + String.Format("{0:x}", ftdiDeviceList[i].LocId));
Console.WriteLine("Serial Number: " + ftdiDeviceList[i].SerialNumber.ToString());
Console.WriteLine("Description: " + ftdiDeviceList[i].Description.ToString());
Console.WriteLine("");
}
}
// Open first device in our list by serial number
ftStatus = myFtdiDevice.OpenBySerialNumber(ftdiDeviceList[0].SerialNumber);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
// Wait for a key press
Console.WriteLine("Failed to open device (error " + ftStatus.ToString() + ")");
Console.ReadKey();
return;
}
// Set up device data parameters
// Set Baud rate to 9600
ftStatus = myFtdiDevice.SetBaudRate(9600);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
// Wait for a key press
Console.WriteLine("Failed to set Baud rate (error " + ftStatus.ToString() + ")");
Console.ReadKey();
return;
}
// Set data characteristics - Data bits, Stop bits, Parity
ftStatus = myFtdiDevice.SetDataCharacteristics(FTDI.FT_DATA_BITS.FT_BITS_8, FTDI.FT_STOP_BITS.FT_STOP_BITS_1, FTDI.FT_PARITY.FT_PARITY_NONE);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
// Wait for a key press
Console.WriteLine("Failed to set data characteristics (error " + ftStatus.ToString() + ")");
Console.ReadKey();
return;
}
// Set flow control - set RTS/CTS flow control
ftStatus = myFtdiDevice.SetFlowControl(FTDI.FT_FLOW_CONTROL.FT_FLOW_RTS_CTS, 0x11, 0x13);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
// Wait for a key press
Console.WriteLine("Failed to set flow control (error " + ftStatus.ToString() + ")");
Console.ReadKey();
return;
}
// Set read timeout to 5 seconds, write timeout to infinite
ftStatus = myFtdiDevice.SetTimeouts(5000, 0);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
// Wait for a key press
Console.WriteLine("Failed to set timeouts (error " + ftStatus.ToString() + ")");
Console.ReadKey();
return;
}
// Perform loop back - make sure loop back connector is fitted to the device
// Write string data to the device
string dataToWrite = "Hello world!";
UInt32 numBytesWritten = 0;
// Note that the Write method is overloaded, so can write string or byte array data
ftStatus = myFtdiDevice.Write(dataToWrite, dataToWrite.Length, ref numBytesWritten);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
// Wait for a key press
Console.WriteLine("Failed to write to device (error " + ftStatus.ToString() + ")");
Console.ReadKey();
return;
}
// Check the amount of data available to read
// In this case we know how much data we are expecting,
// so wait until we have all of the bytes we have sent.
UInt32 numBytesAvailable = 0;
do
{
ftStatus = myFtdiDevice.GetRxBytesAvailable(ref numBytesAvailable);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
// Wait for a key press
Console.WriteLine("Failed to get number of bytes available to read (error " + ftStatus.ToString() + ")");
Console.ReadKey();
return;
}
Thread.Sleep(10);
} while (numBytesAvailable < dataToWrite.Length);
// Now that we have the amount of data we want available, read it
string readData;
UInt32 numBytesRead = 0;
// Note that the Read method is overloaded, so can read string or byte array data
ftStatus = myFtdiDevice.Read(out readData, numBytesAvailable, ref numBytesRead);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
// Wait for a key press
Console.WriteLine("Failed to read data (error " + ftStatus.ToString() + ")");
Console.ReadKey();
return;
}
Console.WriteLine(readData);
// Close our device
ftStatus = myFtdiDevice.Close();
// Wait for a key press
Console.WriteLine("Press any key to continue.");
Console.ReadKey();
return;
}
private static void ListenForData()
{
try
{
UInt32 ftdiDeviceCount = 0;
FTDI.FT_STATUS ftStatus = FTDI.FT_STATUS.FT_OK;
FTDI myFtdiDevice = new FTDI();
ftStatus = myFtdiDevice.GetNumberOfDevices(ref ftdiDeviceCount);
if (ftStatus == FTDI.FT_STATUS.FT_OK)
{
Console.WriteLine("Number of FTDI devices: " + ftdiDeviceCount.ToString());
Console.WriteLine("");
}
else
{
Console.WriteLine("Failed to get number of devices (error " + ftStatus.ToString() + ")");
Console.ReadKey();
return;
}
if (ftdiDeviceCount == 0)
{
Console.WriteLine("Failed to get number of devices (error " + ftStatus.ToString() + ")");
Console.ReadKey();
return;
}
FTDI.FT_DEVICE_INFO_NODE[] ftdiDeviceList = new FTDI.FT_DEVICE_INFO_NODE[ftdiDeviceCount];
ftStatus = myFtdiDevice.GetDeviceList(ftdiDeviceList);
if (ftStatus == FTDI.FT_STATUS.FT_OK)
{
for (UInt32 i = 0; i < ftdiDeviceCount; i++)
{
Console.WriteLine("Device Index: " + i.ToString());
Console.WriteLine("Flags: " + String.Format("{0:x}", ftdiDeviceList[i].Flags));
Console.WriteLine("Type: " + ftdiDeviceList[i].Type.ToString());
Console.WriteLine("ID: " + String.Format("{0:x}", ftdiDeviceList[i].ID));
Console.WriteLine("Location ID: " + String.Format("{0:x}", ftdiDeviceList[i].LocId));
Console.WriteLine("Serial Number: " + ftdiDeviceList[i].SerialNumber.ToString());
Console.WriteLine("Description: " + ftdiDeviceList[i].Description.ToString());
Console.WriteLine("");
}
}
ftStatus = myFtdiDevice.OpenBySerialNumber(ftdiDeviceList[0].SerialNumber);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
Console.WriteLine("Failed to open device (error " + ftStatus.ToString() + ")");
Console.ReadKey();
return;
}
ftStatus = myFtdiDevice.SetBaudRate(115200);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
Console.WriteLine("Failed to set Baud rate (error " + ftStatus.ToString() + ")");
Console.ReadKey();
return;
}
ftStatus = myFtdiDevice.SetDataCharacteristics(FTDI.FT_DATA_BITS.FT_BITS_8, FTDI.FT_STOP_BITS.FT_STOP_BITS_1, FTDI.FT_PARITY.FT_PARITY_NONE);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
Console.WriteLine("Failed to set data characteristics (error " + ftStatus.ToString() + ")");
Console.ReadKey();
return;
}
ftStatus = myFtdiDevice.SetFlowControl(FTDI.FT_FLOW_CONTROL.FT_FLOW_RTS_CTS, 0x11, 0x13);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
Console.WriteLine("Failed to set flow control (error " + ftStatus.ToString() + ")");
Console.ReadKey();
return;
}
// Set read timeout to 12 seconds, write timeout to infinite
ftStatus = myFtdiDevice.SetTimeouts(12000, 0);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
Console.WriteLine("Failed to set timeouts (error " + ftStatus.ToString() + ")");
Console.ReadKey();
return;
}
UInt32 numBytesAvailable = 0;
ftStatus = myFtdiDevice.GetRxBytesAvailable(ref numBytesAvailable);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
Console.WriteLine("Failed to get number of bytes available to read (error " + ftStatus.ToString() + ")");
Console.ReadKey();
return;
}
Thread.Sleep(10);
string readData = "";
UInt32 numBytesRead = 0;
byte[] dataBuffer = new byte[1024];
ftStatus = myFtdiDevice.Read(out readData, numBytesAvailable, ref numBytesRead);
while (readData == "")
{
ftStatus = myFtdiDevice.Read(out readData, numBytesAvailable, ref numBytesRead);
}
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
Console.WriteLine("Failed to read data (error " + ftStatus.ToString() + ")");
Console.ReadKey();
return;
}
Console.WriteLine(readData);
ftStatus = myFtdiDevice.Close();
Console.WriteLine("Press any key to continue.");
Console.ReadKey();
return;
}
catch
{
Console.WriteLine("Something realy bad happened..");
}
}
FTDI OpenAndPrepareDevice()
{
UInt32 ftdiDeviceCount = 0;
FTDI.FT_STATUS ftStatus = FTDI.FT_STATUS.FT_OK;
// Create new instance of the FTDI device class
FTDI myFtdiDevice = new FTDI();
// Determine the number of FTDI devices connected to the machine
ftStatus = myFtdiDevice.GetNumberOfDevices(ref ftdiDeviceCount);
// Check status
if (ftStatus == FTDI.FT_STATUS.FT_OK)
{
Console.WriteLine("Number of FTDI devices: " + ftdiDeviceCount.ToString());
Console.WriteLine("");
}
else
{
// Wait for a key press
Console.WriteLine("Failed to get number of devices (error " + ftStatus.ToString() + ")");
Console.ReadKey();
return(null);
}
// If no devices available, return
if (ftdiDeviceCount == 0)
{
// Wait for a key press
Console.WriteLine("Failed to get number of devices (error " + ftStatus.ToString() + ")");
Console.ReadKey();
return(null);
}
// Allocate storage for device info list
FTDI.FT_DEVICE_INFO_NODE[] ftdiDeviceList = new FTDI.FT_DEVICE_INFO_NODE[ftdiDeviceCount];
// Populate our device list
ftStatus = myFtdiDevice.GetDeviceList(ftdiDeviceList);
if (ftStatus == FTDI.FT_STATUS.FT_OK)
{
for (UInt32 i = 0; i < ftdiDeviceCount; i++)
{
Console.WriteLine("Device Index: " + i.ToString());
Console.WriteLine("Flags: " + String.Format("{0:x}", ftdiDeviceList[i].Flags));
Console.WriteLine("Type: " + ftdiDeviceList[i].Type.ToString());
Console.WriteLine("ID: " + String.Format("{0:x}", ftdiDeviceList[i].ID));
Console.WriteLine("Location ID: " + String.Format("{0:x}", ftdiDeviceList[i].LocId));
Console.WriteLine("Serial Number: " + ftdiDeviceList[i].SerialNumber.ToString());
Console.WriteLine("Description: " + ftdiDeviceList[i].Description.ToString());
Console.WriteLine("");
}
}
// Open first device in our list by serial number
ftStatus = myFtdiDevice.OpenBySerialNumber(ftdiDeviceList[0].SerialNumber);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
// Wait for a key press
Console.WriteLine("Failed to open device (error " + ftStatus.ToString() + ")");
Console.ReadKey();
return(null);
}
//Check the amount of data available to read
//In this case we know how much data we are expecting,
//so wait until we have all of the bytes we have sent.
ftStatus = myFtdiDevice.Purge(FTDI.FT_PURGE.FT_PURGE_RX | FTDI.FT_PURGE.FT_PURGE_TX);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
// Wait for a key press
Console.WriteLine("Failed to purge (error " + ftStatus.ToString() + ")");
Console.ReadKey();
return(null);
}
return(myFtdiDevice);
}
//-------------------------------------------------------------------------------------------------
public FTDI.FT_STATUS InitializeFTDI()
{
// Create new instance of the FTDI device class
SPI_Device = new FTDI();
uint ftdiDeviceCount = 0;
int i;
Initialize_SPI_Constants();
// Determine the number of FTDI devices connected to the machine
ftStatus = SPI_Device.GetNumberOfDevices(ref ftdiDeviceCount);
// Check status
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
return(ftStatus);
}
// If no devices available, return
if (ftdiDeviceCount == 0)
{
ftStatus = FTDI.FT_STATUS.FT_DEVICE_NOT_FOUND;
return(ftStatus);
}
// Allocate storage for device info list
FTDI.FT_DEVICE_INFO_NODE[] ftdiDeviceList = new FTDI.FT_DEVICE_INFO_NODE[ftdiDeviceCount];
// Populate our device list
ftStatus = SPI_Device.GetDeviceList(ftdiDeviceList);
if (ftStatus == FTDI.FT_STATUS.FT_OK)
{
for (i = 0; i < ftdiDeviceCount; i++)
{
//MessageBox.Show("Device Index: " + i.ToString());
//MessageBox.Show("Flags: " + String.Format("{0:x}", ftdiDeviceList[i].Flags));
//MessageBox.Show("Type: " + ftdiDeviceList[i].Type.ToString());
//MessageBox.Show("ID: " + String.Format("{0:x}", ftdiDeviceList[i].ID));
//MessageBox.Show("Location ID: " + String.Format("{0:x}", ftdiDeviceList[i].LocId));
//MessageBox.Show("Serial Number: " + ftdiDeviceList[i].SerialNumber.ToString());
//MessageBox.Show("Description: " + ftdiDeviceList[i].Description.ToString());
//MessageBox.Show("");
}
}
// Open first device in our list by serial number
ftStatus = SPI_Device.OpenBySerialNumber(ftdiDeviceList[0].SerialNumber);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
return(ftStatus);
}
// Set latency timer
ftStatus = SPI_Device.SetLatency(2);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
return(ftStatus);
}
// Reset the controller
ftStatus = SPI_Device.SetBitMode(0, 0);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
return(ftStatus);
}
// Set synchronous bit bang mode
ftStatus = SPI_Device.SetBitMode(FT232Routputs, 4); // Set device to mode 4 and sets outputs
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
return(ftStatus);
}
// Set baud rate/bit clock settings
ftStatus = SPI_Device.SetBaudRate(3000000);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
return(ftStatus);
}
presetShiftRegisterOutputs();
return(ftStatus);
}
static void Main(string[] args)
{
UInt32 ftdiDeviceCount = 0;
//1
// Create new instance of the FTDI device class
//2
// Determine the number of FTDI devices connected to the machine
ftStatus = myFtdiDevice.GetNumberOfDevices(ref ftdiDeviceCount);
// Check status
if (ftStatus == FTDI.FT_STATUS.FT_OK)
{
Console.WriteLine("Number of FTDI devices: " + ftdiDeviceCount.ToString());
Console.WriteLine("");
}
else
{
// Wait for a key press
Console.WriteLine("Failed to get number of devices (error " + ftStatus.ToString() + ")");
Console.ReadKey();
return;
}
// If no devices available, return
if (ftdiDeviceCount == 0)
{
// Wait for a key press
Console.WriteLine("Failed to get number of devices (error " + ftStatus.ToString() + ")");
Console.ReadKey();
return;
}
// Allocate storage for device info list
FTDI.FT_DEVICE_INFO_NODE[] ftdiDeviceList = new FTDI.FT_DEVICE_INFO_NODE[ftdiDeviceCount];
// Populate our device list
ftStatus = myFtdiDevice.GetDeviceList(ftdiDeviceList);
if (ftStatus == FTDI.FT_STATUS.FT_OK)
{
for (UInt32 i = 0; i < ftdiDeviceCount; i++)
{
Console.WriteLine("Device Index: " + i.ToString());
Console.WriteLine("Flags: " + String.Format("{0:x}", ftdiDeviceList[i].Flags));
Console.WriteLine("Type: " + ftdiDeviceList[i].Type.ToString());
Console.WriteLine("ID: " + String.Format("{0:x}", ftdiDeviceList[i].ID));
Console.WriteLine("Location ID: " + String.Format("{0:x}", ftdiDeviceList[i].LocId));
Console.WriteLine("Serial Number: " + ftdiDeviceList[i].SerialNumber.ToString());
Console.WriteLine("Description: " + ftdiDeviceList[i].Description.ToString());
Console.WriteLine("");
}
}
// Open first device in our list by serial number
ftStatus = myFtdiDevice.OpenBySerialNumber(ftdiDeviceList[0].SerialNumber);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
// Wait for a key press
Console.WriteLine("Failed to open device (error " + ftStatus.ToString() + ")");
Console.ReadKey();
return;
}
else
{
// ZJ
Console.WriteLine(ftdiDeviceList[0].Description.ToString());
Console.WriteLine("Open OK: ");
}
ftStatus = myFtdiDevice.ResetDevice();
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
// Wait for a key press
Console.WriteLine("Failed to Reset Device (error " + ftStatus.ToString() + ")");
Console.ReadKey();
return;
}
else
{
Console.WriteLine("Reset OK: ");
}
//3
UInt32 numBytesRead = 0;
UInt32 data = 0;
UInt32 numBytesWritten = 5;
Boolean calibrated = false;
//4//Boolean Meas_Ready = false;
ftStatus = myFtdiDevice.Write(cmd_ctrl, cmd_ctrl.Length, ref numBytesWritten);
ftStatus = myFtdiDevice.Write(cmd_en, cmd_en.Length, ref numBytesWritten);
ftStatus = myFtdiDevice.Write(cmd_wr_s, cmd_wr_s.Length, ref numBytesWritten);
ftStatus = myFtdiDevice.Write(cmd_wr_dac, cmd_wr_dac.Length, ref numBytesWritten);
// wait on finish of calibration
Console.WriteLine("Wait on calibration");
ftStatus = myFtdiDevice.Write(cmd_res, 5, ref numBytesWritten);
do
{
Console.Write(".");
ftStatus = myFtdiDevice.Write(cmd_rd_s, cmd_rd_s.Length, ref numBytesWritten);
ftStatus = myFtdiDevice.Read(read_buffer, 4, ref numBytesRead);
data = BitConverter.ToUInt32(read_buffer, 0);
if ((data & 0x800) == 0x800)
{
calibrated = true;
}
} while (!calibrated);
Console.WriteLine("");
Console.WriteLine("Calibration done");
// read the offset value - the simpliest version without averaging (you should read more consecutive data to calculate average value of OFFSET, see page 2.7)
Double Offset = 0.000000000000000;
UInt32 Offset_F = 0;
Double Meas = 0.000000000000000;
UInt64 Count = 0;
UInt32 A = 0;
UInt32 B = 0;
cmd_rd_f_data[1] = 0x02; // number of 32-bit data = 2
ftStatus = myFtdiDevice.Write(cmd_rd_f_data, 5, ref numBytesWritten);
do
{
ftStatus = myFtdiDevice.GetRxBytesAvailable(ref numBytesRead);
} while (numBytesRead < 8);
ftStatus = myFtdiDevice.Read(read_buffer, 8, ref numBytesRead);
data = BitConverter.ToUInt32(read_buffer, 0); // first 32-bit word
Count = data >> 20;
A = data & 0x3FF;
B = (data >> 10) & 0x3FF;
data = BitConverter.ToUInt32(read_buffer, 4); // second 32-bit word
Count = (data << 12) | Count;
Offset = 4 * ((double)Count + (((double)A - (double)B) / 1024));
Console.WriteLine("Offset = " + Offset.ToString() + " ns");
Offset = Offset / 1000000000;
///////////////freq offset
ftStatus = myFtdiDevice.Write(cmd_rd_offset_f, 5, ref numBytesWritten);
do
{
ftStatus = myFtdiDevice.GetRxBytesAvailable(ref numBytesRead);
} while (numBytesRead < 4);
ftStatus = myFtdiDevice.Read(read_buffer, 4, ref numBytesRead);
data = BitConverter.ToUInt32(read_buffer, 0); // first 32-bit word
//Count = (data << 12) | Count;
Offset_F = data;
Console.WriteLine("Offset_F = " + Offset_F.ToString() + " Hz");
//Offset_F = Offset_F / 1000000000;
//TimeIntervalMeas();
do
{
FrequencyMeas(Offset_F);
//WriteToFile();
////////////////////////
Console.ReadKey();
}while(true);
// Close our device
ftStatus = myFtdiDevice.Close();
return;
}
private static bool FT232H_Initial()
{
UInt32 ftdiDeviceCount = 0;
FTDI.FT_STATUS ftStatus = FTDI.FT_STATUS.FT_OK;
// Create new instance of the FTDI device class
myFtdiDevice = new FTDI();
// Determine the number of FTDI devices connected to the machine
ftStatus = myFtdiDevice.GetNumberOfDevices(ref ftdiDeviceCount);
// Check status
if (ftStatus == FTDI.FT_STATUS.FT_OK)
{
Console.WriteLine("Number of FTDI devices: " + ftdiDeviceCount.ToString());
Console.WriteLine("");
}
else
{
// Wait for a key press
Console.WriteLine("Failed to get number of devices (error " + ftStatus.ToString() + ")");
Console.ReadKey();
return(false);
}
// If no devices available, return
if (ftdiDeviceCount == 0)
{
// Wait for a key press
Console.WriteLine("Failed to get number of devices (error " + ftStatus.ToString() + ")");
Console.ReadKey();
return(false);
}
// Allocate storage for device info list
FTDI.FT_DEVICE_INFO_NODE[] ftdiDeviceList = new FTDI.FT_DEVICE_INFO_NODE[ftdiDeviceCount];
// Populate our device list
ftStatus = myFtdiDevice.GetDeviceList(ftdiDeviceList);
if (ftStatus == FTDI.FT_STATUS.FT_OK)
{
for (UInt32 i = 0; i < ftdiDeviceCount; i++)
{
Console.WriteLine("Device Index: " + i.ToString());
Console.WriteLine("Flags: " + String.Format("{0:x}", ftdiDeviceList[i].Flags));
Console.WriteLine("Type: " + ftdiDeviceList[i].Type.ToString());
Console.WriteLine("ID: " + String.Format("{0:x}", ftdiDeviceList[i].ID));
Console.WriteLine("Location ID: " + String.Format("{0:x}", ftdiDeviceList[i].LocId));
Console.WriteLine("Serial Number: " + ftdiDeviceList[i].SerialNumber.ToString());
Console.WriteLine("Description: " + ftdiDeviceList[i].Description.ToString());
Console.WriteLine("");
}
}
// Open first device in our list by serial number
ftStatus = myFtdiDevice.OpenByDescription("FT232H");
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
// Wait for a key press
Console.WriteLine("Failed to open device (error " + ftStatus.ToString() + ")");
Console.ReadKey();
return(false);
}
return(true);
}
static void Main(string[] args)
{
UInt32 ftdiDeviceCount = 0;
FTDI.FT_STATUS ftStatus = FTDI.FT_STATUS.FT_OK;
// Create new instance of the FTDI device class
FTDI myFtdiDevice = new FTDI();
// Determine the number of FTDI devices connected to the machine
ftStatus = myFtdiDevice.GetNumberOfDevices(ref ftdiDeviceCount);
// Check status
if (ftStatus == FTDI.FT_STATUS.FT_OK)
{
Console.WriteLine("Number of FTDI devices: " + ftdiDeviceCount.ToString());
Console.WriteLine("");
}
else
{
// Wait for a key press
Console.WriteLine("Failed to get number of devices (error " + ftStatus.ToString() + ")");
Console.ReadKey();
return;
}
// If no devices available, return
if (ftdiDeviceCount == 0)
{
// Wait for a key press
Console.WriteLine("Failed to get number of devices (error " + ftStatus.ToString() + ")");
Console.ReadKey();
return;
}
// Allocate storage for device info list
FTDI.FT_DEVICE_INFO_NODE[] ftdiDeviceList = new FTDI.FT_DEVICE_INFO_NODE[ftdiDeviceCount];
// Populate our device list
ftStatus = myFtdiDevice.GetDeviceList(ftdiDeviceList);
if (ftStatus == FTDI.FT_STATUS.FT_OK)
{
for (UInt32 i = 0; i < ftdiDeviceCount; i++)
{
Console.WriteLine("Device Index: " + i.ToString());
Console.WriteLine("Flags: " + String.Format("{0:x}", ftdiDeviceList[i].Flags));
Console.WriteLine("Type: " + ftdiDeviceList[i].Type.ToString());
Console.WriteLine("ID: " + String.Format("{0:x}", ftdiDeviceList[i].ID));
Console.WriteLine("Location ID: " + String.Format("{0:x}", ftdiDeviceList[i].LocId));
Console.WriteLine("Serial Number: " + ftdiDeviceList[i].SerialNumber.ToString());
Console.WriteLine("Description: " + ftdiDeviceList[i].Description.ToString());
Console.WriteLine("");
}
}
// Open first device in our list by serial number
ftStatus = myFtdiDevice.OpenBySerialNumber(ftdiDeviceList[0].SerialNumber);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
// Wait for a key press
Console.WriteLine("Failed to open device (error " + ftStatus.ToString() + ")");
Console.ReadKey();
return;
}
// Create our device EEPROM structure based on the type of device we have open
if (ftdiDeviceList[0].Type == FTDI.FT_DEVICE.FT_DEVICE_232R)
{
// We have an FT232R or FT245R so use FT232R EEPROM structure
FTDI.FT232R_EEPROM_STRUCTURE myEEData = new FTDI.FT232R_EEPROM_STRUCTURE();
// Read the device EEPROM
// This can throw an exception if trying to read a device type that does not
// match the EEPROM structure being used, so should always use a
// try - catch block when calling
try
{
ftStatus = myFtdiDevice.ReadFT232REEPROM(myEEData);
}
catch (FTDI.FT_EXCEPTION)
{
Console.WriteLine("Exception thrown when calling ReadFT232REEPROM");
}
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
// Wait for a key press
Console.WriteLine("Failed to read device EEPROM (error " + ftStatus.ToString() + ")");
Console.ReadKey();
// Close the device
myFtdiDevice.Close();
return;
}
// Write common EEPROM elements to our console
Console.WriteLine("EEPROM Contents for device at index 0:");
Console.WriteLine("Vendor ID: " + String.Format("{0:x}", myEEData.VendorID));
Console.WriteLine("Product ID: " + String.Format("{0:x}", myEEData.ProductID));
Console.WriteLine("Manufacturer: " + myEEData.Manufacturer.ToString());
Console.WriteLine("Manufacturer ID: " + myEEData.ManufacturerID.ToString());
Console.WriteLine("Description: " + myEEData.Description.ToString());
Console.WriteLine("Serial Number: " + myEEData.SerialNumber.ToString());
Console.WriteLine("Max Power: " + myEEData.MaxPower.ToString() + "mA");
Console.WriteLine("Self Powered: " + myEEData.SelfPowered.ToString());
Console.WriteLine("Remote Wakeup Enabled: " + myEEData.RemoteWakeup.ToString());
Console.WriteLine("");
// Change our serial number to write back to device
// By setting to an empty string, we allow the FTD2XX DLL
// to generate a serial number
myEEData.SerialNumber = String.Empty;
// Write our modified data structure back to the device EEPROM
// This can throw an exception if trying to write a device type that does not
// match the EEPROM structure being used, so should always use a
// try - catch block when calling
try
{
ftStatus = myFtdiDevice.WriteFT232REEPROM(myEEData);
}
catch (FTDI.FT_EXCEPTION)
{
Console.WriteLine("Exception thrown when calling WriteFT232REEPROM");
}
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
// Wait for a key press
Console.WriteLine("Failed to write device EEPROM (error " + ftStatus.ToString() + ")");
Console.ReadKey();
// Close the device
myFtdiDevice.Close();
return;
}
}
else if (ftdiDeviceList[0].Type == FTDI.FT_DEVICE.FT_DEVICE_2232)
{
// We have an FT2232 so use FT2232 EEPROM structure
FTDI.FT2232_EEPROM_STRUCTURE myEEData = new FTDI.FT2232_EEPROM_STRUCTURE();
// Read the device EEPROM
ftStatus = myFtdiDevice.ReadFT2232EEPROM(myEEData);
// This can throw an exception if trying to read a device type that does not
// match the EEPROM structure being used, so should always use a
// try - catch block when calling
try
{
ftStatus = myFtdiDevice.ReadFT2232EEPROM(myEEData);
}
catch (FTDI.FT_EXCEPTION)
{
Console.WriteLine("Exception thrown when calling ReadFT2232EEPROM");
}
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
// Wait for a key press
Console.WriteLine("Failed to read device EEPROM (error " + ftStatus.ToString() + ")");
Console.ReadKey();
// Close the device
myFtdiDevice.Close();
return;
}
// Write common EEPROM elements to our console
Console.WriteLine("EEPROM Contents for device at index 0:");
Console.WriteLine("Vendor ID: " + String.Format("{0:x}", myEEData.VendorID));
Console.WriteLine("Product ID: " + String.Format("{0:x}", myEEData.ProductID));
Console.WriteLine("Manufacturer: " + myEEData.Manufacturer.ToString());
Console.WriteLine("Manufacturer ID: " + myEEData.ManufacturerID.ToString());
Console.WriteLine("Description: " + myEEData.Description.ToString());
Console.WriteLine("Serial Number: " + myEEData.SerialNumber.ToString());
Console.WriteLine("Max Power: " + myEEData.MaxPower.ToString() + "mA");
Console.WriteLine("Self Powered: " + myEEData.SelfPowered.ToString());
Console.WriteLine("Remote Wakeup Enabled: " + myEEData.RemoteWakeup.ToString());
Console.WriteLine("");
// Change our serial number to write back to device
// By setting to an empty string, we allow the FTD2XX DLL
// to generate a serial number
myEEData.SerialNumber = String.Empty;
// Write our modified data structure back to the device EEPROM
// This can throw an exception if trying to write a device type that does not
// match the EEPROM structure being used, so should always use a
// try - catch block when calling
try
{
ftStatus = myFtdiDevice.WriteFT2232EEPROM(myEEData);
}
catch (FTDI.FT_EXCEPTION)
{
Console.WriteLine("Exception thrown when calling WriteFT2232EEPROM");
}
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
// Wait for a key press
Console.WriteLine("Failed to write device EEPROM (error " + ftStatus.ToString() + ")");
Console.ReadKey();
// Close the device
myFtdiDevice.Close();
return;
}
}
else if (ftdiDeviceList[0].Type == FTDI.FT_DEVICE.FT_DEVICE_BM)
{
// We have an FT232B or FT245B so use FT232B EEPROM structure
FTDI.FT232B_EEPROM_STRUCTURE myEEData = new FTDI.FT232B_EEPROM_STRUCTURE();
// Read the device EEPROM
ftStatus = myFtdiDevice.ReadFT232BEEPROM(myEEData);
// This can throw an exception if trying to read a device type that does not
// match the EEPROM structure being used, so should always use a
// try - catch block when calling
try
{
ftStatus = myFtdiDevice.ReadFT232BEEPROM(myEEData);
}
catch (FTDI.FT_EXCEPTION)
{
Console.WriteLine("Exception thrown when calling ReadFT232BEEPROM");
}
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
// Wait for a key press
Console.WriteLine("Failed to read device EEPROM (error " + ftStatus.ToString() + ")");
Console.ReadKey();
// Close the device
myFtdiDevice.Close();
return;
}
// Write common EEPROM elements to our console
Console.WriteLine("EEPROM Contents for device at index 0:");
Console.WriteLine("Vendor ID: " + String.Format("{0:x}", myEEData.VendorID));
Console.WriteLine("Product ID: " + String.Format("{0:x}", myEEData.ProductID));
Console.WriteLine("Manufacturer: " + myEEData.Manufacturer.ToString());
Console.WriteLine("Manufacturer ID: " + myEEData.ManufacturerID.ToString());
Console.WriteLine("Description: " + myEEData.Description.ToString());
Console.WriteLine("Serial Number: " + myEEData.SerialNumber.ToString());
Console.WriteLine("Max Power: " + myEEData.MaxPower.ToString() + "mA");
Console.WriteLine("Self Powered: " + myEEData.SelfPowered.ToString());
Console.WriteLine("Remote Wakeup Enabled: " + myEEData.RemoteWakeup.ToString());
Console.WriteLine("");
// Change our serial number to write back to device
// By setting to an empty string, we allow the FTD2XX DLL
// to generate a serial number
myEEData.SerialNumber = String.Empty;
// Write our modified data structure back to the device EEPROM
// This can throw an exception if trying to write a device type that does not
// match the EEPROM structure being used, so should always use a
// try - catch block when calling
try
{
ftStatus = myFtdiDevice.WriteFT232BEEPROM(myEEData);
}
catch (FTDI.FT_EXCEPTION)
{
Console.WriteLine("Exception thrown when calling WriteFT232BEEPROM");
}
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
// Wait for a key press
Console.WriteLine("Failed to write device EEPROM (error " + ftStatus.ToString() + ")");
Console.ReadKey();
// Close the device
myFtdiDevice.Close();
return;
}
}
// Use cycle port to force a re-enumeration of the device.
// In the FTD2XX_NET class library, the cycle port method also
// closes the open handle so no need to call the Close method separately.
ftStatus = myFtdiDevice.CyclePort();
UInt32 newFtdiDeviceCount = 0;
do
{
// Wait for device to be re-enumerated
// The device will have the same location since it has not been
// physically unplugged, so we will keep trying to open it until it succeeds
ftStatus = myFtdiDevice.OpenByLocation(ftdiDeviceList[0].LocId);
Thread.Sleep(1000);
} while (ftStatus != FTDI.FT_STATUS.FT_OK);
// Close the device
myFtdiDevice.Close();
// Re-create our device list
ftStatus = myFtdiDevice.GetNumberOfDevices(ref newFtdiDeviceCount);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
// Wait for a key press
Console.WriteLine("Failed to get number of devices (error " + ftStatus.ToString() + ")");
Console.ReadKey();
return;
}
// Re-populate our device list
ftStatus = myFtdiDevice.GetDeviceList(ftdiDeviceList);
if (ftStatus == FTDI.FT_STATUS.FT_OK)
{
for (UInt32 i = 0; i < ftdiDeviceCount; i++)
{
Console.WriteLine("Device Index: " + i.ToString());
Console.WriteLine("Flags: " + String.Format("{0:x}", ftdiDeviceList[i].Flags));
Console.WriteLine("Type: " + ftdiDeviceList[i].Type.ToString());
Console.WriteLine("ID: " + String.Format("{0:x}", ftdiDeviceList[i].ID));
Console.WriteLine("Location ID: " + String.Format("{0:x}", ftdiDeviceList[i].LocId));
Console.WriteLine("Serial Number: " + ftdiDeviceList[i].SerialNumber.ToString());
Console.WriteLine("Description: " + ftdiDeviceList[i].Description.ToString());
Console.WriteLine("");
}
}
// Wait for a key press
Console.WriteLine("Press any key to continue.");
Console.ReadKey();
return;
}
private string[] GetPotentialSensorSerialNumbers()
{
List <string> SerialNumbers = new List <string>();
UInt32 ftdiDeviceCount = 0;
FTDI.FT_STATUS ftStatus = FTDI.FT_STATUS.FT_OK;
// Create new instance of the FTDI device class
FTDI myFtdiDevice = new FTDI();
// Determine the number of FTDI devices connected to the machine
ftStatus = myFtdiDevice.GetNumberOfDevices(ref ftdiDeviceCount);
// Check status
if (ftStatus == FTDI.FT_STATUS.FT_OK)
{
DebugLog.Enqueue("Number of FTDI devices (A and B): " + ftdiDeviceCount.ToString());
}
else
{
DebugLog.Enqueue("Failed to get number of devices (error " + ftStatus.ToString() + ")");
return(SerialNumbers.ToArray());
}
// If no devices available, return
if (ftdiDeviceCount == 0)
{
DebugLog.Enqueue("No FTDI devices found");
return(SerialNumbers.ToArray());
}
// Allocate storage for device info list
FTDI.FT_DEVICE_INFO_NODE[] ftdiDeviceList = new FTDI.FT_DEVICE_INFO_NODE[ftdiDeviceCount];
// Wrap the following code in try-catch to avoid exceptions when devices are being added
try
{
// Populate our device list
ftStatus = myFtdiDevice.GetDeviceList(ftdiDeviceList);
// Add potential sensors to the list
if (ftStatus == FTDI.FT_STATUS.FT_OK)
{
for (UInt32 i = 0; i < ftdiDeviceCount; i++)
{
if (ftdiDeviceList[i].Description.ToString() == PediatricSoftConstants.ValidIDN)
{
SerialNumbers.Add(ftdiDeviceList[i].SerialNumber.ToString());
}
}
}
else
{
DebugLog.Enqueue("Failed to get FTDI serial numbers (error " + ftStatus.ToString() + ")");
return(SerialNumbers.ToArray());
}
}
catch
{
DebugLog.Enqueue("Failed to get FTDI serial numbers - devices are still being added. Please wait a few minutes.");
return(SerialNumbers.ToArray());
}
return(SerialNumbers.ToArray());
}
public bool Initialize(out string message)
// Desc: Initilize USB communication
// Output: message: Message
// bool: true = success, false = fail
{
uint ftdiDeviceCount = 0;
uint i;
uint myDeviceNum = 0;
FTDI.FT_DEVICE_INFO_NODE[] ftdiDeviceList;
FTDI.FT2232H_EEPROM_STRUCTURE myEEData = new FTDI.FT2232H_EEPROM_STRUCTURE();
// Determine the number of FTDI devices connected to the machine
ftStatus = myFtdiDevice.GetNumberOfDevices(ref ftdiDeviceCount);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
message = "FTDI GetNumberOfDevices Failed";
return(false);
}
if (ftdiDeviceCount == 0)
{
message = "No device found";
return(false);
}
// Get device info
ftdiDeviceList = new FTDI.FT_DEVICE_INFO_NODE[ftdiDeviceCount];
ftStatus = myFtdiDevice.GetDeviceList(ftdiDeviceList);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
message = "FTDI GetDeviceList Failed";
return(false);
}
if (ftdiDeviceList[0] == null)
{
message = "FTDI GetDeviceList Failed";
return(false);
}
// Determine which device to use
for (i = 0; i < ftdiDeviceCount; i++)
{
if (ftdiDeviceList[i].Description == "TTL232R")
{
myDeviceNum = i;
break;
}
}
if (i == ftdiDeviceCount)
{
message = "FTDI devices doesn't fit the description";
return(false);
}
// Open the selected device
ftStatus = myFtdiDevice.OpenBySerialNumber(ftdiDeviceList[myDeviceNum].SerialNumber);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
message = "FTDI OpenBySerialNumber Failed";
return(false);
}
// Setup baud rate
ftStatus = myFtdiDevice.SetBaudRate(1250000); // 9600
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
message = "FTDI SetBaudRate Failed";
return(false);
}
// Set data characteristics - Data bits, Stop bits, Parity
ftStatus = myFtdiDevice.SetDataCharacteristics(FTDI.FT_DATA_BITS.FT_BITS_8, FTDI.FT_STOP_BITS.FT_STOP_BITS_1, FTDI.FT_PARITY.FT_PARITY_NONE);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
message = "FTDI SetDataCharacteristics Failed";
return(false);
}
// Set flow control - set RTS/CTS flow control
ftStatus = myFtdiDevice.SetFlowControl(FTDI.FT_FLOW_CONTROL.FT_FLOW_NONE, 0x00, 0x00);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
message = "FTDI SetFlowControl Failed";
return(false);
}
// Set read timeout, write timeout
ftStatus = myFtdiDevice.SetTimeouts(3000, 3000);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
message = "FTDI SetTimeouts Failed";
return(false);
}
// Show result
message = "Initialization complete";
initialized = true;
return(true);
}
private void Polacz()
{
ftstatus = device.GetDeviceList(devicelist);
ftstatus = device.OpenByDescription(devicelist[0].Description);
ftstatus = device.SetBitMode(0xff, 1);
}
static void Main(string[] args)
{
FTDI ftdi = new FTDI();
MAX7219 Display;
uint devcount = 0;
ftdi.GetNumberOfDevices(ref devcount);
if (devcount > 0)
{
byte[] TransferBuffer = new byte[88];
uint NumBytesToTransfer;
uint NumBytesTransfered = 0;
Display = new MAX7219(TransferBuffer, WriteOut);
//FTDI AN_108 3.8 Clock Divisor
uint dwClockDivisor = 29; //Value of clock divisor, SCL Frequency = 60/((1+29)*2) (MHz) = 1Mhz
FTDI.FT_DEVICE_INFO_NODE[] devices = new FTDI.FT_DEVICE_INFO_NODE[devcount];
string Buffer;
FTDI.FT_STATUS s = ftdi.GetDeviceList(devices);
for (uint ix = 0; ix < devcount; ix++)
{
ftdi.OpenBySerialNumber(devices[ix].SerialNumber);
ftdi.GetCOMPort(out Buffer);
Console.WriteLine(Buffer);
ftdi.GetDescription(out Buffer);
Console.WriteLine(Buffer);
//FTDI Set Mode MPSSE
s = ftdi.SetBitMode(0, FTDI.FT_BIT_MODES.FT_BIT_MODE_RESET);
s |= ftdi.SetBitMode(0, FTDI.FT_BIT_MODES.FT_BIT_MODE_MPSSE);
if (s != FTDI.FT_STATUS.FT_OK)
{
Console.WriteLine("Fehler SetBitMode");
ftdi.Close();
return;
}
//FTDI Sync MPSSE (Check) FTDI_AN114 Page 10
if (Sync_MPSSE(ref ftdi, TransferBuffer) != FTDI.FT_STATUS.FT_OK)
{
Console.WriteLine("Fehler Sync MPSSE");
ftdi.Close();
return;
}
//Init FTDI SPI See FTDI AN_108
NumBytesToTransfer = 0;
TransferBuffer[NumBytesToTransfer++] = 0x8a; // Disable Clock divide /5
TransferBuffer[NumBytesToTransfer++] = 0x97; // Disable adaptiv clockink
TransferBuffer[NumBytesToTransfer++] = 0x8d; // Disables 3 phase data clocking
// I think is not nesacery
//TransferBuffer[NumBytesToTransfer++] = 0x80;
//TransferBuffer[NumBytesToTransfer++] = 0x08;
//TransferBuffer[NumBytesToTransfer++] = 0x0b;
TransferBuffer[NumBytesToTransfer++] = 0x86; //3.8 Clock Divisor
TransferBuffer[NumBytesToTransfer++] = (byte)(dwClockDivisor & 0xff);
TransferBuffer[NumBytesToTransfer++] = (byte)(dwClockDivisor >> 8);
s = ftdi.Write(TransferBuffer, NumBytesToTransfer, ref NumBytesTransfered);
NumBytesToTransfer = 0;
Thread.Sleep(20);
TransferBuffer[NumBytesToTransfer++] = 0x85; // Disable loopback
s |= ftdi.Write(TransferBuffer, NumBytesToTransfer, ref NumBytesTransfered);
NumBytesToTransfer = 0;
if (s != FTDI.FT_STATUS.FT_OK)
{
Console.WriteLine("SPI Init Fehler");
ftdi.Close();
return;
}
Console.WriteLine("SPI Init OK");
Console.WriteLine("Press ESC to Exit");
//Init 7219
s = ftdi.Write(TransferBuffer, Display.Init(8), ref NumBytesTransfered);
UInt32 count = 0;
while (true)
{
//Data
s |= ftdi.Write(TransferBuffer, Display.WriteDec(count, (byte)(1 << ((byte)(count++ % 8)))), ref NumBytesTransfered);
Console.WriteLine("SPI {0} Bytes Write", NumBytesTransfered);
Thread.Sleep(100);
if (Console.KeyAvailable && (Console.ReadKey(true)).Key == ConsoleKey.Escape)
{
break;
}
}
s |= ftdi.Write(TransferBuffer, Display.Clr(), ref NumBytesTransfered);
if (s != FTDI.FT_STATUS.FT_OK)
{
Console.WriteLine("SPI Fehler Write Data");
ftdi.Close();
return;
}
ftdi.Close();
}
}
else
{
Console.WriteLine("Kein FTDI gefunden :-(");
}
}
public SetupDialogForm()
{
InitializeComponent();
UInt32 ftdiDeviceCount = 0;
FTDI.FT_STATUS ftStatus = FTDI.FT_STATUS.FT_OK;
// Create new instance of the FTDI device class
FTDI tempFtdiDevice = new FTDI();
// Determine the number of FTDI devices connected to the machine
ftStatus = tempFtdiDevice.GetNumberOfDevices(ref ftdiDeviceCount);
// Check status
if (ftStatus == FTDI.FT_STATUS.FT_OK)
{
AvailableDevicesListBox.Items.Add("# of FTDI devices = " + ftdiDeviceCount.ToString());
}
else
{
throw new ASCOM.InvalidValueException("Error getting count FTDI devices");
}
if (ftdiDeviceCount > 0)
{
// Allocate storage for device info list
FTDI.FT_DEVICE_INFO_NODE[] ftdiDeviceList = new FTDI.FT_DEVICE_INFO_NODE[ftdiDeviceCount];
// Populate our device list
ftStatus = tempFtdiDevice.GetDeviceList(ftdiDeviceList);
//Show device properties
if (ftStatus == FTDI.FT_STATUS.FT_OK)
{
for (UInt32 i = 0; i < ftdiDeviceCount; i++)
{
if (ftdiDeviceList[i].SerialNumber.Contains("CAM8"))
{
AvailableDevicesListBox.Items.Add("Device Index: " + i.ToString());
AvailableDevicesListBox.Items.Add("Flags: " + String.Format("{0:x}", ftdiDeviceList[i].Flags));
AvailableDevicesListBox.Items.Add("Type: " + ftdiDeviceList[i].Type.ToString());
AvailableDevicesListBox.Items.Add("ID: " + String.Format("{0:x}", ftdiDeviceList[i].ID));
AvailableDevicesListBox.Items.Add("Location ID: " + String.Format("{0:x}", ftdiDeviceList[i].LocId));
AvailableDevicesListBox.Items.Add("Serial Number: " + ftdiDeviceList[i].SerialNumber.ToString());
AvailableDevicesListBox.Items.Add("Description: " + ftdiDeviceList[i].Description.ToString());
AvailableDevicesListBox.Items.Add("");
}
}
}
else
{
throw new ASCOM.InvalidValueException("Error getting parameters from FTDI devices");
}
}
//Close device
ftStatus = tempFtdiDevice.Close();
// Initialise current values of user settings from the ASCOM Profile
chkTrace.Checked = Camera.traceState;
coolerCheckBox.Checked = Camera.coolerEnabledState;
//find available com ports in system
string[] comPorts;
comPorts = SerialPort.GetPortNames();
int j;
for (j = 0; j < comPorts.Length; j++)
{
coolerComPortComboBox.Items.Add(comPorts[j]);
if (comPorts[j] == Camera.coolerComPortState)
{
coolerComPortComboBox.SelectedIndex = j;
}
}
}
static void Main(string[] args)
{
UInt32 ftdiDeviceCount = 0;
FTDI.FT_STATUS ftStatus = FTDI.FT_STATUS.FT_OK;
// Create new instance of the FTDI device class
FTDI myFtdiDevice = new FTDI();
// Determine the number of FTDI devices connected to the machine
ftStatus = myFtdiDevice.GetNumberOfDevices(ref ftdiDeviceCount);
// Check status
if (ftStatus == FTDI.FT_STATUS.FT_OK)
{
Console.WriteLine("Number of FTDI devices: " + ftdiDeviceCount.ToString());
Console.WriteLine("");
}
else
{
// Wait for a key press
Console.WriteLine("Failed to get number of devices (error " + ftStatus.ToString() + ")");
Console.ReadKey();
return;
}
// If no devices available, return
if (ftdiDeviceCount == 0)
{
// Wait for a key press
Console.WriteLine("Failed to get number of devices (error " + ftStatus.ToString() + ")");
Console.ReadKey();
return;
}
// Allocate storage for device info list
FTDI.FT_DEVICE_INFO_NODE[] ftdiDeviceList = new FTDI.FT_DEVICE_INFO_NODE[ftdiDeviceCount];
// Populate our device list
ftStatus = myFtdiDevice.GetDeviceList(ftdiDeviceList);
if (ftStatus == FTDI.FT_STATUS.FT_OK)
{
for (UInt32 i = 0; i < ftdiDeviceCount; i++)
{
Console.WriteLine("Device Index: " + i.ToString());
Console.WriteLine("Flags: " + String.Format("{0:x}", ftdiDeviceList[i].Flags));
Console.WriteLine("Type: " + ftdiDeviceList[i].Type.ToString());
Console.WriteLine("ID: " + String.Format("{0:x}", ftdiDeviceList[i].ID));
Console.WriteLine("Location ID: " + String.Format("{0:x}", ftdiDeviceList[i].LocId));
Console.WriteLine("Serial Number: " + ftdiDeviceList[i].SerialNumber.ToString());
Console.WriteLine("Description: " + ftdiDeviceList[i].Description.ToString());
Console.WriteLine("");
}
}
// Open first device in our list by serial number
ftStatus = myFtdiDevice.OpenBySerialNumber(ftdiDeviceList[0].SerialNumber);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
// Wait for a key press
Console.WriteLine("Failed to open device (error " + ftStatus.ToString() + ")");
Console.ReadKey();
return;
}
else
{
// ZJ
Console.WriteLine(ftdiDeviceList[0].Description.ToString());
Console.WriteLine("Open OK: ");
}
ftStatus = myFtdiDevice.ResetDevice();
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
// Wait for a key press
Console.WriteLine("Failed to Reset Device (error " + ftStatus.ToString() + ")");
Console.ReadKey();
return;
}
else
{
Console.WriteLine("Reset OK: ");
}
// you can define control commands (see Programmer's Guide - page 4)
byte[] cmd_res = new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00 };
byte[] cmd_ctrl = new byte[] { 0x04, 0x23, 0x00, 0x00, 0x00 }; // time interval, A<->B, 1 s range
byte[] cmd_en = new byte[] { 0x03, 0x04, 0x00, 0x00, 0x00 }; // Ihibit
byte[] cmd_wr_s = new byte[] { 0x02, 0xee, 0x04, 0x00, 0x00 }; // set START A, STOP B, slope rise (both), internal clock ON
byte[] cmd_wr_dac = new byte[] { 0x05, 0x8f, 0x8f, 0x00, 0x00 }; // threshold 0.5 V to START/STOP.
byte[] cmd_rd_s = new byte[] { 0xF2, 0x01, 0x00, 0x00, 0x00 };
byte[] cmd_meas = new byte[] { 0x01, 0x01, 0x00, 0x00, 0x00 };
byte[] cmd_rd_meas_no = new byte[] { 0xF1, 0x01, 0x00, 0x00, 0x00 };
byte[] cmd_rd_f_data = new byte[] { 0xF0, 0x02, 0x00, 0x00, 0x00 };
byte[] read_buffer = new byte[4 * 1024]; // set the size of buffer
UInt32 numBytesRead = 0;
UInt32 data = 0;
UInt32 numBytesWritten = 5;
Boolean calibrated = false;
Boolean Meas_Ready = false;
ftStatus = myFtdiDevice.Write(cmd_ctrl, cmd_ctrl.Length, ref numBytesWritten);
ftStatus = myFtdiDevice.Write(cmd_en, cmd_en.Length, ref numBytesWritten);
ftStatus = myFtdiDevice.Write(cmd_wr_s, cmd_wr_s.Length, ref numBytesWritten);
ftStatus = myFtdiDevice.Write(cmd_wr_dac, cmd_wr_dac.Length, ref numBytesWritten);
// wait on finish of calibration
Console.WriteLine("Wait on calibration");
ftStatus = myFtdiDevice.Write(cmd_res, 5, ref numBytesWritten);
do
{
Console.Write(".");
ftStatus = myFtdiDevice.Write(cmd_rd_s, cmd_rd_s.Length, ref numBytesWritten);
ftStatus = myFtdiDevice.Read(read_buffer, 4, ref numBytesRead);
data = BitConverter.ToUInt32(read_buffer, 0);
if ((data & 0x800) == 0x800)
{
calibrated = true;
}
} while (!calibrated);
Console.WriteLine("");
Console.WriteLine("Calibration done");
// read the offset value - the simpliest version without averaging (you should read more consecutive data to calculate average value of OFFSET, see page 2.7)
Double Offset = 0.000000000000000;
Double Meas = 0.000000000000000;
UInt64 Count = 0;
UInt32 A = 0;
UInt32 B = 0;
cmd_rd_f_data[1] = 0x02; // number of 32-bit data = 2
ftStatus = myFtdiDevice.Write(cmd_rd_f_data, 5, ref numBytesWritten);
do
{
ftStatus = myFtdiDevice.GetRxBytesAvailable(ref numBytesRead);
} while (numBytesRead < 8);
ftStatus = myFtdiDevice.Read(read_buffer, 8, ref numBytesRead);
data = BitConverter.ToUInt32(read_buffer, 0); // first 32-bit word
Count = data >> 20;
A = data & 0x3FF;
B = (data >> 10) & 0x3FF;
data = BitConverter.ToUInt32(read_buffer, 4); // second 32-bit word
Count = (data << 12) | Count;
Offset = 4 * ((double)Count + (((double)A - (double)B) / 1024));
Console.WriteLine("Offset = " + Offset.ToString() + " ns");
Offset = Offset / 1000000000;
// Measurement loop (in sequence: Start single measurement -> read the result)
// refresh settings (the settings are not restored after calibration)
ftStatus = myFtdiDevice.Write(cmd_ctrl, cmd_ctrl.Length, ref numBytesWritten);
ftStatus = myFtdiDevice.Write(cmd_en, cmd_en.Length, ref numBytesWritten);
ftStatus = myFtdiDevice.Write(cmd_wr_s, cmd_wr_s.Length, ref numBytesWritten);
ftStatus = myFtdiDevice.Write(cmd_wr_dac, cmd_wr_dac.Length, ref numBytesWritten);
Thread.Sleep(20); //wait for DAC
Console.WriteLine("");
Console.WriteLine("Press CTRL C to intrrupt");
Console.WriteLine("");
cmd_meas = new byte[] { 0x01, 0x01, 0x00, 0x00, 0x00 }; // number of measurements to do = 1
do
{
ftStatus = myFtdiDevice.Write(cmd_meas, 5, ref numBytesWritten); // start measuring process
Meas_Ready = false;
do //check the value of RD_MEAS_NO register
{
ftStatus = myFtdiDevice.Write(cmd_rd_meas_no, 5, ref numBytesWritten);
ftStatus = myFtdiDevice.Read(read_buffer, 4, ref numBytesRead);
data = BitConverter.ToUInt32(read_buffer, 0);
if (data > 0)
{
Meas_Ready = true;
}
} while (!Meas_Ready);
// READ RESULTS
cmd_rd_f_data = new byte[] { 0xF0, 0x02, 0x00, 0x00, 0x00 }; // how many words do you want to read? (2)
ftStatus = myFtdiDevice.Write(cmd_rd_f_data, 5, ref numBytesWritten);
do
{
ftStatus = myFtdiDevice.GetRxBytesAvailable(ref numBytesRead);
} while (numBytesRead < 8);
numBytesRead = 0;
ftStatus = myFtdiDevice.Read(read_buffer, 8, ref numBytesRead);
data = BitConverter.ToUInt32(read_buffer, 0); // the first 32-bit word
Count = data >> 20;
A = data & 0x3FF;
B = (data >> 10) & 0x3FF;
data = BitConverter.ToUInt32(read_buffer, 4); // the second 32-bit word
Count = (data << 12) | Count;
Meas = 4 * ((double)Count + (((double)A - (double)B) / 1024));
Meas = Meas / 1000000000;
Meas = Meas - Offset;
Console.WriteLine("Time interval = " + Meas.ToString());
// you should write something to exit the loop
} while (true);
// Close our device
ftStatus = myFtdiDevice.Close();
return;
}
public void fdti_init()
{
// Determine the number of FTDI devices connected to the machine
ftStatus = myFtdiDevice.GetNumberOfDevices(ref ftdiDeviceCount);
// Check status
if (ftStatus == FTDI.FT_STATUS.FT_OK)
{
// MessageBox.Show("Number of FTDI devices: " + ftdiDeviceCount.ToString());
// richTextBox1.AppendText("Number of FTDI devices: " + ftdiDeviceCount.ToString());
}
else
{
// Wait for a key press
MessageBox.Show("Failed to get number of devices (error " + ftStatus.ToString() + ")");
this.Close();
}
// If no devices available, return
if (ftdiDeviceCount == 0)
{
// Wait for a key press
MessageBox.Show("Failed to get number of devices (error " + ftStatus.ToString() + ")");
}
// Allocate storage for device info list
FTDI.FT_DEVICE_INFO_NODE[] ftdiDeviceList = new FTDI.FT_DEVICE_INFO_NODE[ftdiDeviceCount];
// Populate our device list
ftStatus = myFtdiDevice.GetDeviceList(ftdiDeviceList);
if (ftStatus == FTDI.FT_STATUS.FT_OK)
{
//for (UInt32 i = 0; i < ftdiDeviceCount; i++)
//{
// // + Environment.NewLine
// richTextBox1.Text += ("Device Index: " + i.ToString());
// richTextBox1.Text += ("Flags: " + String.Format("{0:x}", ftdiDeviceList[i].Flags));
// richTextBox1.Text += ("Type: " + ftdiDeviceList[i].Type.ToString());
// richTextBox1.Text += ("ID: " + String.Format("{0:x}", ftdiDeviceList[i].ID));
// richTextBox1.Text += ("Location ID: " + String.Format("{0:x}", ftdiDeviceList[i].LocId));
// richTextBox1.Text += ("Serial Number: " + ftdiDeviceList[i].SerialNumber.ToString());
// richTextBox1.Text += ("Description: " + ftdiDeviceList[i].Description.ToString());
// richTextBox1.Text += ("");
//}
//toolStripStatusLabel2.Text += "FT_OK";
statusLed.Value = true;
}
// Open first device in our list by serial number
ftStatus = myFtdiDevice.OpenBySerialNumber(ftdiDeviceList[0].SerialNumber);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
// Wait for a key press
MessageBox.Show("Failed to open device (error " + ftStatus.ToString() + ")");
}
ftStatus = myFtdiDevice.SetBitMode(0xFF, FTDI.FT_BIT_MODES.FT_BIT_MODE_RESET);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
// Wait for a key press
MessageBox.Show("Failed to set Reset mode (error " + ftStatus.ToString() + ")");
}
// Thread.Sleep(10);
ftStatus = myFtdiDevice.SetBitMode(0xFF, FTDI.FT_BIT_MODES.FT_BIT_MODE_SYNC_FIFO);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
// Wait for a key press
MessageBox.Show("Failed to set FIFO mode (error " + ftStatus.ToString() + ")");
}
// Set flow control - set RTS/CTS flow control
ftStatus = myFtdiDevice.SetFlowControl(FTDI.FT_FLOW_CONTROL.FT_FLOW_RTS_CTS, 0x11, 0x13);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
// Wait for a key press
MessageBox.Show("Failed to set flow control (error " + ftStatus.ToString() + ")");
}
//++++++++++++++++++++++++++++++++++++++++++
ftStatus = myFtdiDevice.SetLatency(16);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
// Wait for a key press
MessageBox.Show("Failed to st latency (error " + ftStatus.ToString() + ")");
return;
}
//++++++++++++++++++++++++++++++++++++++++++
//++++++++++++++++++++++++++++++++++++++++++
// Set read timeout to 5 seconds, write timeout to infinite
ftStatus = myFtdiDevice.SetTimeouts(500, 0);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
// Wait for a key press
MessageBox.Show("Failed to set timeouts (error " + ftStatus.ToString() + ")");
}
}
protected FTDI OpenChannel(string channelName, uint baudRate)
{
var res = new FTDI();
FTDI.FT_STATUS status = FTDI.FT_STATUS.FT_OTHER_ERROR;
FTDI.FT_DEVICE_INFO_NODE[] devicelist = new FTDI.FT_DEVICE_INFO_NODE[255];
status = res.GetDeviceList(devicelist);
// ON LINUX RUN APP WITH SUDO OR CONFIGURE ACCESS TO USB FTDI DEVICES
Console.WriteLine($"getdevicelist status is {status}");
devicelist = devicelist.Where(x => x != null).ToArray();
if (!devicelist.Any())
{
throw new Exception("No FTDI devices found.");
}
foreach (var device in devicelist)
{
Console.WriteLine($"Description is '{device.Description}'");
Console.WriteLine($"SerialNumber is '{device.SerialNumber}'");
Console.WriteLine($"ID is '{device.ID}'");
Console.WriteLine($"LocId is '{device.LocId}'");
Console.WriteLine($"Type is '{device.Type}'");
Console.WriteLine($"------");
}
status = res.OpenBySerialNumber(channelName);
Debug.Assert(status == FTDI.FT_STATUS.FT_OK);
res.ResetDevice();
Debug.Assert(status == FTDI.FT_STATUS.FT_OK);
// for (int i = 0; i < 60; i++)
// {
// status = res.OpenBySerialNumber(channelName);
// if (
// status != FTD2XX_NET.FTDI.FT_STATUS.FT_DEVICE_NOT_FOUND &&
// status != FTD2XX_NET.FTDI.FT_STATUS.FT_DEVICE_NOT_OPENED
// )
// break;
// Thread.Sleep(1000);
// res = new FTDI();
// FTDI.FT_DEVICE_INFO_NODE[] list = new FTDI.FT_DEVICE_INFO_NODE[200];
// status = res.GetDeviceList(list);
// }
Debug.Assert(status == FTDI.FT_STATUS.FT_OK);
status = res.SetBaudRate(baudRate);
Debug.Assert(status == FTDI.FT_STATUS.FT_OK);
status = res.SetLatency(0);
Debug.Assert(status == FTDI.FT_STATUS.FT_OK);
// enable async bitbang mode for all 8 pins
status = res.SetBitMode(0b11111111, FTDI.FT_BIT_MODES.FT_BIT_MODE_ASYNC_BITBANG);
Debug.Assert(status == FTDI.FT_STATUS.FT_OK);
status = res.SetTimeouts(1, 1);
Debug.Assert(status == FTDI.FT_STATUS.FT_OK);
return(res);
}
private void GetIdFTDI()
{
// Determine the number of FTDI devices connected to the machine
ftStatus = myFtdiDevice.GetNumberOfDevices(ref ftdiDeviceCount);
// Check status
if (ftStatus == FTDI.FT_STATUS.FT_OK)
{
Log("Number of FTDI devices: " + ftdiDeviceCount.ToString());
Log("");
Text = "BitBang - Devices found " + ftdiDeviceCount.ToString();
}
else
{
// Wait for a key press
Log("Failed to get number of devices (error " + ftStatus.ToString() + ")");
Log("");
Text = "BitBang - Error";
connectBtn.Enabled = false;
setBtn.Enabled = false;
comboBox1.Enabled = false;
return;
}
// If no devices available, return
if (ftdiDeviceCount == 0)
{
// Wait for a key press
//Log("Failed to get number of devices (error " + ftStatus.ToString() + ")");
Log("Failed to get IDs of devices");
Text = "BitBang - No devices";
connectBtn.Enabled = false;
setBtn.Enabled = false;
comboBox1.Enabled = false;
Log("_____________________________________");
return;
}
else
{
comboBox1.Enabled = true;
// Allocate storage for device info list
//FTDI.FT_DEVICE_INFO_NODE[] ftdiDeviceList = new FTDI.FT_DEVICE_INFO_NODE[ftdiDeviceCount];
ftdiDeviceList = new FTDI.FT_DEVICE_INFO_NODE[ftdiDeviceCount];
// Populate our device list
ftStatus = myFtdiDevice.GetDeviceList(ftdiDeviceList);
comboBox1.Items.Clear();
foreach (FTDI.FT_DEVICE_INFO_NODE device in ftdiDeviceList)
{
comboBox1.Items.Add(device.LocId);
}
if (ftdiDeviceCount == 1)
{
comboBox1.Text = ftdiDeviceList[0].LocId.ToString();
}
//ftStatus = myFtdiDevice.OpenByIndex
if (ftStatus == FTDI.FT_STATUS.FT_OK)
{
for (UInt32 i = 0; i < ftdiDeviceCount; i++)
{
Log("Device Index: " + i.ToString());
Log("Flags: " + String.Format("{0:x}", ftdiDeviceList[i].Flags));
Log("Type: " + ftdiDeviceList[i].Type.ToString());
Log("ID: " + String.Format("{0:x}", ftdiDeviceList[i].ID));
Log("Location ID: " + String.Format("{0:x}", ftdiDeviceList[i].LocId));
Log("Serial Number: " + ftdiDeviceList[i].SerialNumber.ToString());
Log("Description: " + ftdiDeviceList[i].Description.ToString());
Log("");
}
}
connectBtn.Enabled = true;
}
Log("_____________________________________");
}
private void AttemptConnect()
{
connected = false;
UInt32 DeviceCount = 0;
FTDI.FT_STATUS ftStatus = FTDI.FT_STATUS.FT_OK;
// Create new instance of the FTDI device class
ftdi = new FTDI();
// Determine the number of FTDI devices connected to the machine
ftStatus = ftdi.GetNumberOfDevices(ref DeviceCount);
// Check status
if (ftStatus != FTDI.FT_STATUS.FT_OK || DeviceCount == 0)
{
commStat = CommStatus.NoDevice;
return;
}
commStat = CommStatus.NoElev8;
// Allocate storage for device info list
FTDI.FT_DEVICE_INFO_NODE[] DeviceList = new FTDI.FT_DEVICE_INFO_NODE[DeviceCount];
try
{
// Populate our device list
ftStatus = ftdi.GetDeviceList(DeviceList);
bool FoundElev8 = false;
for (int i = 0; i < DeviceCount && FoundElev8 == false; i++)
{
if (DeviceList[i].Type != FTDI.FT_DEVICE.FT_DEVICE_X_SERIES)
{
continue;
}
for (int baud = 0; baud < 2; baud++)
{
ftStatus = ftdi.OpenBySerialNumber(DeviceList[i].SerialNumber);
if (ftStatus == FTDI.FT_STATUS.FT_OK)
{
string portName;
ftdi.GetCOMPort(out portName);
if (portName == null || portName == "")
{
ftdi.Close();
continue;
}
if (baud == 0)
{
ftdi.SetBaudRate(115200); // try this first
}
else
{
ftdi.SetBaudRate(57600); // then try this (xbee)
}
ftdi.SetDataCharacteristics(8, 1, 0);
ftdi.SetFlowControl(FTDI.FT_FLOW_CONTROL.FT_FLOW_NONE, 0, 0);
txBuffer[0] = (byte)'E';
txBuffer[1] = (byte)'l';
txBuffer[2] = (byte)'v';
txBuffer[3] = (byte)'8';
uint written = 0;
for (int j = 0; j < 10 && FoundElev8 == false && !quit; j++) // Keep pinging until it replies, or we give up
{
ftdi.Write(txBuffer, 4, ref written);
System.Threading.Thread.Sleep(50);
uint bytesAvail = 0;
ftdi.GetRxBytesAvailable(ref bytesAvail); // How much data is available from the serial port?
if (bytesAvail > 0)
{
int TestVal = 0;
while (bytesAvail > 0 && !quit)
{
uint bytesRead = 0;
ftdi.Read(rxBuffer, 1, ref bytesRead);
if (bytesRead == 1)
{
TestVal = (TestVal << 8) | rxBuffer[0];
if (TestVal == (int)(('E' << 0) | ('l' << 8) | ('v' << 16) | ('8' << 24)))
{
FoundElev8 = true;
commStat = CommStatus.Connected;
break;
}
}
if (bytesRead == 0)
{
break;
}
}
}
}
if (FoundElev8)
{
connected = true;
if (ConnectionStarted != null)
{
ConnectionStarted();
}
break;
}
else
{
ftdi.Close();
}
}
}
}
}
catch (Exception)
{
return;
}
}
private void SetupDialogForm_Shown(object sender, EventArgs e)
{
labelVersionInformation.Text = "CAM86 " + "v=" + Camera.driverVersion + ", LL=" + Camera.driverLLversion;
backuplabelVersionInformation = labelVersionInformation.Text;
// should we show all camera parameters or only some
windowSize = Camera.settingsWindowSizeState;
if (cameraConnected)
{
// make sure the value is valid
if (windowSize == settingsWindowSizeE.cameraOff)
{
windowSize = settingsWindowSizeE.cameraOnNoOptions;
}
setupWindowSize();
// add firmware label
labelVersionInformation.Text += ", FW=" + Camera.driverFirmwareVersion; // will always be zero unless read after initial camera connection
backuplabelVersionInformation = labelVersionInformation.Text;
}
else
{
// make sure the value is valid
if (windowSize != settingsWindowSizeE.cameraOff)
{
windowSize = settingsWindowSizeE.cameraOff;
}
setupWindowSize();
// Get info about the connected FTDI Cam86 devices
UInt32 ftdiDeviceCount = 0;
FTDI.FT_STATUS ftStatus = FTDI.FT_STATUS.FT_OK;
// Create new instance of the FTDI device class
FTDI tempFtdiDevice = new FTDI();
// Determine the number of FTDI devices connected to the machine
ftStatus = tempFtdiDevice.GetNumberOfDevices(ref ftdiDeviceCount);
// Check status
if (ftStatus == FTDI.FT_STATUS.FT_OK)
{
AvailableDevicesListBox.Items.Add("# of FTDI devices = " + ftdiDeviceCount.ToString());
}
else
{
throw new ASCOM.InvalidValueException("Error getting count FTDI devices");
}
if (ftdiDeviceCount > 0)
{
// Allocate storage for device info list
FTDI.FT_DEVICE_INFO_NODE[] ftdiDeviceList = new FTDI.FT_DEVICE_INFO_NODE[ftdiDeviceCount];
// Populate our device list
ftStatus = tempFtdiDevice.GetDeviceList(ftdiDeviceList);
//Show device properties
if (ftStatus == FTDI.FT_STATUS.FT_OK)
{
for (UInt32 i = 0; i < ftdiDeviceCount; i++)
{
if (ftdiDeviceList[i].SerialNumber.Contains("CAM86"))
{
AvailableDevicesListBox.Items.Add("Device Index: " + i.ToString());
AvailableDevicesListBox.Items.Add("Flags: " + String.Format("{0:x}", ftdiDeviceList[i].Flags));
AvailableDevicesListBox.Items.Add("Type: " + ftdiDeviceList[i].Type.ToString());
AvailableDevicesListBox.Items.Add("ID: " + String.Format("{0:x}", ftdiDeviceList[i].ID));
AvailableDevicesListBox.Items.Add("Location ID: " + String.Format("{0:x}", ftdiDeviceList[i].LocId));
AvailableDevicesListBox.Items.Add("Serial Number: " + ftdiDeviceList[i].SerialNumber.ToString());
AvailableDevicesListBox.Items.Add("Description: " + ftdiDeviceList[i].Description.ToString());
AvailableDevicesListBox.Items.Add("");
}
}
}
else
{
throw new ASCOM.InvalidValueException("Error getting parameters from FTDI devices");
}
}
//Close device
ftStatus = tempFtdiDevice.Close();
// Initialise current values of user settings from the ASCOM Profile
chkTrace.Checked = Camera.traceState;
}
// Initialise current values of user settings from the ASCOM Profile
checkBoxNightMode.Checked = Camera.nightModeSettingsState;
checkBoxOnTop.Checked = Camera.onTopState;
checkBoxTEConDuringRead.Checked = Camera.coolerDuringReadingState;
checkBoxMono.Checked = Camera.monoSensorState;
slowCoolingCheckBox.Checked = Camera.slowCoolingEnabledState;
slowCoolingNumUpDown.Value = (decimal)(Camera.slowCoolingSpeedState / 10.0);
numericUpDownSensorClearTime.Value = Camera.sensorClearBeforeExposureTimeState;
numericUpDownTECstartupPowerPercent.Value = Camera.coolingStartingPowerPercentState;
numericUpDownTECmaximumPowerPercent.Value = Camera.coolingMaxPowerPercentState;
checkBoxOpenSettingsOnConnect.Checked = Camera.settingsWindowOpenOnConnectState;
gainNumUpDown.Value = Camera.gainState;
offsetNumUpDown.Value = Camera.offsetState;
numericUpDownReadingTime.Value = Camera.readingTimeState;
numericUpDownPIDKp.Value = (decimal)Camera.PIDproportionalGainState;
numericUpDownPIDKi.Value = (decimal)Camera.PIDintegralGainState;
numericUpDownPIDKd.Value = (decimal)Camera.PIDderivativeGainState;
checkBoxDHT22.Checked = Camera.DHT22presentState;
if (!checkBoxDHT22.Checked)
{
labelDHTinfo.Text = "DHT: no sensor";
labelDHTinfo.Visible = false;
buttonHideSettings.Location = new Point(86, buttonHideSettings.Location.Y); // shift the button to left
}
else
{
labelDHTinfo.Visible = true;
buttonHideSettings.Location = new Point(6, buttonHideSettings.Location.Y); // center the button
}
// check date for the April Fools' Day joke
if (DateTime.Now.Day == 1 && DateTime.Now.Month == 4)
{
buttonCloudsOffAprilFoolsDay.Visible = true;
}
else
{
buttonCloudsOffAprilFoolsDay.Visible = false;
}
}
public ThorController(ThorStageModel stageModel, string serialNumber)
{
stage = new ThorStage(stageModel);
UInt32 deviceCount = 0;
uint numBytesWritten = 0;
this.serialNumber = serialNumber;
deviceHandle = new FTDI();
// Determine the number of FTDI devices connected to the machine
ftStatus = deviceHandle.GetNumberOfDevices(ref deviceCount);
// Populate device list
FTDI.FT_DEVICE_INFO_NODE[] ftdiDeviceList = new FTDI.FT_DEVICE_INFO_NODE[deviceCount];
ftStatus = deviceHandle.GetDeviceList(ftdiDeviceList);
ftStatus = deviceHandle.OpenBySerialNumber(serialNumber);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
// Wait for a key press
throw new Exception("Failed to open FTDI device " + ftStatus.ToString());
}
// Set baud rate to 115200.
ftStatus = deviceHandle.SetBaudRate(115200);
// 8 data bits, 1 stop bit, no parity
ftStatus = deviceHandle.SetDataCharacteristics(FTDI.FT_DATA_BITS.FT_BITS_8, FTDI.FT_STOP_BITS.FT_STOP_BITS_1, FTDI.FT_PARITY.FT_PARITY_NONE);
// Pre purge dwell 50ms.
Thread.Sleep(50);
// Purge the device.
ftStatus = deviceHandle.Purge(FTDI.FT_PURGE.FT_PURGE_RX | FTDI.FT_PURGE.FT_PURGE_TX);
// Post purge dwell 50ms.
Thread.Sleep(50);
// Reset device.
ftStatus = deviceHandle.ResetDevice();
// Set flow control to RTS/CTS.
ftStatus = deviceHandle.SetFlowControl(FTDI.FT_FLOW_CONTROL.FT_FLOW_RTS_CTS, 0, 0);
// Set RTS.
ftStatus = deviceHandle.SetRTS(true);
// Disable then enable channel
byte[] change_enstate = { 0x10, 0x02, 0x01, 0x02, 0x50, 0x1 };
ftStatus = deviceHandle.Write(change_enstate, 6, ref numBytesWritten);
change_enstate[3] = 0x01;
ftStatus = deviceHandle.Write(change_enstate, 6, ref numBytesWritten);
// Move home
byte[] movehome = { 0x43, 0x04, 0x01, 0x00, 0x50, 0x01 };
/*ftStatus = deviceHandle.Write(movehome, 6, ref numBytesWritten);
* Thread.Sleep(3000);
* do
* {
* statusBits = GetStatus();
* //Console.WriteLine("{0:X}", statusbits);
* } while ((statusBits & 0x400) != 0x400 || statusBits == 0);*/
}
public void Init()
{
// get number of FTDI devices connected to the machine
uint ftdiDeviceCount = 0;
var status = Ftdi.GetNumberOfDevices(ref ftdiDeviceCount);
if (status != FTDI.FT_STATUS.FT_OK)
{
Logger.Error("Failed to get number of FTDI devices: {0}", status);
return;
}
// if no FTDI device found, return.
if (ftdiDeviceCount == 0)
{
Logger.Debug("PinDMDv1 device not found.");
return;
}
// allocate storage for device info list
var ftdiDeviceList = new FTDI.FT_DEVICE_INFO_NODE[ftdiDeviceCount];
// populate device list
status = Ftdi.GetDeviceList(ftdiDeviceList);
if (status != FTDI.FT_STATUS.FT_OK)
{
Logger.Error("Failed to get FTDI devices: {0}", status);
return;
}
// loop through list and find PinDMDv1
for (uint i = 0; i < ftdiDeviceCount; i++)
{
var serialNumber = ftdiDeviceList[i].SerialNumber;
if (serialNumber == "DMD1000" || serialNumber == "DMD1001")
{
_pinDmd1Device = ftdiDeviceList[i];
IsAvailable = true;
Logger.Info("Found PinDMDv1 device.");
Logger.Debug(" Device Index: {0}", i);
Logger.Debug(" Flags: {0:x}", _pinDmd1Device.Flags);
Logger.Debug(" Type: {0}", _pinDmd1Device.Type);
Logger.Debug(" ID: {0:x}", _pinDmd1Device.ID);
Logger.Debug(" Location ID: {0}", _pinDmd1Device.LocId);
Logger.Debug(" Serial Number: {0}", _pinDmd1Device.SerialNumber);
Logger.Debug(" Description: {0}", _pinDmd1Device.Description);
break;
}
}
if (!IsAvailable)
{
Logger.Debug("PinDMDv1 device not found.");
return;
}
// open device by serial number
status = Ftdi.OpenBySerialNumber(_pinDmd1Device.SerialNumber);
if (status != FTDI.FT_STATUS.FT_OK)
{
Logger.Error("Failed to open device: {0}", status);
IsAvailable = false;
return;
}
// set bit mode
status = Ftdi.SetBitMode(0xff, 0x1);
if (status != FTDI.FT_STATUS.FT_OK)
{
Logger.Error("Failed to set bit mode: {0}", status);
IsAvailable = false;
return;
}
// set baud rate
status = Ftdi.SetBaudRate(12000);
if (status != FTDI.FT_STATUS.FT_OK)
{
Logger.Error("Failed to set baud rate: {0}", status);
IsAvailable = false;
return;
}
Logger.Info("Connected to PinDMDv1.");
}
//finds the ftdi port
private string getFTDIPort()
{
FTDI ftdi = new FTDI();
FTDI.FT_STATUS state;
uint deviceCount = 0;
state = ftdi.GetNumberOfDevices(ref deviceCount);
if (state != FTDI.FT_STATUS.FT_OK)
{
return(null);
}
FTDI.FT_DEVICE_INFO_NODE[] deviceNodes = new FTDI.FT_DEVICE_INFO_NODE[deviceCount];
state = ftdi.GetDeviceList(deviceNodes);
if (state != FTDI.FT_STATUS.FT_OK)
{
return(null);
}
string port = null;
foreach (FTDI.FT_DEVICE_INFO_NODE node in deviceNodes)
{
if (node.Type == FTDI.FT_DEVICE.FT_DEVICE_2232)
{
//Dieses Gerät hat 2 serielle Anschlüsse. Wir brauchen den Typ B.
if (node.Description.EndsWith("B"))
{
state = ftdi.OpenBySerialNumber(node.SerialNumber);
if (state != FTDI.FT_STATUS.FT_OK)
{
continue;
}
String tmpPort;
state = ftdi.GetCOMPort(out tmpPort);
if (state != FTDI.FT_STATUS.FT_OK)
{
Trace.WriteLine("Failed to get COM-Port (error " + state.ToString() + ")");
ftdi.Close();
continue;
}
if (tmpPort == null || tmpPort.Length == 0)
{
Trace.WriteLine(string.Format("Failed to get COM-Port for device {0}.", node.SerialNumber));
ftdi.Close();
continue;
}
FTDI.FT2232_EEPROM_STRUCTURE eepromData = new FTDI.FT2232_EEPROM_STRUCTURE();
try
{
state = ftdi.ReadFT2232EEPROM(eepromData);
}
catch (Exception)
{
Trace.WriteLine("Exception thrown when calling ReadFT2232EEPROM");
}
if (state != FTDI.FT_STATUS.FT_OK)
{
Trace.WriteLine("Failed to read device EEPROM (error " + state.ToString() + ")");
ftdi.Close();
continue;
}
Debug.WriteLine(port);
ftdi.Close();
if (!eepromData.Manufacturer.Equals("EnOcean GmbH") && !eepromData.Manufacturer.Equals("Viessmann") && !eepromData.Manufacturer.Equals("Eltako GmbH"))
{
Trace.WriteLine(String.Format("Wrong Manufacturer {0}", eepromData.Manufacturer));
continue;
}
if (tmpPort != null)
{
port = tmpPort;
break;
}
}
}
else if (node.Type == FTDI.FT_DEVICE.FT_DEVICE_232R)
{
state = ftdi.OpenBySerialNumber(node.SerialNumber);
if (state != FTDI.FT_STATUS.FT_OK)
{
continue;
}
String tmpPort;
state = ftdi.GetCOMPort(out tmpPort);
if (state != FTDI.FT_STATUS.FT_OK)
{
Trace.WriteLine("Failed to get COM-Port (error " + state.ToString() + ")");
ftdi.Close();
continue;
}
if (tmpPort == null || tmpPort.Length == 0)
{
Trace.WriteLine(string.Format("Failed to get COM-Port for device {0}.", node.SerialNumber));
ftdi.Close();
continue;
}
FTDI.FT232R_EEPROM_STRUCTURE eepromData = new FTDI.FT232R_EEPROM_STRUCTURE();
try
{
state = ftdi.ReadFT232REEPROM(eepromData);
}
catch (Exception)
{
Trace.WriteLine("Exception thrown when calling ReadFT232REEPROM");
}
if (state != FTDI.FT_STATUS.FT_OK)
{
Trace.WriteLine("Failed to read device EEPROM (error " + state.ToString() + ")");
ftdi.Close();
continue;
}
ftdi.Close();
if (!eepromData.Manufacturer.Equals("EnOcean GmbH") && !eepromData.Manufacturer.Equals("Viessmann") && !eepromData.Manufacturer.Equals("Eltako GmbH"))
{
Trace.WriteLine(String.Format("Wrong Manufacturer {0}", eepromData.Manufacturer));
continue;
}
if (tmpPort != null)
{
port = tmpPort;
break;
}
}
}
return(port);
}