Ryan Malloy
a7f62e5d7e
- Library source from AN721SW (cp210xmanufacturing_1.0.tar.gz) - Manufacturing tool source (cp210xsmt) - Builds 64-bit shared library with: make LIB_ARCH=64 - Datasheets and app notes in docs/
466 lines
16 KiB
C
466 lines
16 KiB
C
/////////////////////////////////////////////////////////////////////////////
|
|
// SLABHIDtoUART.h
|
|
// For SLABHIDtoUART.dll
|
|
// and Silicon Labs CP2110/CP2114 HID to UART
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
#ifndef SLAB_HID_TO_UART_H
|
|
#define SLAB_HID_TO_UART_H
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Includes
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
#include "Types.h"
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Tool-chain-dependent hacks
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
#ifdef _WIN32
|
|
// 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 HID_TO_UART_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
|
|
// HID_TO_UART_API functions as being imported from a DLL, whereas this DLL sees symbols
|
|
// defined with this macro as being exported.
|
|
#if defined(HID_TO_UART_EXPORTS)
|
|
#define HID_TO_UART_API __declspec(dllexport)
|
|
#else
|
|
#define HID_TO_UART_API __declspec(dllimport)
|
|
#pragma comment(lib, "SLABHIDtoUART.lib")
|
|
#endif // defined(HID_TO_UART_EXPORTS)
|
|
#else // !_WIN32
|
|
#define HID_TO_UART_API
|
|
#define WINAPI
|
|
#endif // !_WIN32
|
|
|
|
// This is needed for any tool chain that doesn't have Microsoft code analysis
|
|
#if ! defined(_PREFAST_)
|
|
#if ! defined(_Use_decl_annotations_)
|
|
#define _Use_decl_annotations_
|
|
#endif // ! defined(_Use_decl_annotations_)
|
|
#if ! defined(_Check_return_)
|
|
#define _Check_return_
|
|
#endif // ! defined(_Check_return_)
|
|
#if ! defined(_Ret_range_)
|
|
#define _Ret_range_(lb,ub)
|
|
#endif // ! defined(_Ret_range_)
|
|
#if ! defined(_Success_)
|
|
#define _Success_(expr)
|
|
#endif // ! defined(_Success_)
|
|
#if ! defined(_In_)
|
|
#define _In_
|
|
#endif // ! defined(_In_)
|
|
#if ! defined(_In_opt_)
|
|
#define _In_opt_
|
|
#endif // ! defined(_In_opt_)
|
|
#if ! defined(_Out_)
|
|
#define _Out_
|
|
#endif // ! defined(_Out_)
|
|
#if ! defined(_In_range_)
|
|
#define _In_range_(lb,ub)
|
|
#endif // ! defined(_In_range_)
|
|
#if ! defined(_Out_range_)
|
|
#define _Out_range_(lb,ub)
|
|
#endif // ! defined(_Out_range_)
|
|
#if ! defined(_In_reads_bytes_)
|
|
#define _In_reads_bytes_(n)
|
|
#endif // ! defined(_In_reads_bytes_)
|
|
#if ! defined(_Out_writes_bytes_)
|
|
#define _Out_writes_bytes_(n)
|
|
#endif // ! defined(_Out_writes_bytes_)
|
|
#if ! defined(_Out_writes_bytes_opt_)
|
|
#define _Out_writes_bytes_opt_(n)
|
|
#endif // ! defined(_Out_writes_bytes_opt_)
|
|
#if ! defined(_Printf_format_string_)
|
|
#define _Printf_format_string_
|
|
#endif // ! defined(_Printf_format_string_)
|
|
#endif // ! defined(_Check_return_)
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Return Code Definitions
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
// HID_UART_STATUS
|
|
typedef int HID_UART_STATUS;
|
|
|
|
// Return Codes
|
|
#define HID_UART_SUCCESS 0x00
|
|
#define HID_UART_DEVICE_NOT_FOUND 0x01
|
|
#define HID_UART_INVALID_HANDLE 0x02
|
|
#define HID_UART_INVALID_DEVICE_OBJECT 0x03
|
|
#define HID_UART_INVALID_PARAMETER 0x04
|
|
#define HID_UART_INVALID_REQUEST_LENGTH 0x05
|
|
|
|
#define HID_UART_READ_ERROR 0x10
|
|
#define HID_UART_WRITE_ERROR 0x11
|
|
#define HID_UART_READ_TIMED_OUT 0x12
|
|
#define HID_UART_WRITE_TIMED_OUT 0x13
|
|
#define HID_UART_DEVICE_IO_FAILED 0x14
|
|
#define HID_UART_DEVICE_ACCESS_ERROR 0x15
|
|
#define HID_UART_DEVICE_NOT_SUPPORTED 0x16
|
|
#define HID_UART_INVALID_CONFIG_VERSION 0x17
|
|
|
|
#define HID_UART_UNKNOWN_ERROR 0xFF
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// String Definitions
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
// Product String Types
|
|
#define HID_UART_GET_VID_STR 0x01
|
|
#define HID_UART_GET_PID_STR 0x02
|
|
#define HID_UART_GET_PATH_STR 0x03
|
|
#define HID_UART_GET_SERIAL_STR 0x04
|
|
#define HID_UART_GET_MANUFACTURER_STR 0x05
|
|
#define HID_UART_GET_PRODUCT_STR 0x06
|
|
|
|
// String Lengths
|
|
#define HID_UART_DEVICE_STRLEN 260
|
|
|
|
// HID_UART_DEVICE_STR
|
|
typedef char HID_UART_DEVICE_STR[HID_UART_DEVICE_STRLEN];
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// UART Definitions
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
// Error Status
|
|
#define HID_UART_PARITY_ERROR 0x01
|
|
#define HID_UART_OVERRUN_ERROR 0x02
|
|
|
|
// Line Break Status
|
|
#define HID_UART_LINE_BREAK_INACTIVE 0x00
|
|
#define HID_UART_LINE_BREAK_ACTIVE 0x01
|
|
|
|
// Data Bits
|
|
#define HID_UART_FIVE_DATA_BITS 0x00
|
|
#define HID_UART_SIX_DATA_BITS 0x01
|
|
#define HID_UART_SEVEN_DATA_BITS 0x02
|
|
#define HID_UART_EIGHT_DATA_BITS 0x03
|
|
|
|
// Parity
|
|
#define HID_UART_NO_PARITY 0x00
|
|
#define HID_UART_ODD_PARITY 0x01
|
|
#define HID_UART_EVEN_PARITY 0x02
|
|
#define HID_UART_MARK_PARITY 0x03
|
|
#define HID_UART_SPACE_PARITY 0x04
|
|
|
|
// Stop Bits
|
|
// Short = 1 stop bit
|
|
// Long = 1.5 stop bits (5 data bits)
|
|
// = 2 stop bits (6-8 data bits)
|
|
#define HID_UART_SHORT_STOP_BIT 0x00
|
|
#define HID_UART_LONG_STOP_BIT 0x01
|
|
|
|
// Flow Control
|
|
#define HID_UART_NO_FLOW_CONTROL 0x00
|
|
#define HID_UART_RTS_CTS_FLOW_CONTROL 0x01
|
|
|
|
// Read/Write Limits
|
|
#define HID_UART_MIN_READ_SIZE 1
|
|
#define HID_UART_MAX_READ_SIZE 32768
|
|
#define HID_UART_MIN_WRITE_SIZE 1
|
|
#define HID_UART_MAX_WRITE_SIZE 4096
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Part Number Definitions
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
// Part Numbers
|
|
#define HID_UART_PART_CP2110 0x0A
|
|
#define HID_UART_PART_CP2114 0x0E
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// User Customization Definitions
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
// User-Customizable Field Lock Bitmasks
|
|
#define HID_UART_LOCK_PRODUCT_STR_1 0x0001
|
|
#define HID_UART_LOCK_PRODUCT_STR_2 0x0002
|
|
#define HID_UART_LOCK_SERIAL_STR 0x0004
|
|
#define HID_UART_LOCK_PIN_CONFIG 0x0008
|
|
#define HID_UART_LOCK_VID 0x0100
|
|
#define HID_UART_LOCK_PID 0x0200
|
|
#define HID_UART_LOCK_POWER 0x0400
|
|
#define HID_UART_LOCK_POWER_MODE 0x0800
|
|
#define HID_UART_LOCK_RELEASE_VERSION 0x1000
|
|
#define HID_UART_LOCK_FLUSH_BUFFERS 0x2000
|
|
#define HID_UART_LOCK_MFG_STR_1 0x4000
|
|
#define HID_UART_LOCK_MFG_STR_2 0x8000
|
|
|
|
// Field Lock Bit Values
|
|
#define HID_UART_LOCK_UNLOCKED 1
|
|
#define HID_UART_LOCK_LOCKED 0
|
|
|
|
// Power Max Value (500 mA)
|
|
#define HID_UART_BUS_POWER_MAX 0xFA
|
|
|
|
// Power Modes
|
|
#define HID_UART_BUS_POWER 0x00
|
|
#define HID_UART_SELF_POWER_VREG_DIS 0x01
|
|
#define HID_UART_SELF_POWER_VREG_EN 0x02
|
|
|
|
// Flush Buffers Bitmasks
|
|
#define HID_UART_FLUSH_TX_OPEN 0x01
|
|
#define HID_UART_FLUSH_TX_CLOSE 0x02
|
|
#define HID_UART_FLUSH_RX_OPEN 0x04
|
|
#define HID_UART_FLUSH_RX_CLOSE 0x08
|
|
|
|
// USB Config Bitmasks
|
|
#define HID_UART_SET_VID 0x01
|
|
#define HID_UART_SET_PID 0x02
|
|
#define HID_UART_SET_POWER 0x04
|
|
#define HID_UART_SET_POWER_MODE 0x08
|
|
#define HID_UART_SET_RELEASE_VERSION 0x10
|
|
#define HID_UART_SET_FLUSH_BUFFERS 0x20
|
|
|
|
// USB Config Bit Values
|
|
#define HID_UART_SET_IGNORE 0
|
|
#define HID_UART_SET_PROGRAM 1
|
|
|
|
// String Lengths
|
|
#define HID_UART_MFG_STRLEN 62
|
|
#define HID_UART_PRODUCT_STRLEN 62
|
|
#define HID_UART_SERIAL_STRLEN 30
|
|
|
|
// HID_UART_MFG_STR
|
|
typedef char HID_UART_MFG_STR[HID_UART_MFG_STRLEN];
|
|
|
|
// HID_UART_PRODUCT_STR
|
|
typedef char HID_UART_PRODUCT_STR[HID_UART_PRODUCT_STRLEN];
|
|
|
|
// HID_UART_SERIAL_STR
|
|
typedef char HID_UART_SERIAL_STR[HID_UART_SERIAL_STRLEN];
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Pin Definitions
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
// Pin Config Modes
|
|
#define HID_UART_GPIO_MODE_INPUT 0x00
|
|
#define HID_UART_GPIO_MODE_OUTPUT_OD 0x01
|
|
#define HID_UART_GPIO_MODE_OUTPUT_PP 0x02
|
|
#define HID_UART_GPIO_MODE_FUNCTION1 0x03
|
|
#define HID_UART_GPIO_MODE_FUNCTION2 0x04
|
|
|
|
// Suspend Value Bit Values
|
|
#define HID_UART_VALUE_SUSPEND_LO 0
|
|
#define HID_UART_VALUE_SUSPEND_HI 1
|
|
|
|
// Suspend Mode Bit Values
|
|
#define HID_UART_MODE_SUSPEND_OD 0
|
|
#define HID_UART_MODE_SUSPEND_PP 1
|
|
|
|
// RS485 Active Levels
|
|
#define HID_UART_MODE_RS485_ACTIVE_LO 0x00
|
|
#define HID_UART_MODE_RS485_ACTIVE_HI 0x01
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Typedefs
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
typedef void* HID_UART_DEVICE;
|
|
typedef unsigned char U8;
|
|
typedef unsigned short U16;
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Exported Library Functions
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif // __cplusplus
|
|
|
|
// HidUart_GetNumDevices
|
|
_Check_return_
|
|
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
|
|
_Success_(return == HID_UART_SUCCESS)
|
|
HID_TO_UART_API HID_UART_STATUS WINAPI
|
|
HidUart_GetNumDevices(DWORD* numDevices, _In_ const WORD vid, _In_ const WORD pid);
|
|
|
|
// HidUart_GetString
|
|
HID_TO_UART_API HID_UART_STATUS WINAPI
|
|
HidUart_GetString(DWORD deviceNum, WORD vid, WORD pid, char* deviceString, DWORD options);
|
|
|
|
// HidUart_GetOpenedString
|
|
HID_TO_UART_API HID_UART_STATUS WINAPI
|
|
HidUart_GetOpenedString(HID_UART_DEVICE device, char* deviceString, DWORD options);
|
|
|
|
// HidUart_GetIndexedString
|
|
HID_TO_UART_API HID_UART_STATUS WINAPI
|
|
HidUart_GetIndexedString(DWORD deviceNum, WORD vid, WORD pid, DWORD stringIndex, char* deviceString);
|
|
|
|
// HidUart_GetOpenedIndexedString
|
|
HID_TO_UART_API HID_UART_STATUS WINAPI
|
|
HidUart_GetOpenedIndexedString(HID_UART_DEVICE device, DWORD stringIndex, char* deviceString);
|
|
|
|
// HidUart_GetAttributes
|
|
HID_TO_UART_API HID_UART_STATUS WINAPI
|
|
HidUart_GetAttributes(DWORD deviceNum, WORD vid, WORD pid, WORD* deviceVid, WORD* devicePid, WORD* deviceReleaseNumber);
|
|
|
|
// HidUart_GetOpenedAttributes
|
|
HID_TO_UART_API HID_UART_STATUS WINAPI
|
|
HidUart_GetOpenedAttributes(HID_UART_DEVICE device, WORD* deviceVid, WORD* devicePid, WORD* deviceReleaseNumber);
|
|
|
|
// HidUart_Open
|
|
HID_TO_UART_API HID_UART_STATUS WINAPI
|
|
HidUart_Open(HID_UART_DEVICE* device, DWORD deviceNum, WORD vid, WORD pid);
|
|
|
|
// HidUart_Close
|
|
HID_TO_UART_API HID_UART_STATUS WINAPI
|
|
HidUart_Close(HID_UART_DEVICE device);
|
|
|
|
// HidUart_IsOpened
|
|
HID_TO_UART_API HID_UART_STATUS WINAPI
|
|
HidUart_IsOpened(HID_UART_DEVICE device, BOOL* opened);
|
|
|
|
// HidUart_SetUartEnable
|
|
HID_TO_UART_API HID_UART_STATUS WINAPI
|
|
HidUart_SetUartEnable(HID_UART_DEVICE device, BOOL enable);
|
|
|
|
// HidUart_GetUartEnable
|
|
HID_TO_UART_API HID_UART_STATUS WINAPI
|
|
HidUart_GetUartEnable(HID_UART_DEVICE device, BOOL* enable);
|
|
|
|
// HidUart_Read
|
|
HID_TO_UART_API HID_UART_STATUS WINAPI
|
|
HidUart_Read(HID_UART_DEVICE device, BYTE* buffer, DWORD numBytesToRead, DWORD* numBytesRead);
|
|
|
|
// HidUart_Write
|
|
HID_TO_UART_API HID_UART_STATUS WINAPI
|
|
HidUart_Write(HID_UART_DEVICE device, BYTE* buffer, DWORD numBytesToWrite, DWORD* numBytesWritten);
|
|
|
|
// HidUart_FlushBuffers
|
|
HID_TO_UART_API HID_UART_STATUS WINAPI
|
|
HidUart_FlushBuffers(HID_UART_DEVICE device, BOOL flushTransmit, BOOL flushReceive);
|
|
|
|
// HidUart_CancelIo
|
|
HID_TO_UART_API HID_UART_STATUS WINAPI
|
|
HidUart_CancelIo(HID_UART_DEVICE device);
|
|
|
|
// HidUart_SetTimeouts
|
|
HID_TO_UART_API HID_UART_STATUS WINAPI
|
|
HidUart_SetTimeouts(HID_UART_DEVICE device, DWORD readTimeout, DWORD writeTimeout);
|
|
|
|
// HidUart_GetTimeouts
|
|
HID_TO_UART_API HID_UART_STATUS WINAPI
|
|
HidUart_GetTimeouts(HID_UART_DEVICE device, DWORD* readTimeout, DWORD* writeTimeout);
|
|
|
|
// HidUart_GetUARTStatus
|
|
HID_TO_UART_API HID_UART_STATUS WINAPI
|
|
HidUart_GetUartStatus(HID_UART_DEVICE device, WORD* transmitFifoSize, WORD* receiveFifoSize, BYTE* errorStatus, BYTE* lineBreakStatus);
|
|
|
|
// HidUart_SetUARTConfig
|
|
_Check_return_
|
|
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
|
|
_Success_(return == HID_UART_SUCCESS)
|
|
HID_TO_UART_API HID_UART_STATUS WINAPI
|
|
HidUart_SetUartConfig(_In_ HID_UART_DEVICE device, _In_ const DWORD baudRate, _In_ const BYTE dataBits, _In_ const BYTE parity, _In_ const BYTE stopBits, _In_ const BYTE flowControl);
|
|
|
|
// HidUart_GetUARTConfig
|
|
_Check_return_
|
|
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
|
|
_Success_(return == HID_UART_SUCCESS)
|
|
HID_TO_UART_API HID_UART_STATUS WINAPI
|
|
HidUart_GetUartConfig(HID_UART_DEVICE device, DWORD* baudRate, BYTE* dataBits, BYTE* parity, BYTE* stopBits, BYTE* flowControl);
|
|
|
|
// HidUart_StartBreak
|
|
HID_TO_UART_API HID_UART_STATUS WINAPI
|
|
HidUart_StartBreak(HID_UART_DEVICE device, BYTE duration);
|
|
|
|
// HidUart_StopBreak
|
|
HID_TO_UART_API HID_UART_STATUS WINAPI
|
|
HidUart_StopBreak(HID_UART_DEVICE device);
|
|
|
|
// HidUart_Reset
|
|
HID_TO_UART_API HID_UART_STATUS WINAPI
|
|
HidUart_Reset(HID_UART_DEVICE device);
|
|
|
|
// HidUart_ReadLatch
|
|
_Check_return_
|
|
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
|
|
_Success_(return == HID_UART_SUCCESS)
|
|
HID_TO_UART_API HID_UART_STATUS WINAPI
|
|
HidUart_ReadLatch(_In_ HID_UART_DEVICE device, WORD* latchValue);
|
|
|
|
// HidUart_WriteLatch
|
|
_Check_return_
|
|
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
|
|
_Success_(return == HID_UART_SUCCESS)
|
|
HID_TO_UART_API HID_UART_STATUS WINAPI
|
|
HidUart_WriteLatch(_In_ HID_UART_DEVICE device, _In_ const WORD latchValue, _In_ const WORD latchMask);
|
|
|
|
// HidUart_GetPartNumber
|
|
HID_TO_UART_API HID_UART_STATUS WINAPI
|
|
HidUart_GetPartNumber(HID_UART_DEVICE device, BYTE* partNumber, BYTE* version);
|
|
|
|
// HidUart_GetLibraryVersion
|
|
_Check_return_
|
|
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
|
|
_Success_(return == HID_UART_SUCCESS)
|
|
HID_TO_UART_API HID_UART_STATUS WINAPI
|
|
HidUart_GetLibraryVersion(_Out_writes_bytes_(1) BYTE* major, _Out_writes_bytes_(1) BYTE* minor, _Out_writes_bytes_(sizeof(BOOL)) BOOL* release);
|
|
|
|
// HidUart_GetHidLibraryVersion
|
|
_Check_return_
|
|
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
|
|
_Success_(return == HID_UART_SUCCESS)
|
|
HID_TO_UART_API HID_UART_STATUS WINAPI
|
|
HidUart_GetHidLibraryVersion(_Out_writes_bytes_(1) BYTE* major, _Out_writes_bytes_(1) BYTE* minor, _Out_writes_bytes_(sizeof(BOOL)) BOOL* release);
|
|
|
|
// HidUart_GetHidGuid
|
|
_Check_return_
|
|
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
|
|
_Success_(return == HID_UART_SUCCESS)
|
|
HID_TO_UART_API HID_UART_STATUS WINAPI
|
|
HidUart_GetHidGuid(_Out_ void* guid);
|
|
|
|
// HidUart_SetLock
|
|
HID_TO_UART_API HID_UART_STATUS WINAPI
|
|
HidUart_SetLock(HID_UART_DEVICE device, WORD lock);
|
|
|
|
// HidUart_GetLock
|
|
HID_TO_UART_API HID_UART_STATUS WINAPI
|
|
HidUart_GetLock(HID_UART_DEVICE device, WORD* lock);
|
|
|
|
// HidUart_SetUsbConfig
|
|
HID_TO_UART_API HID_UART_STATUS WINAPI
|
|
HidUart_SetUsbConfig(_In_ HID_UART_DEVICE device, _In_ const WORD vid, _In_ const WORD pid, _In_ const BYTE power, _In_ const BYTE powerMode, _In_ const WORD releaseVersion, _In_ const BYTE flushBuffers, _In_ const BYTE mask);
|
|
|
|
// HidUart_GetUsbConfig
|
|
_Check_return_
|
|
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
|
|
_Success_(return == HID_UART_SUCCESS)
|
|
HID_TO_UART_API HID_UART_STATUS WINAPI
|
|
HidUart_GetUsbConfig(HID_UART_DEVICE device, WORD* vid, WORD* pid, BYTE* power, BYTE* powerMode, WORD* releaseVersion, BYTE* flushBuffers);
|
|
|
|
// HidUart_SetManufacturingString
|
|
HID_TO_UART_API HID_UART_STATUS WINAPI
|
|
HidUart_SetManufacturingString(HID_UART_DEVICE device, char* manufacturingString, BYTE strlen);
|
|
|
|
// HidUart_GetManufacturingString
|
|
HID_TO_UART_API HID_UART_STATUS WINAPI
|
|
HidUart_GetManufacturingString(HID_UART_DEVICE device, char* manufacturingString, BYTE* strlen);
|
|
|
|
// HidUart_SetProductString
|
|
HID_TO_UART_API HID_UART_STATUS WINAPI
|
|
HidUart_SetProductString(HID_UART_DEVICE device, char* productString, BYTE strlen);
|
|
|
|
// HidUart_GetProductString
|
|
HID_TO_UART_API HID_UART_STATUS WINAPI
|
|
HidUart_GetProductString(HID_UART_DEVICE device, char* productString, BYTE* strlen);
|
|
|
|
// HidUart_SetSerialString
|
|
HID_TO_UART_API HID_UART_STATUS WINAPI
|
|
HidUart_SetSerialString(HID_UART_DEVICE device, char* serialString, BYTE strlen);
|
|
|
|
// HidUart_GetSerialString
|
|
HID_TO_UART_API HID_UART_STATUS WINAPI
|
|
HidUart_GetSerialString(HID_UART_DEVICE device, char* serialString, BYTE* strlen);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif // __cplusplus
|
|
|
|
#endif // SLAB_HID_TO_UART_H
|