From 6c2901cb4c08467581d621f10e3433274eda1107 Mon Sep 17 00:00:00 2001 From: "Frank Meier (Mac)" Date: Tue, 16 Jul 2013 22:46:23 -0500 Subject: [PATCH] Neuste Version von Beat: psi46test_20130715 --- win32/FTD2XX.h | 1067 ++++++++++++++++++++++++++++++++++++++++++++++ win32/FTD2XX.lib | Bin 0 -> 19966 bytes win32/rs232.cpp | 185 ++++++++ win32/usb.cpp | 187 ++++++++ win32/usb.h | 57 +++ 5 files changed, 1496 insertions(+) create mode 100644 win32/FTD2XX.h create mode 100644 win32/FTD2XX.lib create mode 100644 win32/rs232.cpp create mode 100644 win32/usb.cpp create mode 100644 win32/usb.h diff --git a/win32/FTD2XX.h b/win32/FTD2XX.h new file mode 100644 index 0000000..6bf632b --- /dev/null +++ b/win32/FTD2XX.h @@ -0,0 +1,1067 @@ +/*++ + +Copyright © 2001-2011 Future Technology Devices International Limited + +THIS SOFTWARE IS PROVIDED BY FUTURE TECHNOLOGY DEVICES INTERNATIONAL LIMITED "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL +FUTURE TECHNOLOGY DEVICES INTERNATIONAL LIMITED BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT +OF SUBSTITUTE GOODS OR SERVICES LOSS OF USE, DATA, OR PROFITS OR BUSINESS INTERRUPTION) +HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR +TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, +EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +FTDI DRIVERS MAY BE USED ONLY IN CONJUNCTION WITH PRODUCTS BASED ON FTDI PARTS. + +FTDI DRIVERS MAY BE DISTRIBUTED IN ANY FORM AS LONG AS LICENSE INFORMATION IS NOT MODIFIED. + +IF A CUSTOM VENDOR ID AND/OR PRODUCT ID OR DESCRIPTION STRING ARE USED, IT IS THE +RESPONSIBILITY OF THE PRODUCT MANUFACTURER TO MAINTAIN ANY CHANGES AND SUBSEQUENT WHQL +RE-CERTIFICATION AS A RESULT OF MAKING THESE CHANGES. + + +Module Name: + +ftd2xx.h + +Abstract: + +Native USB device driver for FTDI FT232x, FT245x, FT2232x and FT4232x devices +FTD2XX library definitions + +Environment: + +kernel & user mode + + +--*/ + + +#ifndef FTD2XX_H +#define FTD2XX_H + +// The following ifdef block is the standard way of creating macros +// which make exporting from a DLL simpler. All files within this DLL +// are compiled with the FTD2XX_EXPORTS symbol defined on the command line. +// This symbol should not be defined on any project that uses this DLL. +// This way any other project whose source files include this file see +// FTD2XX_API functions as being imported from a DLL, whereas this DLL +// sees symbols defined with this macro as being exported. + +#ifdef FTD2XX_EXPORTS +#define FTD2XX_API __declspec(dllexport) +#else +#define FTD2XX_API __declspec(dllimport) +#endif + + +typedef PVOID FT_HANDLE; +typedef ULONG FT_STATUS; + +// +// Device status +// +enum { + FT_OK, + FT_INVALID_HANDLE, + FT_DEVICE_NOT_FOUND, + FT_DEVICE_NOT_OPENED, + FT_IO_ERROR, + FT_INSUFFICIENT_RESOURCES, + FT_INVALID_PARAMETER, + FT_INVALID_BAUD_RATE, + + FT_DEVICE_NOT_OPENED_FOR_ERASE, + FT_DEVICE_NOT_OPENED_FOR_WRITE, + FT_FAILED_TO_WRITE_DEVICE, + FT_EEPROM_READ_FAILED, + FT_EEPROM_WRITE_FAILED, + FT_EEPROM_ERASE_FAILED, + FT_EEPROM_NOT_PRESENT, + FT_EEPROM_NOT_PROGRAMMED, + FT_INVALID_ARGS, + FT_NOT_SUPPORTED, + FT_OTHER_ERROR, + FT_DEVICE_LIST_NOT_READY, +}; + + +#define FT_SUCCESS(status) ((status) == FT_OK) + +// +// FT_OpenEx Flags +// + +#define FT_OPEN_BY_SERIAL_NUMBER 1 +#define FT_OPEN_BY_DESCRIPTION 2 +#define FT_OPEN_BY_LOCATION 4 + +// +// FT_ListDevices Flags (used in conjunction with FT_OpenEx Flags +// + +#define FT_LIST_NUMBER_ONLY 0x80000000 +#define FT_LIST_BY_INDEX 0x40000000 +#define FT_LIST_ALL 0x20000000 + +#define FT_LIST_MASK (FT_LIST_NUMBER_ONLY|FT_LIST_BY_INDEX|FT_LIST_ALL) + +// +// Baud Rates +// + +#define FT_BAUD_300 300 +#define FT_BAUD_600 600 +#define FT_BAUD_1200 1200 +#define FT_BAUD_2400 2400 +#define FT_BAUD_4800 4800 +#define FT_BAUD_9600 9600 +#define FT_BAUD_14400 14400 +#define FT_BAUD_19200 19200 +#define FT_BAUD_38400 38400 +#define FT_BAUD_57600 57600 +#define FT_BAUD_115200 115200 +#define FT_BAUD_230400 230400 +#define FT_BAUD_460800 460800 +#define FT_BAUD_921600 921600 + +// +// Word Lengths +// + +#define FT_BITS_8 (UCHAR) 8 +#define FT_BITS_7 (UCHAR) 7 + +// +// Stop Bits +// + +#define FT_STOP_BITS_1 (UCHAR) 0 +#define FT_STOP_BITS_2 (UCHAR) 2 + +// +// Parity +// + +#define FT_PARITY_NONE (UCHAR) 0 +#define FT_PARITY_ODD (UCHAR) 1 +#define FT_PARITY_EVEN (UCHAR) 2 +#define FT_PARITY_MARK (UCHAR) 3 +#define FT_PARITY_SPACE (UCHAR) 4 + +// +// Flow Control +// + +#define FT_FLOW_NONE 0x0000 +#define FT_FLOW_RTS_CTS 0x0100 +#define FT_FLOW_DTR_DSR 0x0200 +#define FT_FLOW_XON_XOFF 0x0400 + +// +// Purge rx and tx buffers +// +#define FT_PURGE_RX 1 +#define FT_PURGE_TX 2 + +// +// Events +// + +typedef void (*PFT_EVENT_HANDLER)(DWORD,DWORD); + +#define FT_EVENT_RXCHAR 1 +#define FT_EVENT_MODEM_STATUS 2 +#define FT_EVENT_LINE_STATUS 4 + +// +// Timeouts +// + +#define FT_DEFAULT_RX_TIMEOUT 300 +#define FT_DEFAULT_TX_TIMEOUT 300 + +// +// Device types +// + +typedef ULONG FT_DEVICE; + +enum { + FT_DEVICE_BM, + FT_DEVICE_AM, + FT_DEVICE_100AX, + FT_DEVICE_UNKNOWN, + FT_DEVICE_2232C, + FT_DEVICE_232R, + FT_DEVICE_2232H, + FT_DEVICE_4232H, + FT_DEVICE_232H +}; + +// +// Bit Modes +// + +#define FT_BITMODE_RESET 0x00 +#define FT_BITMODE_ASYNC_BITBANG 0x01 +#define FT_BITMODE_MPSSE 0x02 +#define FT_BITMODE_SYNC_BITBANG 0x04 +#define FT_BITMODE_MCU_HOST 0x08 +#define FT_BITMODE_FAST_SERIAL 0x10 +#define FT_BITMODE_CBUS_BITBANG 0x20 +#define FT_BITMODE_SYNC_FIFO 0x40 + +// +// FT232R CBUS Options EEPROM values +// + +#define FT_232R_CBUS_TXDEN 0x00 // Tx Data Enable +#define FT_232R_CBUS_PWRON 0x01 // Power On +#define FT_232R_CBUS_RXLED 0x02 // Rx LED +#define FT_232R_CBUS_TXLED 0x03 // Tx LED +#define FT_232R_CBUS_TXRXLED 0x04 // Tx and Rx LED +#define FT_232R_CBUS_SLEEP 0x05 // Sleep +#define FT_232R_CBUS_CLK48 0x06 // 48MHz clock +#define FT_232R_CBUS_CLK24 0x07 // 24MHz clock +#define FT_232R_CBUS_CLK12 0x08 // 12MHz clock +#define FT_232R_CBUS_CLK6 0x09 // 6MHz clock +#define FT_232R_CBUS_IOMODE 0x0A // IO Mode for CBUS bit-bang +#define FT_232R_CBUS_BITBANG_WR 0x0B // Bit-bang write strobe +#define FT_232R_CBUS_BITBANG_RD 0x0C // Bit-bang read strobe + +// +// FT232H CBUS Options EEPROM values +// + +#define FT_232H_CBUS_TRISTATE 0x00 // Tristate +#define FT_232H_CBUS_RXLED 0x01 // Rx LED +#define FT_232H_CBUS_TXLED 0x02 // Tx LED +#define FT_232H_CBUS_TXRXLED 0x03 // Tx and Rx LED +#define FT_232H_CBUS_PWREN 0x04 // Power Enable +#define FT_232H_CBUS_SLEEP 0x05 // Sleep +#define FT_232H_CBUS_DRIVE_0 0x06 // Drive pin to logic 0 +#define FT_232H_CBUS_DRIVE_1 0x07 // Drive pin to logic 1 +#define FT_232H_CBUS_IOMODE 0x08 // IO Mode for CBUS bit-bang +#define FT_232H_CBUS_TXDEN 0x09 // Tx Data Enable +#define FT_232H_CBUS_CLK30 0x0A // 30MHz clock +#define FT_232H_CBUS_CLK15 0x0B // 15MHz clock +#define FT_232H_CBUS_CLK7_5 0x0C // 7.5MHz clock + + +#ifdef __cplusplus +extern "C" { +#endif + + + FTD2XX_API + FT_STATUS WINAPI FT_Open( + int deviceNumber, + FT_HANDLE *pHandle + ); + + FTD2XX_API + FT_STATUS WINAPI FT_OpenEx( + PVOID pArg1, + DWORD Flags, + FT_HANDLE *pHandle + ); + + FTD2XX_API + FT_STATUS WINAPI FT_ListDevices( + PVOID pArg1, + PVOID pArg2, + DWORD Flags + ); + + FTD2XX_API + FT_STATUS WINAPI FT_Close( + FT_HANDLE ftHandle + ); + + FTD2XX_API + FT_STATUS WINAPI FT_Read( + FT_HANDLE ftHandle, + LPVOID lpBuffer, + DWORD dwBytesToRead, + LPDWORD lpBytesReturned + ); + + FTD2XX_API + FT_STATUS WINAPI FT_Write( + FT_HANDLE ftHandle, + LPVOID lpBuffer, + DWORD dwBytesToWrite, + LPDWORD lpBytesWritten + ); + + FTD2XX_API + FT_STATUS WINAPI FT_IoCtl( + FT_HANDLE ftHandle, + DWORD dwIoControlCode, + LPVOID lpInBuf, + DWORD nInBufSize, + LPVOID lpOutBuf, + DWORD nOutBufSize, + LPDWORD lpBytesReturned, + LPOVERLAPPED lpOverlapped + ); + + FTD2XX_API + FT_STATUS WINAPI FT_SetBaudRate( + FT_HANDLE ftHandle, + ULONG BaudRate + ); + + FTD2XX_API + FT_STATUS WINAPI FT_SetDivisor( + FT_HANDLE ftHandle, + USHORT Divisor + ); + + FTD2XX_API + FT_STATUS WINAPI FT_SetDataCharacteristics( + FT_HANDLE ftHandle, + UCHAR WordLength, + UCHAR StopBits, + UCHAR Parity + ); + + FTD2XX_API + FT_STATUS WINAPI FT_SetFlowControl( + FT_HANDLE ftHandle, + USHORT FlowControl, + UCHAR XonChar, + UCHAR XoffChar + ); + + FTD2XX_API + FT_STATUS WINAPI FT_ResetDevice( + FT_HANDLE ftHandle + ); + + FTD2XX_API + FT_STATUS WINAPI FT_SetDtr( + FT_HANDLE ftHandle + ); + + FTD2XX_API + FT_STATUS WINAPI FT_ClrDtr( + FT_HANDLE ftHandle + ); + + FTD2XX_API + FT_STATUS WINAPI FT_SetRts( + FT_HANDLE ftHandle + ); + + FTD2XX_API + FT_STATUS WINAPI FT_ClrRts( + FT_HANDLE ftHandle + ); + + FTD2XX_API + FT_STATUS WINAPI FT_GetModemStatus( + FT_HANDLE ftHandle, + ULONG *pModemStatus + ); + + FTD2XX_API + FT_STATUS WINAPI FT_SetChars( + FT_HANDLE ftHandle, + UCHAR EventChar, + UCHAR EventCharEnabled, + UCHAR ErrorChar, + UCHAR ErrorCharEnabled + ); + + FTD2XX_API + FT_STATUS WINAPI FT_Purge( + FT_HANDLE ftHandle, + ULONG Mask + ); + + FTD2XX_API + FT_STATUS WINAPI FT_SetTimeouts( + FT_HANDLE ftHandle, + ULONG ReadTimeout, + ULONG WriteTimeout + ); + + FTD2XX_API + FT_STATUS WINAPI FT_GetQueueStatus( + FT_HANDLE ftHandle, + DWORD *dwRxBytes + ); + + FTD2XX_API + FT_STATUS WINAPI FT_SetEventNotification( + FT_HANDLE ftHandle, + DWORD Mask, + PVOID Param + ); + + FTD2XX_API + FT_STATUS WINAPI FT_GetStatus( + FT_HANDLE ftHandle, + DWORD *dwRxBytes, + DWORD *dwTxBytes, + DWORD *dwEventDWord + ); + + FTD2XX_API + FT_STATUS WINAPI FT_SetBreakOn( + FT_HANDLE ftHandle + ); + + FTD2XX_API + FT_STATUS WINAPI FT_SetBreakOff( + FT_HANDLE ftHandle + ); + + FTD2XX_API + FT_STATUS WINAPI FT_SetWaitMask( + FT_HANDLE ftHandle, + DWORD Mask + ); + + FTD2XX_API + FT_STATUS WINAPI FT_WaitOnMask( + FT_HANDLE ftHandle, + DWORD *Mask + ); + + FTD2XX_API + FT_STATUS WINAPI FT_GetEventStatus( + FT_HANDLE ftHandle, + DWORD *dwEventDWord + ); + + FTD2XX_API + FT_STATUS WINAPI FT_ReadEE( + FT_HANDLE ftHandle, + DWORD dwWordOffset, + LPWORD lpwValue + ); + + FTD2XX_API + FT_STATUS WINAPI FT_WriteEE( + FT_HANDLE ftHandle, + DWORD dwWordOffset, + WORD wValue + ); + + FTD2XX_API + FT_STATUS WINAPI FT_EraseEE( + FT_HANDLE ftHandle + ); + + // + // structure to hold program data for FT_Program function + // + typedef struct ft_program_data { + + DWORD Signature1; // Header - must be 0x00000000 + DWORD Signature2; // Header - must be 0xffffffff + DWORD Version; // Header - FT_PROGRAM_DATA version + // 0 = original + // 1 = FT2232C extensions + // 2 = FT232R extensions + // 3 = FT2232H extensions + // 4 = FT4232H extensions + // 5 = FT232H extensions + + WORD VendorId; // 0x0403 + WORD ProductId; // 0x6001 + char *Manufacturer; // "FTDI" + char *ManufacturerId; // "FT" + char *Description; // "USB HS Serial Converter" + char *SerialNumber; // "FT000001" if fixed, or NULL + WORD MaxPower; // 0 < MaxPower <= 500 + WORD PnP; // 0 = disabled, 1 = enabled + WORD SelfPowered; // 0 = bus powered, 1 = self powered + WORD RemoteWakeup; // 0 = not capable, 1 = capable + // + // Rev4 (FT232B) extensions + // + UCHAR Rev4; // non-zero if Rev4 chip, zero otherwise + UCHAR IsoIn; // non-zero if in endpoint is isochronous + UCHAR IsoOut; // non-zero if out endpoint is isochronous + UCHAR PullDownEnable; // non-zero if pull down enabled + UCHAR SerNumEnable; // non-zero if serial number to be used + UCHAR USBVersionEnable; // non-zero if chip uses USBVersion + WORD USBVersion; // BCD (0x0200 => USB2) + // + // Rev 5 (FT2232) extensions + // + UCHAR Rev5; // non-zero if Rev5 chip, zero otherwise + UCHAR IsoInA; // non-zero if in endpoint is isochronous + UCHAR IsoInB; // non-zero if in endpoint is isochronous + UCHAR IsoOutA; // non-zero if out endpoint is isochronous + UCHAR IsoOutB; // non-zero if out endpoint is isochronous + UCHAR PullDownEnable5; // non-zero if pull down enabled + UCHAR SerNumEnable5; // non-zero if serial number to be used + UCHAR USBVersionEnable5; // non-zero if chip uses USBVersion + WORD USBVersion5; // BCD (0x0200 => USB2) + UCHAR AIsHighCurrent; // non-zero if interface is high current + UCHAR BIsHighCurrent; // non-zero if interface is high current + UCHAR IFAIsFifo; // non-zero if interface is 245 FIFO + UCHAR IFAIsFifoTar; // non-zero if interface is 245 FIFO CPU target + UCHAR IFAIsFastSer; // non-zero if interface is Fast serial + UCHAR AIsVCP; // non-zero if interface is to use VCP drivers + UCHAR IFBIsFifo; // non-zero if interface is 245 FIFO + UCHAR IFBIsFifoTar; // non-zero if interface is 245 FIFO CPU target + UCHAR IFBIsFastSer; // non-zero if interface is Fast serial + UCHAR BIsVCP; // non-zero if interface is to use VCP drivers + // + // Rev 6 (FT232R) extensions + // + UCHAR UseExtOsc; // Use External Oscillator + UCHAR HighDriveIOs; // High Drive I/Os + UCHAR EndpointSize; // Endpoint size + UCHAR PullDownEnableR; // non-zero if pull down enabled + UCHAR SerNumEnableR; // non-zero if serial number to be used + UCHAR InvertTXD; // non-zero if invert TXD + UCHAR InvertRXD; // non-zero if invert RXD + UCHAR InvertRTS; // non-zero if invert RTS + UCHAR InvertCTS; // non-zero if invert CTS + UCHAR InvertDTR; // non-zero if invert DTR + UCHAR InvertDSR; // non-zero if invert DSR + UCHAR InvertDCD; // non-zero if invert DCD + UCHAR InvertRI; // non-zero if invert RI + UCHAR Cbus0; // Cbus Mux control + UCHAR Cbus1; // Cbus Mux control + UCHAR Cbus2; // Cbus Mux control + UCHAR Cbus3; // Cbus Mux control + UCHAR Cbus4; // Cbus Mux control + UCHAR RIsD2XX; // non-zero if using D2XX driver + // + // Rev 7 (FT2232H) Extensions + // + UCHAR PullDownEnable7; // non-zero if pull down enabled + UCHAR SerNumEnable7; // non-zero if serial number to be used + UCHAR ALSlowSlew; // non-zero if AL pins have slow slew + UCHAR ALSchmittInput; // non-zero if AL pins are Schmitt input + UCHAR ALDriveCurrent; // valid values are 4mA, 8mA, 12mA, 16mA + UCHAR AHSlowSlew; // non-zero if AH pins have slow slew + UCHAR AHSchmittInput; // non-zero if AH pins are Schmitt input + UCHAR AHDriveCurrent; // valid values are 4mA, 8mA, 12mA, 16mA + UCHAR BLSlowSlew; // non-zero if BL pins have slow slew + UCHAR BLSchmittInput; // non-zero if BL pins are Schmitt input + UCHAR BLDriveCurrent; // valid values are 4mA, 8mA, 12mA, 16mA + UCHAR BHSlowSlew; // non-zero if BH pins have slow slew + UCHAR BHSchmittInput; // non-zero if BH pins are Schmitt input + UCHAR BHDriveCurrent; // valid values are 4mA, 8mA, 12mA, 16mA + UCHAR IFAIsFifo7; // non-zero if interface is 245 FIFO + UCHAR IFAIsFifoTar7; // non-zero if interface is 245 FIFO CPU target + UCHAR IFAIsFastSer7; // non-zero if interface is Fast serial + UCHAR AIsVCP7; // non-zero if interface is to use VCP drivers + UCHAR IFBIsFifo7; // non-zero if interface is 245 FIFO + UCHAR IFBIsFifoTar7; // non-zero if interface is 245 FIFO CPU target + UCHAR IFBIsFastSer7; // non-zero if interface is Fast serial + UCHAR BIsVCP7; // non-zero if interface is to use VCP drivers + UCHAR PowerSaveEnable; // non-zero if using BCBUS7 to save power for self-powered designs + // + // Rev 8 (FT4232H) Extensions + // + UCHAR PullDownEnable8; // non-zero if pull down enabled + UCHAR SerNumEnable8; // non-zero if serial number to be used + UCHAR ASlowSlew; // non-zero if AL pins have slow slew + UCHAR ASchmittInput; // non-zero if AL pins are Schmitt input + UCHAR ADriveCurrent; // valid values are 4mA, 8mA, 12mA, 16mA + UCHAR BSlowSlew; // non-zero if AH pins have slow slew + UCHAR BSchmittInput; // non-zero if AH pins are Schmitt input + UCHAR BDriveCurrent; // valid values are 4mA, 8mA, 12mA, 16mA + UCHAR CSlowSlew; // non-zero if BL pins have slow slew + UCHAR CSchmittInput; // non-zero if BL pins are Schmitt input + UCHAR CDriveCurrent; // valid values are 4mA, 8mA, 12mA, 16mA + UCHAR DSlowSlew; // non-zero if BH pins have slow slew + UCHAR DSchmittInput; // non-zero if BH pins are Schmitt input + UCHAR DDriveCurrent; // valid values are 4mA, 8mA, 12mA, 16mA + UCHAR ARIIsTXDEN; // non-zero if port A uses RI as RS485 TXDEN + UCHAR BRIIsTXDEN; // non-zero if port B uses RI as RS485 TXDEN + UCHAR CRIIsTXDEN; // non-zero if port C uses RI as RS485 TXDEN + UCHAR DRIIsTXDEN; // non-zero if port D uses RI as RS485 TXDEN + UCHAR AIsVCP8; // non-zero if interface is to use VCP drivers + UCHAR BIsVCP8; // non-zero if interface is to use VCP drivers + UCHAR CIsVCP8; // non-zero if interface is to use VCP drivers + UCHAR DIsVCP8; // non-zero if interface is to use VCP drivers + // + // Rev 9 (FT232H) Extensions + // + UCHAR PullDownEnableH; // non-zero if pull down enabled + UCHAR SerNumEnableH; // non-zero if serial number to be used + UCHAR ACSlowSlewH; // non-zero if AC pins have slow slew + UCHAR ACSchmittInputH; // non-zero if AC pins are Schmitt input + UCHAR ACDriveCurrentH; // valid values are 4mA, 8mA, 12mA, 16mA + UCHAR ADSlowSlewH; // non-zero if AD pins have slow slew + UCHAR ADSchmittInputH; // non-zero if AD pins are Schmitt input + UCHAR ADDriveCurrentH; // valid values are 4mA, 8mA, 12mA, 16mA + UCHAR Cbus0H; // Cbus Mux control + UCHAR Cbus1H; // Cbus Mux control + UCHAR Cbus2H; // Cbus Mux control + UCHAR Cbus3H; // Cbus Mux control + UCHAR Cbus4H; // Cbus Mux control + UCHAR Cbus5H; // Cbus Mux control + UCHAR Cbus6H; // Cbus Mux control + UCHAR Cbus7H; // Cbus Mux control + UCHAR Cbus8H; // Cbus Mux control + UCHAR Cbus9H; // Cbus Mux control + UCHAR IsFifoH; // non-zero if interface is 245 FIFO + UCHAR IsFifoTarH; // non-zero if interface is 245 FIFO CPU target + UCHAR IsFastSerH; // non-zero if interface is Fast serial + UCHAR IsFT1248H; // non-zero if interface is FT1248 + UCHAR FT1248CpolH; // FT1248 clock polarity - clock idle high (1) or clock idle low (0) + UCHAR FT1248LsbH; // FT1248 data is LSB (1) or MSB (0) + UCHAR FT1248FlowControlH; // FT1248 flow control enable + UCHAR IsVCPH; // non-zero if interface is to use VCP drivers + UCHAR PowerSaveEnableH; // non-zero if using ACBUS7 to save power for self-powered designs + + } FT_PROGRAM_DATA, *PFT_PROGRAM_DATA; + + FTD2XX_API + FT_STATUS WINAPI FT_EE_Program( + FT_HANDLE ftHandle, + PFT_PROGRAM_DATA pData + ); + + FTD2XX_API + FT_STATUS WINAPI FT_EE_ProgramEx( + FT_HANDLE ftHandle, + PFT_PROGRAM_DATA pData, + char *Manufacturer, + char *ManufacturerId, + char *Description, + char *SerialNumber + ); + + FTD2XX_API + FT_STATUS WINAPI FT_EE_Read( + FT_HANDLE ftHandle, + PFT_PROGRAM_DATA pData + ); + + FTD2XX_API + FT_STATUS WINAPI FT_EE_ReadEx( + FT_HANDLE ftHandle, + PFT_PROGRAM_DATA pData, + char *Manufacturer, + char *ManufacturerId, + char *Description, + char *SerialNumber + ); + + FTD2XX_API + FT_STATUS WINAPI FT_EE_UASize( + FT_HANDLE ftHandle, + LPDWORD lpdwSize + ); + + FTD2XX_API + FT_STATUS WINAPI FT_EE_UAWrite( + FT_HANDLE ftHandle, + PUCHAR pucData, + DWORD dwDataLen + ); + + FTD2XX_API + FT_STATUS WINAPI FT_EE_UARead( + FT_HANDLE ftHandle, + PUCHAR pucData, + DWORD dwDataLen, + LPDWORD lpdwBytesRead + ); + + FTD2XX_API + FT_STATUS WINAPI FT_SetLatencyTimer( + FT_HANDLE ftHandle, + UCHAR ucLatency + ); + + FTD2XX_API + FT_STATUS WINAPI FT_GetLatencyTimer( + FT_HANDLE ftHandle, + PUCHAR pucLatency + ); + + FTD2XX_API + FT_STATUS WINAPI FT_SetBitMode( + FT_HANDLE ftHandle, + UCHAR ucMask, + UCHAR ucEnable + ); + + FTD2XX_API + FT_STATUS WINAPI FT_GetBitMode( + FT_HANDLE ftHandle, + PUCHAR pucMode + ); + + FTD2XX_API + FT_STATUS WINAPI FT_SetUSBParameters( + FT_HANDLE ftHandle, + ULONG ulInTransferSize, + ULONG ulOutTransferSize + ); + + FTD2XX_API + FT_STATUS WINAPI FT_SetDeadmanTimeout( + FT_HANDLE ftHandle, + ULONG ulDeadmanTimeout + ); + + FTD2XX_API + FT_STATUS WINAPI FT_GetDeviceInfo( + FT_HANDLE ftHandle, + FT_DEVICE *lpftDevice, + LPDWORD lpdwID, + PCHAR SerialNumber, + PCHAR Description, + LPVOID Dummy + ); + + FTD2XX_API + FT_STATUS WINAPI FT_StopInTask( + FT_HANDLE ftHandle + ); + + FTD2XX_API + FT_STATUS WINAPI FT_RestartInTask( + FT_HANDLE ftHandle + ); + + FTD2XX_API + FT_STATUS WINAPI FT_SetResetPipeRetryCount( + FT_HANDLE ftHandle, + DWORD dwCount + ); + + FTD2XX_API + FT_STATUS WINAPI FT_ResetPort( + FT_HANDLE ftHandle + ); + + FTD2XX_API + FT_STATUS WINAPI FT_CyclePort( + FT_HANDLE ftHandle + ); + + + // + // Win32-type functions + // + + FTD2XX_API + FT_HANDLE WINAPI FT_W32_CreateFile( + LPCTSTR lpszName, + DWORD dwAccess, + DWORD dwShareMode, + LPSECURITY_ATTRIBUTES lpSecurityAttributes, + DWORD dwCreate, + DWORD dwAttrsAndFlags, + HANDLE hTemplate + ); + + FTD2XX_API + BOOL WINAPI FT_W32_CloseHandle( + FT_HANDLE ftHandle + ); + + FTD2XX_API + BOOL WINAPI FT_W32_ReadFile( + FT_HANDLE ftHandle, + LPVOID lpBuffer, + DWORD nBufferSize, + LPDWORD lpBytesReturned, + LPOVERLAPPED lpOverlapped + ); + + FTD2XX_API + BOOL WINAPI FT_W32_WriteFile( + FT_HANDLE ftHandle, + LPVOID lpBuffer, + DWORD nBufferSize, + LPDWORD lpBytesWritten, + LPOVERLAPPED lpOverlapped + ); + + FTD2XX_API + DWORD WINAPI FT_W32_GetLastError( + FT_HANDLE ftHandle + ); + + FTD2XX_API + BOOL WINAPI FT_W32_GetOverlappedResult( + FT_HANDLE ftHandle, + LPOVERLAPPED lpOverlapped, + LPDWORD lpdwBytesTransferred, + BOOL bWait + ); + + FTD2XX_API + BOOL WINAPI FT_W32_CancelIo( + FT_HANDLE ftHandle + ); + + + // + // Win32 COMM API type functions + // + typedef struct _FTCOMSTAT { + DWORD fCtsHold : 1; + DWORD fDsrHold : 1; + DWORD fRlsdHold : 1; + DWORD fXoffHold : 1; + DWORD fXoffSent : 1; + DWORD fEof : 1; + DWORD fTxim : 1; + DWORD fReserved : 25; + DWORD cbInQue; + DWORD cbOutQue; + } FTCOMSTAT, *LPFTCOMSTAT; + + typedef struct _FTDCB { + DWORD DCBlength; /* sizeof(FTDCB) */ + DWORD BaudRate; /* Baudrate at which running */ + DWORD fBinary: 1; /* Binary Mode (skip EOF check) */ + DWORD fParity: 1; /* Enable parity checking */ + DWORD fOutxCtsFlow:1; /* CTS handshaking on output */ + DWORD fOutxDsrFlow:1; /* DSR handshaking on output */ + DWORD fDtrControl:2; /* DTR Flow control */ + DWORD fDsrSensitivity:1; /* DSR Sensitivity */ + DWORD fTXContinueOnXoff: 1; /* Continue TX when Xoff sent */ + DWORD fOutX: 1; /* Enable output X-ON/X-OFF */ + DWORD fInX: 1; /* Enable input X-ON/X-OFF */ + DWORD fErrorChar: 1; /* Enable Err Replacement */ + DWORD fNull: 1; /* Enable Null stripping */ + DWORD fRtsControl:2; /* Rts Flow control */ + DWORD fAbortOnError:1; /* Abort all reads and writes on Error */ + DWORD fDummy2:17; /* Reserved */ + WORD wReserved; /* Not currently used */ + WORD XonLim; /* Transmit X-ON threshold */ + WORD XoffLim; /* Transmit X-OFF threshold */ + BYTE ByteSize; /* Number of bits/byte, 4-8 */ + BYTE Parity; /* 0-4=None,Odd,Even,Mark,Space */ + BYTE StopBits; /* 0,1,2 = 1, 1.5, 2 */ + char XonChar; /* Tx and Rx X-ON character */ + char XoffChar; /* Tx and Rx X-OFF character */ + char ErrorChar; /* Error replacement char */ + char EofChar; /* End of Input character */ + char EvtChar; /* Received Event character */ + WORD wReserved1; /* Fill for now. */ + } FTDCB, *LPFTDCB; + + typedef struct _FTTIMEOUTS { + DWORD ReadIntervalTimeout; /* Maximum time between read chars. */ + DWORD ReadTotalTimeoutMultiplier; /* Multiplier of characters. */ + DWORD ReadTotalTimeoutConstant; /* Constant in milliseconds. */ + DWORD WriteTotalTimeoutMultiplier; /* Multiplier of characters. */ + DWORD WriteTotalTimeoutConstant; /* Constant in milliseconds. */ + } FTTIMEOUTS,*LPFTTIMEOUTS; + + + FTD2XX_API + BOOL WINAPI FT_W32_ClearCommBreak( + FT_HANDLE ftHandle + ); + + FTD2XX_API + BOOL WINAPI FT_W32_ClearCommError( + FT_HANDLE ftHandle, + LPDWORD lpdwErrors, + LPFTCOMSTAT lpftComstat + ); + + FTD2XX_API + BOOL WINAPI FT_W32_EscapeCommFunction( + FT_HANDLE ftHandle, + DWORD dwFunc + ); + + FTD2XX_API + BOOL WINAPI FT_W32_GetCommModemStatus( + FT_HANDLE ftHandle, + LPDWORD lpdwModemStatus + ); + + FTD2XX_API + BOOL WINAPI FT_W32_GetCommState( + FT_HANDLE ftHandle, + LPFTDCB lpftDcb + ); + + FTD2XX_API + BOOL WINAPI FT_W32_GetCommTimeouts( + FT_HANDLE ftHandle, + FTTIMEOUTS *pTimeouts + ); + + FTD2XX_API + BOOL WINAPI FT_W32_PurgeComm( + FT_HANDLE ftHandle, + DWORD dwMask + ); + + FTD2XX_API + BOOL WINAPI FT_W32_SetCommBreak( + FT_HANDLE ftHandle + ); + + FTD2XX_API + BOOL WINAPI FT_W32_SetCommMask( + FT_HANDLE ftHandle, + ULONG ulEventMask + ); + + FTD2XX_API + BOOL WINAPI FT_W32_GetCommMask( + FT_HANDLE ftHandle, + LPDWORD lpdwEventMask + ); + + FTD2XX_API + BOOL WINAPI FT_W32_SetCommState( + FT_HANDLE ftHandle, + LPFTDCB lpftDcb + ); + + FTD2XX_API + BOOL WINAPI FT_W32_SetCommTimeouts( + FT_HANDLE ftHandle, + FTTIMEOUTS *pTimeouts + ); + + FTD2XX_API + BOOL WINAPI FT_W32_SetupComm( + FT_HANDLE ftHandle, + DWORD dwReadBufferSize, + DWORD dwWriteBufferSize + ); + + FTD2XX_API + BOOL WINAPI FT_W32_WaitCommEvent( + FT_HANDLE ftHandle, + PULONG pulEvent, + LPOVERLAPPED lpOverlapped + ); + + + // + // Device information + // + + typedef struct _ft_device_list_info_node { + ULONG Flags; + ULONG Type; + ULONG ID; + DWORD LocId; + char SerialNumber[16]; + char Description[64]; + FT_HANDLE ftHandle; + } FT_DEVICE_LIST_INFO_NODE; + + // Device information flags + enum { + FT_FLAGS_OPENED = 1, + FT_FLAGS_HISPEED = 2 + }; + + + FTD2XX_API + FT_STATUS WINAPI FT_CreateDeviceInfoList( + LPDWORD lpdwNumDevs + ); + + FTD2XX_API + FT_STATUS WINAPI FT_GetDeviceInfoList( + FT_DEVICE_LIST_INFO_NODE *pDest, + LPDWORD lpdwNumDevs + ); + + FTD2XX_API + FT_STATUS WINAPI FT_GetDeviceInfoDetail( + DWORD dwIndex, + LPDWORD lpdwFlags, + LPDWORD lpdwType, + LPDWORD lpdwID, + LPDWORD lpdwLocId, + LPVOID lpSerialNumber, + LPVOID lpDescription, + FT_HANDLE *pftHandle + ); + + + // + // Version information + // + + FTD2XX_API + FT_STATUS WINAPI FT_GetDriverVersion( + FT_HANDLE ftHandle, + LPDWORD lpdwVersion + ); + + FTD2XX_API + FT_STATUS WINAPI FT_GetLibraryVersion( + LPDWORD lpdwVersion + ); + + + FTD2XX_API + FT_STATUS WINAPI FT_Rescan( + void + ); + + FTD2XX_API + FT_STATUS WINAPI FT_Reload( + WORD wVid, + WORD wPid + ); + + FTD2XX_API + FT_STATUS WINAPI FT_GetComPortNumber( + FT_HANDLE ftHandle, + LPLONG lpdwComPortNumber + ); + + + // + // FT232H additional EEPROM functions + // + + FTD2XX_API + FT_STATUS WINAPI FT_EE_ReadConfig( + FT_HANDLE ftHandle, + UCHAR ucAddress, + PUCHAR pucValue + ); + + FTD2XX_API + FT_STATUS WINAPI FT_EE_WriteConfig( + FT_HANDLE ftHandle, + UCHAR ucAddress, + UCHAR ucValue + ); + + FTD2XX_API + FT_STATUS WINAPI FT_EE_ReadECC( + FT_HANDLE ftHandle, + UCHAR ucOption, + LPWORD lpwValue + ); + + FTD2XX_API + FT_STATUS WINAPI FT_GetQueueStatusEx( + FT_HANDLE ftHandle, + DWORD *dwRxBytes + ); + + +#ifdef __cplusplus +} +#endif + + +#endif /* FTD2XX_H */ + diff --git a/win32/FTD2XX.lib b/win32/FTD2XX.lib new file mode 100644 index 0000000000000000000000000000000000000000..bccb53be93e9a4d1957a38e45be137d35631a64c GIT binary patch literal 19966 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 literal 0 HcmV?d00001 diff --git a/win32/rs232.cpp b/win32/rs232.cpp new file mode 100644 index 0000000..30a8c64 --- /dev/null +++ b/win32/rs232.cpp @@ -0,0 +1,185 @@ +// rs232.cpp +// dummy + + +#include +#include +#include +#include +#include + + + +int rs232_open(int portNr, int baud, char parity, + int data_bit, int stop_bit, int flow_control) +{ + if (portNr < 0 && 99 < portNr) return -1; + + HANDLE hComm; + char comport[8]; + sprintf(comport,"COM%i",portNr+1); + hComm = CreateFile(comport, GENERIC_READ | GENERIC_WRITE, + 0, // exclusive-access + NULL, // no security attributes + OPEN_EXISTING, // comm devices must use OPEN_EXISTING + 0, // not overlapped I/O + NULL); // hTemplate must be NULL for comm devices + if (hComm == INVALID_HANDLE_VALUE) return -1; + + DCB commDCB; + if (!GetCommState(hComm,&commDCB)) + { CloseHandle(hComm); return -1; } + + const struct { int speed, code; } baud_table[] = + { + { 300,CBR_300 }, + { 600,CBR_600 }, + { 1200,CBR_1200 }, + { 2400,CBR_2400 }, + { 4800,CBR_4800 }, + { 9600,CBR_9600 }, + {19200,CBR_19200}, + {38400,CBR_38400}, + {0,0} + }; + int i=0; + int baudrate = CBR_9600; + while (baud_table[i].speed) + { + if (baud_table[i].speed == baud) { baudrate = baud_table[i].code; break; } + i++; + } + + commDCB.BaudRate = baudrate; // current baud rate + commDCB.fBinary = true; // binary mode, no EOF check + commDCB.fParity = false; // enable parity checking + commDCB.fOutxCtsFlow = false; // CTS output flow control + commDCB.fOutxDsrFlow = false; // DSR output flow control + commDCB.fDtrControl = DTR_CONTROL_DISABLE; // DTR flow control type + commDCB.fDsrSensitivity = false; // DSR sensitivity + commDCB.fTXContinueOnXoff = false; // XOFF continues Tx + commDCB.fOutX = false; // XON/XOFF out flow control + commDCB.fInX = false; // XON/XOFF in flow control + commDCB.fErrorChar = false; // enable error replacement + commDCB.fNull = false; // enable null stripping + commDCB.fRtsControl = RTS_CONTROL_DISABLE; // RTS flow control + commDCB.fAbortOnError = false; // abort on error + commDCB.XonLim = 0; // transmit XON threshold + commDCB.XoffLim = 0; // transmit XOFF threshold + commDCB.ByteSize = 8; // number of bits/byte, 4-8 + commDCB.Parity = NOPARITY; // 0-4=no,odd,even,mark,space + commDCB.StopBits = ONESTOPBIT; // 0,1,2 = 1, 1.5, 2 + + if (!SetCommState(hComm,&commDCB)) + { + DWORD le = GetLastError(); + CloseHandle(hComm); + return -1; + } + + SetupComm(hComm,600,600); + + COMMTIMEOUTS timeout; + timeout.ReadIntervalTimeout = 100; // ms + timeout.ReadTotalTimeoutMultiplier = 0; + timeout.ReadTotalTimeoutConstant = 100; + timeout.WriteTotalTimeoutMultiplier = 0; + timeout.WriteTotalTimeoutConstant = 0; + if (!SetCommTimeouts(hComm,&timeout)) + { CloseHandle(hComm); return -1; } + + return (int)hComm; +} + + +int rs232_exit(int fd) +{ + CloseHandle((HANDLE)fd); + return 0; +} + + +int rs232_write(int fd, char *data, int size) +{ + if (fd == -1) return 0; + unsigned long bytesWritten; + WriteFile((HANDLE)fd, data, size, &bytesWritten, NULL); + + return (int)bytesWritten; +} + + +int rs232_puts(int fd, char *str) +{ + return rs232_write(fd,str,strlen(str)); +} + + +int rs232_gets(int fd, char *str, int size, char *pattern, int timeout) +{ + int l; + unsigned long i; + if (fd == -1) return 0; + + struct _timeb start, now; + double fstart, fnow; + + _ftime(&start); + fstart = start.time+start.millitm/1000.0; + + + memset(str, 0, size); + for (l=0; l0) + { + l += i; + if (pattern && pattern[0]) + if (strstr(str, pattern) != NULL) break; + } + + _ftime(&now); + fnow = now.time+now.millitm/1000.0; + + if ((fnow - fstart) >= timeout/1000.0) + { + if (pattern && pattern[0]) return 0; + break; + } + } + return l; +} + + +void rs232_clearRx(int fd) +{ + if (fd == -1) return; + PurgeComm((HANDLE)fd, PURGE_RXABORT|PURGE_RXCLEAR); +} + + +void rs232_clearTx(int fd) +{ + if (fd == -1) return; + PurgeComm((HANDLE)fd, PURGE_TXABORT|PURGE_TXCLEAR); +} + + +void rs232_clear(int fd) +{ + if (fd == -1) return; + PurgeComm((HANDLE)fd, PURGE_TXABORT|PURGE_RXABORT| + PURGE_TXCLEAR|PURGE_RXCLEAR); +} + + +void rs232_setStatus(int fd, bool rts, bool cts) +{ + if (fd == -1) return; + DCB commDCB; + if (!GetCommState((HANDLE)fd,&commDCB)) return; + commDCB.fRtsControl = (rts ? RTS_CONTROL_ENABLE : RTS_CONTROL_DISABLE); + commDCB.fDtrControl = (cts ? DTR_CONTROL_ENABLE : DTR_CONTROL_DISABLE); + SetCommState((HANDLE)fd,&commDCB); +} diff --git a/win32/usb.cpp b/win32/usb.cpp new file mode 100644 index 0000000..89666ad --- /dev/null +++ b/win32/usb.cpp @@ -0,0 +1,187 @@ +// usb.cpp + + +#include "..\rpc_error.h" +#include "usb.h" +#include "FTD2XX.h" + + + +const char* CUSB::GetErrorMsg(int error) +{ + switch (error) + { + case FT_OK: return "ok"; + case FT_INVALID_HANDLE: return "invalid handle"; + case FT_DEVICE_NOT_FOUND: return "device not found"; + case FT_DEVICE_NOT_OPENED: return "device not opened"; + case FT_IO_ERROR: return "io error"; + case FT_INSUFFICIENT_RESOURCES: return "insufficient resource"; + case FT_INVALID_PARAMETER: return "invalid parameter"; + case FT_INVALID_BAUD_RATE: return "invalid baud rate"; + case FT_DEVICE_NOT_OPENED_FOR_ERASE: return "device not opened for erase"; + case FT_DEVICE_NOT_OPENED_FOR_WRITE: return "device not opened for write"; + case FT_FAILED_TO_WRITE_DEVICE: return "failed to write device"; + case FT_EEPROM_READ_FAILED: return "eeprom read failed"; + case FT_EEPROM_WRITE_FAILED: return "eeprom write failed"; + case FT_EEPROM_ERASE_FAILED: return "eeprom erase failed"; + case FT_EEPROM_NOT_PRESENT: return "eeprom not present"; + case FT_EEPROM_NOT_PROGRAMMED: return "eeprom not programmed"; + case FT_INVALID_ARGS: return "invalid args"; + case FT_NOT_SUPPORTED: return "not supported"; + case FT_OTHER_ERROR: return "other error"; + } + return "unknown error"; +} + + +bool CUSB::EnumFirst(unsigned int &nDevices) +{ + ftStatus = FT_ListDevices(&enumCount, + NULL,FT_LIST_NUMBER_ONLY|FT_OPEN_BY_SERIAL_NUMBER); + if (ftStatus != FT_OK) + { + nDevices = enumCount = enumPos = 0; + return false; + } + + nDevices = enumCount; + enumPos = 0; + return true; +} + + +bool CUSB::EnumNext(char name[]) +{ + if (enumPos >= enumCount) return false; + ftStatus = FT_ListDevices((PVOID)enumPos, name, FT_LIST_BY_INDEX); + if (ftStatus != FT_OK) + { + enumCount = enumPos = 0; + return false; + } + + enumPos++; + return true; +} + + +bool CUSB::Open(char serialNumber[]) +{ + if (isUSB_open) { ftStatus = FT_DEVICE_NOT_OPENED; return false; } + + m_posR = m_sizeR = m_posW = 0; + ftStatus = FT_OpenEx(serialNumber, FT_OPEN_BY_SERIAL_NUMBER, &ftHandle); + if (ftStatus != FT_OK) return false; + + ftStatus = FT_SetBitMode(ftHandle, 0xFF, 0x40); + if (ftStatus != FT_OK) return false; + + FT_SetTimeouts(ftHandle,1000,1000); + isUSB_open = true; + return true; +} + + +void CUSB::Close() +{ + if (!isUSB_open) return; + FT_Close(ftHandle); + isUSB_open = 0; +} + + +void CUSB::Write(const void *buffer, unsigned int bytesToWrite) +{ + if (!isUSB_open) throw RpcError(RpcError::WRITE_ERROR); + + unsigned long k=0; + for (k=0; k < bytesToWrite; k++) + { + if (m_posW >= USBWRITEBUFFERSIZE) Flush(); + m_bufferW[m_posW++] = ((unsigned char*)buffer)[k]; + } +} + + +void CUSB::Flush() +{ + unsigned long bytesWritten; + unsigned long bytesToWrite = m_posW; + m_posW = 0; + + if (!isUSB_open) throw RpcError(RpcError::WRITE_ERROR); + + if (!bytesToWrite) return; + + ftStatus = FT_Write(ftHandle, m_bufferW, bytesToWrite, &bytesWritten); + + if (ftStatus != FT_OK) throw RpcError(RpcError::WRITE_ERROR); + if (bytesWritten != bytesToWrite) { ftStatus = FT_IO_ERROR; throw RpcError(RpcError::WRITE_ERROR); } +} + + +bool CUSB::FillBuffer(unsigned long minBytesToRead) +{ + if (!isUSB_open) return false; + + unsigned long bytesAvailable, bytesToRead; + + ftStatus = FT_GetQueueStatus(ftHandle, &bytesAvailable); + if (ftStatus != FT_OK) return false; + + if (m_posRminBytesToRead)? bytesAvailable : minBytesToRead; + if (bytesToRead>USBREADBUFFERSIZE) bytesToRead = USBREADBUFFERSIZE; + + ftStatus = FT_Read(ftHandle, m_bufferR, bytesToRead, &m_sizeR); + m_posR = 0; + if (ftStatus != FT_OK) + { + m_sizeR = 0; + return false; + } + return true; +} + + +void CUSB::Read(void *buffer, unsigned int bytesToRead) +{ + if (!isUSB_open) throw RpcError(RpcError::READ_ERROR); + + unsigned long i; + + for (i=0; iUSBREADBUFFERSIZE) n = USBREADBUFFERSIZE; + + if (!FillBuffer(n)) throw RpcError(RpcError::READ_ERROR); + if (m_sizeR < n) throw RpcError(RpcError::READ_ERROR); + + if (m_posR