|
public SetBaudRate ( |
||
| BaudRate | The desired Baud rate for the device. | |
| return | FT_STATUS | |
/// <summary>
/// Create a USB Relay Device and open it by the serial number
/// </summary>
/// <param name="serialNumber">Device serial number</param>
public UsbRelay8( String serialNumber )
{
// Open the relay device by serial number
// The serial number is always uniques, so the safest
_device = new FTDI();
_status = _device.OpenBySerialNumber(serialNumber);
if (_status != FTDI.FT_STATUS.FT_OK)
{
throw new UsbRelayDeviceNotFoundException();
}
// Set the baud rate
_status = _device.SetBaudRate(BaudRate);
if (_status != FTDI.FT_STATUS.FT_OK)
{
throw new UsbRelayConfigurationException();
}
// Set the bit mode
_status = _device.SetBitMode(BitMask, BitMode);
if (_status != FTDI.FT_STATUS.FT_OK)
{
throw new UsbRelayConfigurationException();
}
// Clear all the relays
// Note: From the Data Sheet, when in Sync Mode you can
// only read the interface pins when writing. So start
// start out with all the values cleared.
_values = 0x00;
SetRelays(_values);
}
//-------------------------------------------------------------------------------------------------
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);
}
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 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 void Connect(SerialPort port)
{
_port = port;
port.Open();
_laser = new FTDI();
//uint devs =0 ;
//_laser.GetNumberOfDevices(ref devs);
// FTDI.FT_DEVICE_INFO_NODE[] list = new FTDI.FT_DEVICE_INFO_NODE[devs];
//_laser.GetDeviceList(list);
// _laser.OpenBySerialNumber("FT94OEXA"); //cable
// _laser.OpenBySerialNumber("A602KUPB"); // Dongle
_laser.OpenBySerialNumber("DEFCON01"); //Joe's
//_controller.Connect(new SerialPort((string)comboBox2.SelectedItem, 57600));
_laser.SetBaudRate(4800);
_laser.SetDataCharacteristics(FTDI.FT_DATA_BITS.FT_BITS_8, FTDI.FT_STOP_BITS.FT_STOP_BITS_1, FTDI.FT_PARITY.FT_PARITY_NONE);
if (laser_always_on)
{
_laser.SetRTS(false);
}
else
{
_laser.SetRTS(false);
}
}
public FTDIBulkDriver(GraphBuilder gb, FTDI device, string deviceDescriptor, uint baudRate)
: base(gb)
{
FTDI.FT_STATUS fs;
if (device != null)
{
m_device = device;
if ((fs = device.OpenBySerialNumber(deviceDescriptor)) != FTDI.FT_STATUS.FT_OK)
throw new Exception(string.Format("Невозможно открыть устройство. Устройство не готово. ({0})", fs));
if ((fs = device.SetBaudRate(baudRate)) != FTDI.FT_STATUS.FT_OK)
throw new Exception(string.Format("Устройство не поддерживает заданную скорость ({0})", fs));
m_outputPin = RegisterOutputPin<byte[]>("MainOutPin");
}
}
private void button5_Click( object sender, EventArgs e )
{
UInt32 ftdiDeviceCount = 0;
// Create new instance of the FTDI device class
myFtdiDevice = new FTDI();
myFtdiDevice.GetNumberOfDevices( ref ftdiDeviceCount );
FTDI.FT_DEVICE_INFO_NODE[] ftdiDeviceList = new FTDI.FT_DEVICE_INFO_NODE[ftdiDeviceCount];
myFtdiDevice.GetDeviceList( ftdiDeviceList );
myFtdiDevice.OpenBySerialNumber( ftdiDeviceList[0].SerialNumber );
myFtdiDevice.SetBaudRate( 9600 );
myFtdiDevice.SetDataCharacteristics( FTDI.FT_DATA_BITS.FT_BITS_8, FTDI.FT_STOP_BITS.FT_STOP_BITS_1, FTDI.FT_PARITY.FT_PARITY_NONE );
myFtdiDevice.SetFlowControl( FTDI.FT_FLOW_CONTROL.FT_FLOW_RTS_CTS, 0x11, 0x13 );
myFtdiDevice.SetTimeouts( 5000, 0 );
richTextBox1.AppendText("polaczono");
}
public CentralBoard()
{
centralBoardCom = new FTD2XX_NET.FTDI();
propertyManager = PropertyManager.i;
propertyManager.Load("Hardware");
string SerialNumber = propertyManager.GetStringValue("Hardware", "CentralBoardSerialNumber");
centralBoardCom.OpenBySerialNumber(SerialNumber);
if (!centralBoardCom.IsOpen)
{
throw new Exception("Could Not Connect to CentralBoard");
}
centralBoardCom.SetBaudRate(38400);
centralBoardCom.SetTimeouts(100, 1000);
}
//==============================
//serial port stuff
/// <summary>
///
/// </summary>
/// <param name="dev"></param>
/// <param name="index"></param>
/// <returns></returns>
public FTDI.FT_STATUS setSerialParams(FTDI dev, uint index)
{
FTDI.FT_STATUS ftStatus = FTDI.FT_STATUS.FT_OK;
// Set up device data parameters
// must be opened first
// Set Baud rate to 9600
ftStatus = dev.SetBaudRate(9600);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
return ftStatus;
// Set data characteristics - Data bits, Stop bits, Parity
ftStatus = dev.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 ftStatus;
// Set flow control - set RTS/CTS flow control
//ftStatus = dev.SetFlowControl(
// FTDI.FT_FLOW_CONTROL.FT_FLOW_RTS_CTS, 0x11, 0x13);
//ftStatus = dev.SetRTS(true);
//Thread.Sleep(5);
//ftStatus=dev.SetRTS(false);
ftStatus = dev.SetFlowControl(
FTDI.FT_FLOW_CONTROL.FT_FLOW_NONE, 0x11, 0x13);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
return ftStatus;
// Set read timeout to 5 seconds, write timeout to infinite
ftStatus = dev.SetTimeouts(5000, 0);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
return ftStatus;
return ftStatus;
}
/// <summary>
///
/// </summary>
/// <param name="iSoundChipType"></param>
/// <param name="clock"></param>
/// <returns></returns>
public static VsifClient TryToConnectVSIF(VsifSoundModuleType soundModule, PortId comPort, bool shareOnly)
{
lock (lockObject)
{
foreach (var c in vsifClients)
{
if (c.SoundModuleType == soundModule)
{
if (c.DataWriter.PortName.Equals("COM" + (int)(comPort + 1)))
{
c.ReferencedCount++;
return(c);
}
if (c.DataWriter.PortName.Equals("FTDI_COM" + (int)comPort))
{
c.ReferencedCount++;
return(c);
}
}
}
if (shareOnly)
{
return(null);
}
try
{
switch (soundModule)
{
case VsifSoundModuleType.Generic_UART:
{
SerialPort sp = null;
sp = new SerialPort("COM" + ((int)comPort + 1));
sp.WriteTimeout = 100;
sp.ReadTimeout = 100;
sp.BaudRate = 115200;
sp.BaudRate = 1200 * (int)Settings.Default.BitBangWaitAY8910;
sp.StopBits = StopBits.One;
sp.DataBits = 8;
sp.Handshake = Handshake.None;
sp.Open();
var client = new VsifClient(soundModule, new PortWriterGenericUart(sp));
client.Disposed += Client_Disposed;
vsifClients.Add(client);
return(client);
}
case VsifSoundModuleType.SMS:
{
SerialPort sp = null;
sp = new SerialPort("COM" + ((int)comPort + 1));
sp.WriteTimeout = 100;
sp.ReadTimeout = 100;
sp.BaudRate = 115200;
sp.StopBits = StopBits.Two;
//sp.BaudRate = 57600;
//sp.StopBits = StopBits.One;
sp.Parity = Parity.None;
sp.DataBits = 8;
sp.Handshake = Handshake.None;
sp.Open();
var client = new VsifClient(soundModule, new PortWriterGenesis(sp));
client.Disposed += Client_Disposed;
vsifClients.Add(client);
return(client);
}
case VsifSoundModuleType.Genesis:
{
SerialPort sp = null;
sp = new SerialPort("COM" + ((int)comPort + 1));
sp.WriteTimeout = 500;
sp.ReadTimeout = 500;
//sp.BaudRate = 230400;
sp.BaudRate = 163840;
sp.StopBits = StopBits.One;
sp.Parity = Parity.None;
sp.DataBits = 8;
sp.Open();
var client = new VsifClient(soundModule, new PortWriterGenesis(sp));
client.Disposed += Client_Disposed;
vsifClients.Add(client);
return(client);
}
case VsifSoundModuleType.Genesis_Low:
{
SerialPort sp = null;
sp = new SerialPort("COM" + ((int)comPort + 1));
sp.WriteTimeout = 500;
sp.ReadTimeout = 500;
sp.BaudRate = 115200;
sp.StopBits = StopBits.One;
sp.Parity = Parity.None;
sp.DataBits = 8;
sp.Open();
var client = new VsifClient(soundModule, new PortWriterGenesis(sp));
client.Disposed += Client_Disposed;
vsifClients.Add(client);
return(client);
}
case VsifSoundModuleType.Genesis_FTDI:
{
var ftdi = new FTD2XX_NET.FTDI();
var stat = ftdi.OpenByIndex((uint)comPort);
if (stat == FTDI.FT_STATUS.FT_OK)
{
ftdi.SetBitMode(0x00, FTDI.FT_BIT_MODES.FT_BIT_MODE_RESET);
ftdi.SetBitMode(0xff, FTDI.FT_BIT_MODES.FT_BIT_MODE_ASYNC_BITBANG);
ftdi.SetBaudRate(FTDI_BAUDRATE_GEN * FTDI_BAUDRATE_GEN_MUL);
ftdi.SetTimeouts(500, 500);
ftdi.SetLatency(0);
byte ps = 0;
ftdi.GetPinStates(ref ps);
if ((ps & 0x40) == 0)
{
uint dummy = 0;
ftdi.Write(new byte[] { 0x40 }, 1, ref dummy);
}
var client = new VsifClient(soundModule, new PortWriterGenesis(ftdi, comPort));
//ftdi.Write(new byte[] { (byte)(((0x07 << 1) & 0xe) | 0) }, 1, ref dummy);
//ftdi.Write(new byte[] { (byte)(((0x38 >> 2) & 0xe) | 1) }, 1, ref dummy);
//ftdi.Write(new byte[] { (byte)(((0xC0 >> 5) & 0xe) | 0) }, 1, ref dummy);
//ftdi.Write(new byte[] { 1 }, 1, ref dummy);
client.Disposed += Client_Disposed;
vsifClients.Add(client);
return(client);
}
}
break;
case VsifSoundModuleType.MSX_FTDI:
{
var ftdi = new FTD2XX_NET.FTDI();
var stat = ftdi.OpenByIndex((uint)comPort);
if (stat == FTDI.FT_STATUS.FT_OK)
{
ftdi.SetBitMode(0x00, FTDI.FT_BIT_MODES.FT_BIT_MODE_RESET);
ftdi.SetBitMode(0xff, FTDI.FT_BIT_MODES.FT_BIT_MODE_ASYNC_BITBANG);
ftdi.SetBaudRate(FTDI_BAUDRATE_MSX * FTDI_BAUDRATE_MSX_MUL);
ftdi.SetTimeouts(500, 500);
ftdi.SetLatency(0);
//{
// uint dummy = 0x00;
// ftdi.Write(new byte[] { (byte)dummy }, 1, ref dummy);
//}
var client = new VsifClient(soundModule, new PortWriterMsx(ftdi, comPort));
client.Disposed += Client_Disposed;
vsifClients.Add(client);
return(client);
}
}
break;
case VsifSoundModuleType.NES_FTDI_INDIRECT:
case VsifSoundModuleType.NES_FTDI_DIRECT:
{
var ftdi = new FTD2XX_NET.FTDI();
var stat = ftdi.OpenByIndex((uint)comPort);
if (stat == FTDI.FT_STATUS.FT_OK)
{
ftdi.SetBitMode(0x00, FTDI.FT_BIT_MODES.FT_BIT_MODE_RESET);
ftdi.SetBitMode(0xff, FTDI.FT_BIT_MODES.FT_BIT_MODE_ASYNC_BITBANG);
ftdi.SetBaudRate(FTDI_BAUDRATE_NES * FTDI_BAUDRATE_NES_MUL);
ftdi.SetTimeouts(500, 500);
ftdi.SetLatency(0);
byte ps = 0;
ftdi.GetPinStates(ref ps);
if ((ps & 0x10) == 0x10)
{
uint dummy = 0;
ftdi.Write(new byte[] { 0x00 }, 1, ref dummy);
}
VsifClient client = null;
switch (soundModule)
{
case VsifSoundModuleType.NES_FTDI_DIRECT:
client = new VsifClient(soundModule, new PortWriterNesDirect(ftdi, comPort));
break;
case VsifSoundModuleType.NES_FTDI_INDIRECT:
client = new VsifClient(soundModule, new PortWriterNesIndirect(ftdi, comPort));
break;
}
client.Disposed += Client_Disposed;
vsifClients.Add(client);
return(client);
}
}
break;
}
//sp.Write(new byte[] { (byte)'M', (byte)'a', (byte)'M', (byte)'i' }, 0, 4);
//sp.BaseStream.WriteByte((byte)soundModule);
//Thread.Sleep(100);
//var ret = sp.BaseStream.ReadByte();
//if (ret == 0x0F) //OK
}
catch (Exception ex)
{
if (ex.GetType() == typeof(Exception))
{
throw;
}
else if (ex.GetType() == typeof(SystemException))
{
throw;
}
}
return(null);
}
}
static void open(FTDI myFtdiDevice)
{
UInt32 ftdiDeviceCount = 0;
FTDI.FT_STATUS ftStatus = FTDI.FT_STATUS.FT_OK;
// Determine the number of FTDI devices connected to the machine
ftStatus = myFtdiDevice.GetNumberOfDevices(ref ftdiDeviceCount);
// Check status
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
return;
}
// If no devices available, return
if (ftdiDeviceCount == 0) return;
Console.WriteLine("Number of FTDI devices: " + ftdiDeviceCount.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);
int oIdx=-1;
if (ftStatus == FTDI.FT_STATUS.FT_OK)
{
for (Int32 i = 0; i < ftdiDeviceCount; i++)
{
if (ftdiDeviceList[i].Type == FTDI.FT_DEVICE.FT_DEVICE_232R)
{
oIdx = i;
}
}
if (oIdx < 0)
{
Console.WriteLine("no matching device");
return;
}
}
Console.WriteLine("Device Index: " + oIdx.ToString());
Console.WriteLine("Flags: " + String.Format("{0:x}", ftdiDeviceList[oIdx].Flags));
Console.WriteLine("Type: " + ftdiDeviceList[oIdx].Type.ToString());
Console.WriteLine("ID: " + String.Format("{0:x}", ftdiDeviceList[oIdx].ID));
Console.WriteLine("Location ID: " + String.Format("{0:x}", ftdiDeviceList[oIdx].LocId));
Console.WriteLine("Serial Number: " + ftdiDeviceList[oIdx].SerialNumber.ToString());
Console.WriteLine("Description: " + ftdiDeviceList[oIdx].Description.ToString());
myFtdiDevice.SetDTR(false);
myFtdiDevice.SetRTS(false);
// Open first device in our list by serial number
ftStatus = myFtdiDevice.OpenBySerialNumber(ftdiDeviceList[oIdx].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;
}
myFtdiDevice.SetDTR(false);
myFtdiDevice.SetRTS(false);
// Set up device data parameters
uint baud = 230400;
if (ConfigurationManager.AppSettings["BaudRate"] != null)
{
baud = UInt32.Parse(ConfigurationManager.AppSettings["BaudRate"]);
}
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, 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;
}
// times out at 100ms
ftStatus = myFtdiDevice.SetTimeouts(100, 100);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
// Wait for a key press
Console.WriteLine("Failed to set timeouts (error " + ftStatus.ToString() + ")");
//Console.ReadKey();
return;
}
attention();
Console.WriteLine("CONNECTED. PRESS ANY KEY TO START.");
Console.WriteLine("CTRL-R: RESET");
Console.WriteLine("CTRL-P: PROGRAM");
Console.WriteLine("CTRL-T: SET TIME");
prompt();
myFtdiDevice.SetDTR(true);
Thread.Sleep(100);
myFtdiDevice.SetDTR(false);
while (true)
{
UInt32 numBytes = 0;
byte[] buf = new byte[1024];
while (Console.KeyAvailable)
{
ConsoleKeyInfo cki = Console.ReadKey(true);
//Console.WriteLine("{0} (character '{1}')", cki.Key, cki.KeyChar);
if ((cki.Modifiers & ConsoleModifiers.Control) != 0)
{
if (cki.Key.ToString().ToUpper().EndsWith("R"))
{
attention();
Console.WriteLine("\nRESET!");
prompt();
myFtdiDevice.SetRTS(false);
myFtdiDevice.SetDTR(true);
Thread.Sleep(100);
myFtdiDevice.SetDTR(false);
continue;
}
if (cki.Key.ToString().ToUpper().EndsWith("P"))
{
attention();
Console.WriteLine("\nPROGRAM MODE:");
myFtdiDevice.Close();
program();
string firmwareName = ConfigurationManager.AppSettings["FirmwareName"];
LpcProgrammer p = new LpcProgrammer(new StringOutDelegate(myStrDelegate));
//p.Prepare();
int r = p.Program(firmwareName);
attention();
Console.WriteLine("\nRETURN VALUE: {0}", r);
subdue();
throw new Exception("Leaving program mode");
}
if (cki.Key.ToString().ToUpper().EndsWith("T"))
{
// Time: 10:11:0
// Date: 2827.5.9
string datePatt = @"yyyy.M.d";
string timePatt = @"HH:mm:ss";
DateTime dispDt = DateTime.Now;
string dtString = "set_date " + dispDt.ToString(datePatt) + "\r";
string tmString = "set_time " + dispDt.ToString(timePatt) + "\r";
//Console.WriteLine(dtString);
//Console.WriteLine(tmString);
System.Text.ASCIIEncoding ASCII = new System.Text.ASCIIEncoding();
Byte[] cmdBytes = ASCII.GetBytes(dtString);
myFtdiDevice.Write(cmdBytes, cmdBytes.Length, ref numBytes);
Thread.Sleep(200);
cmdBytes = ASCII.GetBytes(tmString);
myFtdiDevice.Write(cmdBytes, cmdBytes.Length, ref numBytes);
continue;
}
}
buf[0] = (byte)(cki.KeyChar & 0xff);
numBytes = 0;
ftStatus = myFtdiDevice.Write(buf, 1, ref numBytes);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
throw new Exception("Failed to write to device (error " + ftStatus.ToString() + ")");
//return;
}
}
numBytes = 0;
ftStatus = myFtdiDevice.GetRxBytesAvailable(ref numBytes);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
throw new Exception("Failed to get number of bytes available to read (error " + ftStatus.ToString() + ")");
//return;
}
if (numBytes > 0)
{
UInt32 numBytesRead = 0;
byte[] buffer = new byte[1024];
// Note that the Read method is overloaded, so can read string or byte array data
//ftStatus = myFtdiDevice.Read(out readData, 1024, ref numBytesRead);
ftStatus = myFtdiDevice.Read(buffer, 1024, ref numBytesRead);
if (ftStatus != FTDI.FT_STATUS.FT_OK)
{
// Wait for a key press
throw new Exception("Failed to read data (error " + ftStatus.ToString() + ")");
//Console.ReadKey();
//return;
}
string readData = System.Text.Encoding.ASCII.GetString(buffer, 0, (int)numBytesRead);
Console.Write(readData);
}
else
{
Thread.Sleep(10);
}
}
}
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[1].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_NONE,0,0);
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);
myFtdiDevice.Purge(FTDI.FT_PURGE.FT_PURGE_TX);
if (numBytesWritten != dataToWrite.Length)
{
Console.WriteLine("Error writting");
Console.Read();
return;
}
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);
//Console.WriteLine(ftStatus + " " + 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;
}
void ConnectFTDI()
{
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.NoDevices;
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)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, 1, 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)
{
break;
}
else
{
ftdi.Close();
}
}
}
}
catch(Exception) {
return;
}
Active = true;
if( ftdi.IsOpen ) {
currentMode = (Mode)(tcMainTabs.SelectedIndex + 1);
txBuffer[0] = (byte)currentMode;
uint written = 0;
ftdi.Write( txBuffer, 1, ref written ); // Which mode are we in?
}
// Start my 'tick timer' - It's set to tick every 20 milliseconds
// (used to check the comm port periodically instead of using a thread)
//tickTimer.Start();
}