commit 603fec6fc3c1bba84ec4b81b83c37a214a2ab49b Author: anovikova Date: Tue Aug 12 21:51:30 2025 +0300 rt mode v1 diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..0b1d33a --- /dev/null +++ b/.gitignore @@ -0,0 +1,34 @@ +*.a +*.o +*.md +*.exe +*.user +*.Debug +*.Release +*.stash +MakeFile +*.bin +*.m +*.txt +*.mpd +*.sens +*.kna +*.djvu +resource/ +*.qrc +resource.h +*.png +*.jpeg +*.mp3 +*.wav +*.db +data/ +debug/ +platforms/ +release/ +compiler/ +src_build/ +html/ +log/ +doc/ +QtXml/ \ No newline at end of file diff --git a/TestTa1.pro b/TestTa1.pro new file mode 100644 index 0000000..f7462d4 --- /dev/null +++ b/TestTa1.pro @@ -0,0 +1,20 @@ +QT += testlib +QT += core gui + +greaterThan(QT_MAJOR_VERSION, 4): QT += widgets + +SOURCES += \ + WDMTMKv2.cpp \ + bcmil.cpp \ + cmdwrd.cpp \ + main.cpp \ + mainwindow.cpp \ + testinfo.cpp + +HEADERS += \ + WDMTMKv2.h \ + bcmil.h \ + cmdwrd.h \ + declarations.h \ + mainwindow.h \ + testinfo.h diff --git a/USB_TA_DRV.dll b/USB_TA_DRV.dll new file mode 100644 index 0000000..238123f Binary files /dev/null and b/USB_TA_DRV.dll differ diff --git a/USB_TA_VC2.dll b/USB_TA_VC2.dll new file mode 100644 index 0000000..ea72972 Binary files /dev/null and b/USB_TA_VC2.dll differ diff --git a/WDMTMKv2.cpp b/WDMTMKv2.cpp new file mode 100644 index 0000000..73e3a97 --- /dev/null +++ b/WDMTMKv2.cpp @@ -0,0 +1,2105 @@ +/*****************************************************************************/ +/* WDMTMK API v4.08 for Microsoft Windows ELCUS, 1998, 2011. */ +/* Interface to driver TMK1553B.SYS v4.08 */ +/* Interface to driver USB_TA_DRV.dll v1.9.2 */ +/* for Windows 98/ME/2000/XP/Vista/7 */ +/*****************************************************************************/ + +//#ifndef _TMK1553B_ +//#define _TMK1553B_ +#include +#include +#include "WDMTMKv2.h" + +HANDLE _ahVTMK4Event[MAX_TMK_NUMBER+1]; +HANDLE _hVTMK4VxD[MAX_TMK_NUMBER+1]; +int _VTMK4tmkMaxNum = -1; +int _VTMK4mrtMaxNum = -1; +int _VTMK4tmkCurNum = 0; +char _VTMK4usbFlag[MAX_TMK_NUMBER+1]; +int _VTMK4tmkDrvnum[MAX_TMK_NUMBER+1]; + +HINSTANCE hUSBDrvDll = NULL; + +DWORD TmkOpen() +{ + WORD _awVTMK4InBuf[2], _awVTMK4OutBuf[6]; + DWORD _cbVTMK4Ret; + PEZUSB_DRIVER_VERSION version; + int iTMK; + int nTMK = -1; + int nMRT = -1; + int loaded = 1; + int nTMKb = 0; + int badver = 0; + char tmkName[32]; + char cc = 0x5c; + + for (iTMK = 0; iTMK <= MAX_TMK_NUMBER; ++iTMK) + { + _VTMK4usbFlag[iTMK] = 0; + sprintf (tmkName, "%c%c.%cTMK1553BDevice%d",cc,cc,cc,iTMK); + _hVTMK4VxD[iTMK] = CreateFileA(tmkName, + GENERIC_READ | GENERIC_WRITE, + 0, + NULL, + OPEN_EXISTING, + FILE_ATTRIBUTE_NORMAL, + NULL); + + if (_hVTMK4VxD[iTMK] != INVALID_HANDLE_VALUE) + { + if (!DeviceIoControl(_hVTMK4VxD[iTMK], (DWORD)IOCTL_TMK_GetVersion, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL) || + _awVTMK4OutBuf[0] < TMK_VERSION_MIN) + { + badver = 1; + } + _VTMK4tmkDrvnum[iTMK] = iTMK; + nTMK = iTMK; + if (iTMK < 8) + nMRT = iTMK; + + CloseHandle(_hVTMK4VxD[iTMK]); + } + _hVTMK4VxD[iTMK] = NULL; + _ahVTMK4Event[iTMK] = 0; + } + if(badver) + return VTMK_BAD_VERSION; + + if(!hUSBDrvDll) + hUSBDrvDll = LoadLibrary(TEXT("USB_TA_DRV.dll")); + + if(hUSBDrvDll != NULL) + { + if(!(ptmkError = (int*)GetProcAddress(hUSBDrvDll, "tmkError"))) + {ptmkError = &ftmkError;loaded = 0;} + if(!(tmkconfig_usb = (htmkconfig_usb) GetProcAddress(hUSBDrvDll, "tmkconfig_usb"))) + {tmkconfig_usb = ftmkconfig_usb;loaded = 0;} + if(!(tmkdone_usb = (htmkdone_usb) GetProcAddress(hUSBDrvDll, "tmkdone_usb"))) + {tmkdone_usb = ftmkdone_usb;loaded = 0;} + if(!(tmkselect_usb = (htmkselect_usb) GetProcAddress(hUSBDrvDll, "tmkselect_usb"))) + {tmkselect_usb = ftmkselect_usb;loaded = 0;} + if(!(Read_DLL_EvD_usb = (hRead_DLL_EvD_usb) GetProcAddress(hUSBDrvDll, "Read_DLL_EvD_usb"))) + {Read_DLL_EvD_usb = fRead_DLL_EvD_usb;loaded = 0;} + if(!(tmktimeout_usb = (htmktimeout_usb) GetProcAddress(hUSBDrvDll, "tmktimeout_usb"))) + {tmktimeout_usb = ftmktimeout_usb;loaded = 0;} + if(!(tmksetcwbits_usb = (htmksetcwbits_usb) GetProcAddress(hUSBDrvDll, "tmksetcwbits_usb"))) + {tmksetcwbits_usb = ftmksetcwbits_usb;loaded = 0;} + if(!(tmkclrcwbits_usb = (htmkclrcwbits_usb) GetProcAddress(hUSBDrvDll, "tmkclrcwbits_usb"))) + {tmkclrcwbits_usb = ftmkclrcwbits_usb;loaded = 0;} + if(!(tmkgetcwbits_usb = (htmkgetcwbits_usb) GetProcAddress(hUSBDrvDll, "tmkclrcwbits_usb"))) + {tmkgetcwbits_usb = ftmkgetcwbits_usb;loaded = 0;} + if(!(tmkgetmode_usb = (htmkgetmode_usb) GetProcAddress(hUSBDrvDll, "tmkgetmode_usb"))) + {tmkgetmode_usb = ftmkgetmode_usb;loaded = 0;} + if(!(tmkdefdac_usb = (htmkdefdac_usb) GetProcAddress(hUSBDrvDll, "tmkdefdac_usb"))) + {tmkdefdac_usb = ftmkdefdac_usb;loaded = 0;} + if(!(tmkgetdac_usb = (htmkgetdac_usb) GetProcAddress(hUSBDrvDll, "tmkgetdac_usb"))) + {tmkgetdac_usb = ftmkgetdac_usb;loaded = 0;} + if(!(bcreset_usb = (hbcreset_usb) GetProcAddress(hUSBDrvDll, "bcreset_usb"))) + {bcreset_usb = fbcreset_usb;loaded = 0;} + if(!(bcdefirqmode_usb = (hbcdefirqmode_usb) GetProcAddress(hUSBDrvDll, "bcdefirqmode_usb"))) + {bcdefirqmode_usb = fbcdefirqmode_usb;loaded = 0;} + if(!(bcgetirqmode_usb = (hbcgetirqmode_usb) GetProcAddress(hUSBDrvDll, "bcgetirqmode_usb"))) + {bcgetirqmode_usb = fbcgetirqmode_usb;loaded = 0;} + if(!(bcgetmaxbase_usb = (hbcgetmaxbase_usb) GetProcAddress(hUSBDrvDll, "bcgetmaxbase_usb"))) + {bcgetmaxbase_usb = fbcgetmaxbase_usb;loaded = 0;} + if(!(bcgetmaxbase_usb = (hbcgetmaxbase_usb) GetProcAddress(hUSBDrvDll, "bcgetmaxbase_usb"))) + {bcgetmaxbase_usb = fbcgetmaxbase_usb;loaded = 0;} + if(!(bcdefbase_usb = (hbcdefbase_usb) GetProcAddress(hUSBDrvDll, "bcdefbase_usb"))) + {bcdefbase_usb = fbcdefbase_usb;loaded = 0;} + if(!(bcgetbase_usb = (hbcgetbase_usb) GetProcAddress(hUSBDrvDll, "bcgetbase_usb"))) + {bcgetbase_usb = fbcgetbase_usb;loaded = 0;} + if(!(bcputw_usb = (hbcputw_usb) GetProcAddress(hUSBDrvDll, "bcputw_usb"))) + {bcputw_usb = fbcputw_usb;loaded = 0;} + if(!(bcgetw_usb = (hbcgetw_usb) GetProcAddress(hUSBDrvDll, "bcgetw_usb"))) + {bcgetw_usb = fbcgetw_usb;loaded = 0;} + if(!(bcgetansw_usb = (hbcgetansw_usb) GetProcAddress(hUSBDrvDll, "bcgetansw_usb"))) + {bcgetansw_usb = fbcgetansw_usb;loaded = 0;} + if(!(bcputblk_usb = (hbcputblk_usb) GetProcAddress(hUSBDrvDll, "bcputblk_usb"))) + {bcputblk_usb = fbcputblk_usb;loaded = 0;} + if(!(bcgetblk_usb = (hbcgetblk_usb) GetProcAddress(hUSBDrvDll, "bcgetblk_usb"))) + {bcgetblk_usb = fbcgetblk_usb;loaded = 0;} + if(!(bcdefbus_usb = (hbcdefbus_usb) GetProcAddress(hUSBDrvDll, "bcdefbus_usb"))) + {bcdefbus_usb = fbcdefbus_usb;loaded = 0;} + if(!(bcgetbus_usb = (hbcgetbus_usb) GetProcAddress(hUSBDrvDll, "bcgetbus_usb"))) + {bcgetbus_usb = fbcgetbus_usb;loaded = 0;} + if(!(bcstart_usb = (hbcstart_usb) GetProcAddress(hUSBDrvDll, "bcstart_usb"))) + {bcstart_usb = fbcstart_usb;loaded = 0;} + if(!(bcstartx_usb = (hbcstartx_usb) GetProcAddress(hUSBDrvDll, "bcstartx_usb"))) + {bcstartx_usb = fbcstartx_usb;loaded = 0;} + if(!(bcdeflink_usb = (hbcdeflink_usb) GetProcAddress(hUSBDrvDll, "bcdeflink_usb"))) + {bcdeflink_usb = fbcdeflink_usb;loaded = 0;} + if(!(bcgetlink_usb = (hbcgetlink_usb) GetProcAddress(hUSBDrvDll, "bcgetlink_usb"))) + {bcgetlink_usb = fbcgetlink_usb;loaded = 0;} + if(!(bcstop_usb = (hbcstop_usb) GetProcAddress(hUSBDrvDll, "bcstop_usb"))) + {bcstop_usb = fbcstop_usb;loaded = 0;} + if(!(bcgetstate_usb = (hbcgetstate_usb) GetProcAddress(hUSBDrvDll, "bcgetstate_usb"))) + {bcgetstate_usb = fbcgetstate_usb;loaded = 0;} + if(!(rtreset_usb = (hrtreset_usb) GetProcAddress(hUSBDrvDll, "rtreset_usb"))) + {rtreset_usb = frtreset_usb;loaded = 0;} + if(!(rtdefirqmode_usb = (hrtdefirqmode_usb) GetProcAddress(hUSBDrvDll, "rtdefirqmode_usb"))) + {rtdefirqmode_usb = frtdefirqmode_usb;loaded = 0;} + if(!(rtgetirqmode_usb = (hrtgetirqmode_usb) GetProcAddress(hUSBDrvDll, "rtgetirqmode_usb"))) + {rtgetirqmode_usb = frtgetirqmode_usb;loaded = 0;} + if(!(rtdefmode_usb = (hrtdefmode_usb) GetProcAddress(hUSBDrvDll, "rtdefmode_usb"))) + {rtdefmode_usb = frtdefmode_usb;loaded = 0;} + if(!(rtgetmode_usb = (hrtgetmode_usb) GetProcAddress(hUSBDrvDll, "rtgetmode_usb"))) + {rtgetmode_usb = frtgetmode_usb;loaded = 0;} + if(!(rtgetmaxpage_usb = (hrtgetmaxpage_usb) GetProcAddress(hUSBDrvDll, "rtgetmaxpage_usb"))) + {rtgetmaxpage_usb = frtgetmaxpage_usb;loaded = 0;} + if(!(rtdefpage_usb = (hrtdefpage_usb) GetProcAddress(hUSBDrvDll, "rtdefpage_usb"))) + {rtdefpage_usb = frtdefpage_usb;loaded = 0;} + if(!(rtgetpage_usb = (hrtgetpage_usb) GetProcAddress(hUSBDrvDll, "rtgetpage_usb"))) + {rtgetpage_usb = frtgetpage_usb;loaded = 0;} + if(!(rtdefpagepc_usb = (hrtdefpagepc_usb) GetProcAddress(hUSBDrvDll, "rtdefpagepc_usb"))) + {rtdefpagepc_usb = frtdefpagepc_usb;loaded = 0;} + if(!(rtdefpagebus_usb = (hrtdefpagebus_usb) GetProcAddress(hUSBDrvDll, "rtdefpagebus_usb"))) + {rtdefpagebus_usb = frtdefpagebus_usb;loaded = 0;} + if(!(rtgetpagepc_usb = (hrtgetpagepc_usb) GetProcAddress(hUSBDrvDll, "rtgetpagepc_usb"))) + {rtgetpagepc_usb = frtgetpagepc_usb;loaded = 0;} + if(!(rtgetpagebus_usb = (hrtgetpagebus_usb) GetProcAddress(hUSBDrvDll, "rtgetpagebus_usb"))) + {rtgetpagebus_usb = frtgetpagebus_usb;loaded = 0;} + if(!(rtdefaddress_usb = (hrtdefaddress_usb) GetProcAddress(hUSBDrvDll, "rtdefaddress_usb"))) + {rtdefaddress_usb = frtdefaddress_usb;loaded = 0;} + if(!(rtgetaddress_usb = (hrtgetaddress_usb) GetProcAddress(hUSBDrvDll, "rtgetaddress_usb"))) + {rtgetaddress_usb = frtgetaddress_usb;loaded = 0;} + if(!(rtdefsubaddr_usb = (hrtdefsubaddr_usb) GetProcAddress(hUSBDrvDll, "rtdefsubaddr_usb"))) + {rtdefsubaddr_usb = frtdefsubaddr_usb;loaded = 0;} + if(!(rtgetsubaddr_usb = (hrtgetsubaddr_usb) GetProcAddress(hUSBDrvDll, "rtgetsubaddr_usb"))) + {rtgetsubaddr_usb = frtgetsubaddr_usb;loaded = 0;} + if(!(rtputw_usb = (hrtputw_usb) GetProcAddress(hUSBDrvDll, "rtputw_usb"))) + {rtputw_usb = frtputw_usb;loaded = 0;} + if(!(rtgetw_usb = (hrtgetw_usb) GetProcAddress(hUSBDrvDll, "rtgetw_usb"))) + {rtgetw_usb = frtgetw_usb;loaded = 0;} + if(!(rtputblk_usb = (hrtputblk_usb) GetProcAddress(hUSBDrvDll, "rtputblk_usb"))) + {rtputblk_usb = frtputblk_usb;loaded = 0;} + if(!(rtgetblk_usb = (hrtgetblk_usb) GetProcAddress(hUSBDrvDll, "rtgetblk_usb"))) + {rtgetblk_usb = frtgetblk_usb;loaded = 0;} + if(!(rtsetanswbits_usb = (hrtsetanswbits_usb) GetProcAddress(hUSBDrvDll, "rtsetanswbits_usb"))) + {rtsetanswbits_usb = frtsetanswbits_usb;loaded = 0;} + if(!(rtclranswbits_usb = (hrtclranswbits_usb) GetProcAddress(hUSBDrvDll, "rtclranswbits_usb"))) + {rtclranswbits_usb = frtclranswbits_usb;loaded = 0;} + if(!(rtgetanswbits_usb = (hrtgetanswbits_usb) GetProcAddress(hUSBDrvDll, "rtgetanswbits_usb"))) + {rtgetanswbits_usb = frtgetanswbits_usb;loaded = 0;} + if(!(rtgetflags_usb = (hrtgetflags_usb) GetProcAddress(hUSBDrvDll, "rtgetflags_usb"))) + {rtgetflags_usb = frtgetflags_usb;loaded = 0;} + if(!(rtputflags_usb = (hrtputflags_usb) GetProcAddress(hUSBDrvDll, "rtputflags_usb"))) + {rtputflags_usb = frtputflags_usb;loaded = 0;} + if(!(rtsetflag_usb = (hrtsetflag_usb) GetProcAddress(hUSBDrvDll, "rtsetflag_usb"))) + {rtsetflag_usb = frtsetflag_usb;loaded = 0;} + if(!(rtclrflag_usb = (hrtclrflag_usb) GetProcAddress(hUSBDrvDll, "rtclrflag_usb"))) + {rtclrflag_usb = frtclrflag_usb;loaded = 0;} + if(!(rtgetflag_usb = (hrtgetflag_usb) GetProcAddress(hUSBDrvDll, "rtgetflag_usb"))) + {rtgetflag_usb = frtgetflag_usb;loaded = 0;} + if(!(rtputflag_usb = (hrtputflag_usb) GetProcAddress(hUSBDrvDll, "rtputflag_usb"))) + {rtputflag_usb = frtputflag_usb;loaded = 0;} + if(!(rtgetstate_usb = (hrtgetstate_usb) GetProcAddress(hUSBDrvDll, "rtgetstate_usb"))) + {rtgetstate_usb = frtgetstate_usb;loaded = 0;} + if(!(rtbusy_usb = (hrtbusy_usb) GetProcAddress(hUSBDrvDll, "rtbusy_usb"))) + {rtbusy_usb = frtbusy_usb;loaded = 0;} + if(!(rtlock_usb = (hrtlock_usb) GetProcAddress(hUSBDrvDll, "rtlock_usb"))) + {rtlock_usb = frtlock_usb;loaded = 0;} + if(!(rtunlock_usb = (hrtunlock_usb) GetProcAddress(hUSBDrvDll, "rtunlock_usb"))) + {rtunlock_usb = frtunlock_usb;loaded = 0;} + if(!(rtgetcmddata_usb = (hrtgetcmddata_usb) GetProcAddress(hUSBDrvDll, "rtgetcmddata_usb"))) + {rtgetcmddata_usb = frtgetcmddata_usb;loaded = 0;} + if(!(rtputcmddata_usb = (hrtputcmddata_usb) GetProcAddress(hUSBDrvDll, "rtputcmddata_usb"))) + {rtputcmddata_usb = frtputcmddata_usb;loaded = 0;} + if(!(mtreset_usb = (hmtreset_usb) GetProcAddress(hUSBDrvDll, "mtreset_usb"))) + {mtreset_usb = fmtreset_usb;loaded = 0;} + if(!(mtgetsw_usb = (hmtgetsw_usb) GetProcAddress(hUSBDrvDll, "mtgetsw_usb"))) + {mtgetsw_usb = fmtgetsw_usb;loaded = 0;} + if(!(rtenable_usb = (hrtenable_usb) GetProcAddress(hUSBDrvDll, "rtenable_usb"))) + {rtenable_usb = frtenable_usb;loaded = 0;} + if(!(mrtselected_usb = (hmrtselected_usb) GetProcAddress(hUSBDrvDll, "mrtselected_usb"))) + {mrtselected_usb = fmrtselected_usb;loaded = 0;} + if(!(mrtgetstate_usb = (hmrtgetstate_usb) GetProcAddress(hUSBDrvDll, "mrtgetstate_usb"))) + {mrtgetstate_usb = fmrtgetstate_usb;loaded = 0;} + if(!(mrtdefbrcsubaddr0_usb = (hmrtdefbrcsubaddr0_usb) GetProcAddress(hUSBDrvDll, "mrtdefbrcsubaddr0_usb"))) + {mrtdefbrcsubaddr0_usb = fmrtdefbrcsubaddr0_usb;loaded = 0;} + if(!(mrtreset_usb = (hmrtreset_usb) GetProcAddress(hUSBDrvDll, "mrtreset_usb"))) + {mrtreset_usb = fmrtreset_usb;loaded = 0;} + if(!(tmktimer_usb = (htmktimer_usb) GetProcAddress(hUSBDrvDll, "tmktimer_usb"))) + {tmktimer_usb = ftmktimer_usb;loaded = 0;} + if(!(tmkgettimer_usb = (htmkgettimer_usb) GetProcAddress(hUSBDrvDll, "tmkgettimer_usb"))) + {tmkgettimer_usb = ftmkgettimer_usb;loaded = 0;} + if(!(tmkgettimerl_usb = (htmkgettimerl_usb) GetProcAddress(hUSBDrvDll, "tmkgettimerl_usb"))) + {tmkgettimerl_usb = ftmkgettimerl_usb;loaded = 0;} + if(!(bcgetmsgtime_usb = (hbcgetmsgtime_usb) GetProcAddress(hUSBDrvDll, "bcgetmsgtime_usb"))) + {bcgetmsgtime_usb = fbcgetmsgtime_usb;loaded = 0;} + if(!(rtgetmsgtime_usb = (hrtgetmsgtime_usb) GetProcAddress(hUSBDrvDll, "rtgetmsgtime_usb"))) + {rtgetmsgtime_usb = frtgetmsgtime_usb;loaded = 0;} + if(!(tmkgethwver_usb = (htmkgethwver_usb) GetProcAddress(hUSBDrvDll, "tmkgethwver_usb"))) + {tmkgethwver_usb = ftmkgethwver_usb;loaded = 0;} + if(!(tmkgetevtime_usb = (htmkgetevtime_usb) GetProcAddress(hUSBDrvDll, "tmkgetevtime_usb"))) + {tmkgetevtime_usb = ftmkgetevtime_usb;loaded = 0;} + if(!(tmkdefevent_usb = (htmkdefevent_usb) GetProcAddress(hUSBDrvDll, "tmkdefevent_usb"))) + {tmkdefevent_usb = ftmkdefevent_usb;loaded = 0;} + if(!(tmkswtimer_usb = (htmkswtimer_usb) GetProcAddress(hUSBDrvDll, "tmkswtimer_usb"))) + {tmkswtimer_usb = ftmkswtimer_usb;loaded = 0;} + if(!(tmkgetswtimer_usb = (htmkgetswtimer_usb) GetProcAddress(hUSBDrvDll, "tmkgetswtimer_usb"))) + {tmkgetswtimer_usb = ftmkgetswtimer_usb;loaded = 0;} + if(!(tmktimeout_usb = (htmktimeout_usb) GetProcAddress(hUSBDrvDll, "tmktimeout_usb"))) + {tmktimeout_usb = ftmktimeout_usb;loaded = 0;} + if(!(mrtdefbrcpage_usb = (hmrtdefbrcpage_usb) GetProcAddress(hUSBDrvDll, "mrtdefbrcpage_usb"))) + {mrtdefbrcpage_usb = fmrtdefbrcpage_usb;loaded = 0;} + if(!(mrtgetbrcpage_usb = (hmrtgetbrcpage_usb) GetProcAddress(hUSBDrvDll, "mrtgetbrcpage_usb"))) + {mrtgetbrcpage_usb = fmrtgetbrcpage_usb;loaded = 0;} + + if(!(MonitorHwStart_usb = (hMonitorHwStart_usb) GetProcAddress(hUSBDrvDll, "MonitorHwStart_usb"))) + {MonitorHwStart_usb = fMonitorHwStart_usb;loaded = 0;} + if(!(MonitorHwGetMessage_usb = (hMonitorHwGetMessage_usb) GetProcAddress(hUSBDrvDll, "MonitorHwGetMessage_usb"))) + {MonitorHwGetMessage_usb = fMonitorHwGetMessage_usb;loaded = 0;} + if(!(MonitorHwStop_usb = (hMonitorHwStop_usb) GetProcAddress(hUSBDrvDll, "MonitorHwStop_usb"))) + {MonitorHwStop_usb = fMonitorHwStop_usb;loaded = 0;} + + if(!(tmkrawio_usb = (htmkrawio_usb) GetProcAddress(hUSBDrvDll, "tmkrawio_usb"))) + {tmkrawio_usb = ftmkrawio_usb;loaded = 0;} + if(!(rtgap_usb = (hrtgap_usb) GetProcAddress(hUSBDrvDll, "rtgap_usb"))) + {rtgap_usb = frtgap_usb;loaded = 0;} + if(!(tmkreadsn_usb = (htmkreadsn_usb) GetProcAddress(hUSBDrvDll, "tmkreadsn_usb"))) + {tmkreadsn_usb = ftmkreadsn_usb;loaded = 0;} + + + if(loaded) + { + nTMKb = 0; + for(iTMK = 0; iTMK <= MAX_USBTA_NUM; ++iTMK) + { + if(nMRT+1+nTMKb > MAX_USBTA_NUM) + break; + sprintf (tmkName,"%c%c.%cEZUSB-%d",cc,cc,cc,iTMK); + _hVTMK4VxD[nMRT+1+nTMKb] = CreateFileA(tmkName, + GENERIC_READ | GENERIC_WRITE, + 0, + NULL, + OPEN_EXISTING, + FILE_ATTRIBUTE_NORMAL, + NULL); + + if (_hVTMK4VxD[nMRT+1+nTMKb] != INVALID_HANDLE_VALUE) + { + DeviceIoControl(_hVTMK4VxD[nMRT+1+nTMKb], (DWORD)IOCTL_EZUSB_GET_DRIVER_VERSION, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 6, &_cbVTMK4Ret, NULL); + version = (PEZUSB_DRIVER_VERSION) _awVTMK4OutBuf; + if(((DWORD)(version->MajorVersion << 16)+(DWORD)(version->MinorVersion)) < ((DWORD)(EZUSB_MAJOR_VERSION_MIN << 16)+(DWORD)(EZUSB_MINOR_VERSION_MIN))) + { + badver = 1; + } + _VTMK4usbFlag[nMRT+1+nTMKb] = 1; + _VTMK4tmkDrvnum[nMRT+1+nTMKb]=iTMK; + CloseHandle(_hVTMK4VxD[nMRT+1+nTMKb]); + _hVTMK4VxD[nMRT+1+nTMKb] = NULL; + nTMKb++; + } + else + _hVTMK4VxD[nMRT+1+nTMKb] = NULL; + } + if(badver) + return VTMK_BAD_VERSION; + nMRT += nTMKb; + if(nTMK < MAX_USBTA_NUM) + nTMK += nTMKb; + } + } + + if (nTMK == -1) + return 1; + + _VTMK4tmkMaxNum = nTMK; + _VTMK4mrtMaxNum = nMRT; + + return 0; +} + +void TmkClose() +{ + int iTMK; + for (iTMK = 0; iTMK <= _VTMK4tmkMaxNum; ++iTMK) + { + if (_hVTMK4VxD[iTMK]) + CloseHandle(_hVTMK4VxD[iTMK]); + _ahVTMK4Event[iTMK] = 0; + _hVTMK4VxD[iTMK] = NULL; + _VTMK4usbFlag[iTMK] = 0; + _VTMK4tmkDrvnum[iTMK] = -1; + } + + _VTMK4tmkMaxNum = -1; + + tmkconfig_usb = ftmkconfig_usb; + tmkdone_usb = ftmkdone_usb; + tmkselect_usb = ftmkselect_usb; + tmkdefevent_usb = ftmkdefevent_usb; + Read_DLL_EvD_usb = fRead_DLL_EvD_usb; + tmksetcwbits_usb = ftmksetcwbits_usb; + tmkclrcwbits_usb = ftmkclrcwbits_usb; + tmkgetcwbits_usb = ftmkgetcwbits_usb; + tmkgetmode_usb = ftmkgetmode_usb; + tmkdefdac_usb = ftmkdefdac_usb; + tmkgetdac_usb = ftmkgetdac_usb; + bcreset_usb = fbcreset_usb; + bcdefirqmode_usb = fbcdefirqmode_usb; + bcgetirqmode_usb = fbcgetirqmode_usb; + bcgetmaxbase_usb = fbcgetmaxbase_usb; + bcdefbase_usb = fbcdefbase_usb; + bcgetbase_usb = fbcgetbase_usb; + bcputw_usb = fbcputw_usb; + bcgetw_usb = fbcgetw_usb; + bcgetansw_usb = fbcgetansw_usb; + bcputblk_usb = fbcputblk_usb; + bcgetblk_usb = fbcgetblk_usb; + bcdefbus_usb = fbcdefbus_usb; + bcgetbus_usb = fbcgetbus_usb; + bcstart_usb = fbcstart_usb; + bcstartx_usb = fbcstartx_usb; + bcdeflink_usb = fbcdeflink_usb; + bcgetlink_usb = fbcgetlink_usb; + bcstop_usb = fbcstop_usb; + bcgetstate_usb = fbcgetstate_usb; + rtreset_usb = frtreset_usb; + rtdefirqmode_usb = frtdefirqmode_usb; + rtgetirqmode_usb = frtgetirqmode_usb; + rtdefmode_usb = frtdefmode_usb; + rtgetmode_usb = frtgetmode_usb; + rtgetmaxpage_usb = frtgetmaxpage_usb; + rtdefpage_usb = frtdefpage_usb; + rtgetpage_usb = frtgetpage_usb; + rtdefpagepc_usb = frtdefpagepc_usb; + rtdefpagebus_usb = frtdefpagebus_usb; + rtgetpagepc_usb = frtgetpagepc_usb; + rtgetpagebus_usb = frtgetpagebus_usb; + rtdefaddress_usb = frtdefaddress_usb; + rtgetaddress_usb = frtgetaddress_usb; + rtdefsubaddr_usb = frtdefsubaddr_usb; + rtgetsubaddr_usb = frtgetsubaddr_usb; + rtputw_usb = frtputw_usb; + rtgetw_usb = frtgetw_usb; + rtputblk_usb = frtputblk_usb; + rtgetblk_usb = frtgetblk_usb; + rtsetanswbits_usb = frtsetanswbits_usb; + rtclranswbits_usb = frtclranswbits_usb; + rtgetanswbits_usb = frtgetanswbits_usb; + rtgetflags_usb = frtgetflags_usb; + rtputflags_usb = frtputflags_usb; + rtsetflag_usb = frtsetflag_usb; + rtclrflag_usb = frtclrflag_usb; + rtgetflag_usb = frtgetflag_usb; + rtputflag_usb = frtputflag_usb; + rtgetstate_usb = frtgetstate_usb; + rtbusy_usb = frtbusy_usb; + rtlock_usb = frtlock_usb; + rtunlock_usb = frtunlock_usb; + rtgetcmddata_usb = frtgetcmddata_usb; + rtputcmddata_usb = frtputcmddata_usb; + mtreset_usb = fmtreset_usb; + mtgetsw_usb = fmtgetsw_usb; + rtenable_usb = frtenable_usb; + mrtselected_usb = fmrtselected_usb; + mrtgetstate_usb = fmrtgetstate_usb; + mrtdefbrcsubaddr0_usb = fmrtdefbrcsubaddr0_usb; + mrtreset_usb = fmrtreset_usb; + tmktimer_usb = ftmktimer_usb; + tmkgettimer_usb = ftmkgettimer_usb; + tmkgettimerl_usb = ftmkgettimerl_usb; + bcgetmsgtime_usb = fbcgetmsgtime_usb; + rtgetmsgtime_usb = frtgetmsgtime_usb; + tmkgethwver_usb = ftmkgethwver_usb; + tmkgetevtime_usb = ftmkgetevtime_usb; + tmkswtimer_usb = ftmkswtimer_usb; + tmkgetswtimer_usb = ftmkgetswtimer_usb; + tmktimeout_usb = ftmktimeout_usb; + mrtdefbrcpage_usb = fmrtdefbrcpage_usb; + mrtgetbrcpage_usb = fmrtgetbrcpage_usb; + + MonitorHwStart_usb = fMonitorHwStart_usb; + MonitorHwGetMessage_usb = fMonitorHwGetMessage_usb; + MonitorHwStop_usb = fMonitorHwStop_usb; + + tmkrawio_usb = ftmkrawio_usb; + rtgap_usb = frtgap_usb; + tmkreadsn_usb = ftmkreadsn_usb; + + if(hUSBDrvDll) + FreeLibrary(hUSBDrvDll); + hUSBDrvDll = NULL; +} + +int tmkgetmaxn() +{ + return _VTMK4tmkMaxNum; +} + +int tmkconfig(int tmkNumber) +{ + WORD _awVTMK4InBuf[2], _awVTMK4OutBuf[2]; + DWORD _cbVTMK4Ret; + int Status; + char tmkName[32]; + + if (_VTMK4tmkMaxNum == -1) + return TMK_BAD_NUMBER; + + if (_hVTMK4VxD[tmkNumber] != NULL) + return TMK_BAD_NUMBER; + + if (tmkNumber < 0 || tmkNumber > _VTMK4tmkMaxNum) + return TMK_BAD_NUMBER; + + if (_VTMK4usbFlag[tmkNumber]) + { + sprintf (tmkName,"%c%c.%cEZUSB-%d",0x5c,0x5c,0x5c,_VTMK4tmkDrvnum[tmkNumber]); + _hVTMK4VxD[tmkNumber] = CreateFileA(tmkName, + GENERIC_READ | GENERIC_WRITE, + 0, + NULL, + OPEN_EXISTING, + FILE_ATTRIBUTE_NORMAL, + NULL); + + if (_hVTMK4VxD[tmkNumber] == INVALID_HANDLE_VALUE) + { + _hVTMK4VxD[tmkNumber] = NULL; + return TMK_BAD_NUMBER; + } + + if(DeviceIoControl(_hVTMK4VxD[tmkNumber], (DWORD)IOCTL_EZUSB_SET_CURPROC, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL)) + { + Status = tmkconfig_usb(_VTMK4tmkDrvnum[tmkNumber], 9, 0, 0); + if(Status == 0) + { + _VTMK4tmkCurNum = tmkNumber; + return Status; + } + } + + CloseHandle (_hVTMK4VxD[tmkNumber]); + _hVTMK4VxD[tmkNumber] = NULL; + return TMK_BAD_NUMBER; + } + + sprintf (tmkName,"%c%c.%cTMK1553BDevice%d",0x5c,0x5c,0x5c,tmkNumber); + _hVTMK4VxD[tmkNumber] = CreateFileA(tmkName, + GENERIC_READ | GENERIC_WRITE, + 0, + NULL, + OPEN_EXISTING, + FILE_ATTRIBUTE_NORMAL, + NULL + ); + if (_hVTMK4VxD[tmkNumber] == INVALID_HANDLE_VALUE) + { + _hVTMK4VxD[tmkNumber] = NULL; + return TMK_BAD_NUMBER; + } + + _awVTMK4InBuf[0] = (WORD)tmkNumber; + DeviceIoControl(_hVTMK4VxD[tmkNumber], (DWORD)IOCTL_TMK_tmkconfig, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + if (_awVTMK4OutBuf[0] != 0) + { + CloseHandle (_hVTMK4VxD[tmkNumber]); + _hVTMK4VxD[tmkNumber] = NULL; + } + _VTMK4tmkCurNum = tmkNumber; + return (int)_awVTMK4OutBuf[0]; +} + +int tmkdone(int tmkNumber) +{ + WORD _awVTMK4InBuf[2], _awVTMK4OutBuf[2]; + DWORD _cbVTMK4Ret; + int iTMK; + + if (tmkNumber == ALL_TMKS) + { + for (iTMK = 0; iTMK <= _VTMK4tmkMaxNum; ++iTMK) + { + if(_VTMK4usbFlag[iTMK]) + { + _ahVTMK4Event[iTMK] = 0; + if(_hVTMK4VxD[iTMK]) + CloseHandle (_hVTMK4VxD[iTMK]); + _hVTMK4VxD[iTMK] = NULL; + tmkdone_usb(_VTMK4tmkDrvnum[iTMK]); + } + else + { + if (_hVTMK4VxD[iTMK] == NULL) + continue; + _awVTMK4InBuf[0] = (WORD)iTMK; + DeviceIoControl(_hVTMK4VxD[iTMK], (DWORD)IOCTL_TMK_tmkdone, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + + _ahVTMK4Event[iTMK] = 0; + CloseHandle(_hVTMK4VxD[iTMK]); + _hVTMK4VxD[iTMK] = NULL; + } + } + } + else if (tmkNumber >= 0 && tmkNumber <= _VTMK4tmkMaxNum && _hVTMK4VxD[tmkNumber] != NULL) + { + if(_VTMK4usbFlag[tmkNumber]) + { + _ahVTMK4Event[tmkNumber] = 0; + CloseHandle (_hVTMK4VxD[tmkNumber]); + _hVTMK4VxD[tmkNumber] = NULL; + tmkdone_usb(_VTMK4tmkDrvnum[tmkNumber]); + } + else + { + _awVTMK4InBuf[0] = (WORD)tmkNumber; + DeviceIoControl(_hVTMK4VxD[tmkNumber], (DWORD)IOCTL_TMK_tmkdone, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + + _ahVTMK4Event[tmkNumber] = 0; + CloseHandle (_hVTMK4VxD[tmkNumber]); + _hVTMK4VxD[tmkNumber] = NULL; + } + } + + return 0; +} + +int tmkselect(int tmkNumber) +{ + WORD _awVTMK4InBuf[2], _awVTMK4OutBuf[2]; + DWORD _cbVTMK4Ret; + + if (tmkNumber < 0 || tmkNumber > _VTMK4tmkMaxNum) + return TMK_BAD_NUMBER; + if ((_hVTMK4VxD[tmkNumber] != INVALID_HANDLE_VALUE) && (_hVTMK4VxD[tmkNumber] != 0)) + { + if (_VTMK4usbFlag[tmkNumber]) + { + _VTMK4tmkCurNum = tmkNumber; + tmkselect_usb(_VTMK4tmkDrvnum[tmkNumber]); + return 0; + } + + //************** ********************************************************** + _awVTMK4InBuf[0] = tmkNumber; + DeviceIoControl(_hVTMK4VxD[tmkNumber], (DWORD)IOCTL_TMK_tmkselect, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + + if (_awVTMK4OutBuf[0] == 0) + _VTMK4tmkCurNum = tmkNumber; + return _awVTMK4OutBuf[0]; + //******************************************************************************************************************* + //return 0; + } + else + return TMK_BAD_NUMBER; +} + +int tmkselected() +{ + return _VTMK4tmkCurNum; +} + +TMK_DATA tmkgetmode() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_tmkgetmode, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return tmkgetmode_usb(); +} + +int tmkdefdac(int dacValue) +{ + if ((_hVTMK4VxD[_VTMK4tmkCurNum])&&(_VTMK4usbFlag[_VTMK4tmkCurNum])) + return tmkdefdac_usb(dacValue); + else + return TMK_BAD_NUMBER; +} + +int tmkgetdac(int *dacValue, int *dacMode) +{ + if ((_hVTMK4VxD[_VTMK4tmkCurNum])&&(_VTMK4usbFlag[_VTMK4tmkCurNum])) + return tmkgetdac_usb(dacValue, dacMode); + else + { + *dacValue = 0; + *dacMode = 0; + return TMK_BAD_NUMBER; + } +} + +void tmksetcwbits(TMK_DATA tmkSetControl) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = tmkSetControl; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_tmksetcwbits, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + tmksetcwbits_usb(tmkSetControl); +} + +void tmkclrcwbits(TMK_DATA tmkClrControl) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = tmkClrControl; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_tmkclrcwbits, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + tmkclrcwbits_usb(tmkClrControl); +} + +TMK_DATA tmkgetcwbits() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_tmkgetcwbits, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return tmkgetcwbits_usb(); +} + +void tmkdefevent(HANDLE hEvent, BOOL fEventSet) +{ +#ifdef _WIN64 + WORD _awVTMK4InBuf[8], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + DWORD64 hVxDEvent; + hVxDEvent = (DWORD64)hEvent; + _ahVTMK4Event[_VTMK4tmkCurNum] = hEvent; +// _awVTMK4InBuf[0] = 0; +// _awVTMK4InBuf[1] = 0; + _awVTMK4InBuf[2] = LOWORD(fEventSet); + _awVTMK4InBuf[3] = HIWORD(fEventSet); + *(PDWORD64)(_awVTMK4InBuf+4) = hVxDEvent; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_tmkdefevent, _awVTMK4InBuf, 16, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + tmkdefevent_usb(hEvent); +#else + WORD _awVTMK4InBuf[4], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + DWORD hVxDEvent; + +/* int iTMK; + if (hEvent != 0) + { + for (iTMK = 0; iTMK <= MAX_TMK_NUMBER; ++iTMK) + { + if (hEvent == _ahVTMK4Event[iTMK]) + break; + } + if (iTMK > MAX_TMK_NUMBER) + { + hVxDEvent = (DWORD)hEvent; + _ahVTMK4Event[_VTMK4tmkCurNum] = hEvent; + } + } + else + { + hVxDEvent = 0; + _ahVTMK4Event[_VTMK4tmkCurNum] = 0; + } +*/ + hVxDEvent = (DWORD)hEvent; + _ahVTMK4Event[_VTMK4tmkCurNum] = hEvent; + _awVTMK4InBuf[0] = LOWORD(hVxDEvent); + _awVTMK4InBuf[1] = HIWORD(hVxDEvent); + _awVTMK4InBuf[2] = LOWORD(fEventSet); + _awVTMK4InBuf[3] = HIWORD(fEventSet); + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_tmkdefevent, _awVTMK4InBuf, 8, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + tmkdefevent_usb(hEvent); +#endif +} + +void tmkgetevd(TTmkEventData *pEvD) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[6]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_tmkgetevd, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 12, &_cbVTMK4Ret, NULL); + + pEvD->nInt = ((DWORD*)(_awVTMK4OutBuf))[0]; + switch (pEvD->wMode = _awVTMK4OutBuf[2]) + { + case BC_MODE: + switch (pEvD->nInt) + { + case 1: + pEvD->bc.wResult = _awVTMK4OutBuf[3]; + break; + case 2: + pEvD->bc.wResult = _awVTMK4OutBuf[3]; + pEvD->bc.wAW1 = _awVTMK4OutBuf[4]; + pEvD->bc.wAW2 = _awVTMK4OutBuf[5]; + break; + case 3: + pEvD->bcx.wResultX = _awVTMK4OutBuf[3]; + pEvD->bcx.wBase = _awVTMK4OutBuf[4]; + break; + case 4: + pEvD->bcx.wBase = _awVTMK4OutBuf[3]; + break; + } + break; + case MT_MODE: + switch (pEvD->nInt) + { + case 3: + pEvD->mt.wResultX = _awVTMK4OutBuf[3]; + pEvD->mt.wBase = _awVTMK4OutBuf[4]; + break; + case 4: + pEvD->mt.wBase = _awVTMK4OutBuf[3]; + break; + } + break; + case RT_MODE: + switch (pEvD->nInt) + { + case 1: + pEvD->rt.wCmd = _awVTMK4OutBuf[3]; + break; + case 2: + case 3: + pEvD->rt.wStatus = _awVTMK4OutBuf[3]; + break; + } + break; + case UNDEFINED_MODE: + switch (pEvD->nInt) + { + case 5: + pEvD->tmk.wRequest = _awVTMK4OutBuf[3]; +// pEvD->tmk.dwTimer = *((DWORD*)(&_awVTMK4OutBuf[4])); + break; + } + break; + } + } + else + { + TListEvD evd_s; + Read_DLL_EvD_usb(&evd_s); + + pEvD->nInt = evd_s.nInt; + pEvD->wMode = evd_s.wMode; + switch (pEvD->wMode) + { + case BC_MODE: + switch (pEvD->nInt) + { + case 1: + pEvD->bc.wResult = evd_s.awEvData[0]; + break; + case 2: + pEvD->bc.wResult = evd_s.awEvData[0]; + pEvD->bc.wAW1 = evd_s.awEvData[1]; + pEvD->bc.wAW2 = evd_s.awEvData[2]; + break; + case 3: + pEvD->bcx.wResultX = evd_s.awEvData[0]; + pEvD->bcx.wBase = evd_s.awEvData[1]; + break; + case 4: + pEvD->bcx.wBase = evd_s.awEvData[0]; + break; + } + break; + case MT_MODE: + switch (pEvD->nInt) + { + case 3: + pEvD->mt.wResultX = evd_s.awEvData[0]; + pEvD->mt.wBase = evd_s.awEvData[1]; + break; + case 4: + pEvD->mt.wBase = evd_s.awEvData[0]; + break; + } + break; + case RT_MODE: + switch (pEvD->nInt) + { + case 1: + pEvD->rt.wCmd = evd_s.awEvData[0]; + break; + case 2: + case 3: + pEvD->rt.wStatus = evd_s.awEvData[0]; + break; + } + break; + case UNDEFINED_MODE: + switch (pEvD->nInt) + { + case 5: + pEvD->tmk.wRequest = evd_s.awEvData[0]; +// pEvD->tmk.dwTimer = *((DWORD*)(&_awVTMK4OutBuf[4])); + break; + case 255: + pEvD->raw.wData1 = evd_s.awEvData[0]; + pEvD->raw.wData2 = evd_s.awEvData[1]; + break; + } + break; + } + } +} + +void tmkgetinfo(TTmkConfigData *pConfD) +{ +#ifdef _WIN64 + WORD _awVTMK4InBuf[4], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + *(PDWORD64)(_awVTMK4InBuf) = (DWORD64)pConfD; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_tmkgetinfo, _awVTMK4InBuf, 8, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + } +#else + WORD _awVTMK4InBuf[2], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = LOWORD(pConfD); + _awVTMK4InBuf[1] = HIWORD(pConfD); + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_tmkgetinfo, _awVTMK4InBuf, 4, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + } +#endif + else + { + pConfD->nType = TA; + strcpy(pConfD->szName, "TA1USB"); + pConfD->wPorts1 = 0; + pConfD->wPorts2 = 0; + pConfD->wIrq1 = 0; + pConfD->wIrq2 = 0; + pConfD->wIODelay = 0; + } +} + +int bcreset() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + return(DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bcreset, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL))?0:GetLastError(); + else + return bcreset_usb(); +} + +void bc_def_tldw(TMK_DATA wTLDW) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = wTLDW; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bc_def_tldw, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); +} + +void bc_enable_di() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bc_enable_di, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); +} + +void bc_disable_di() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bc_disable_di, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); +} + +int bcdefirqmode(TMK_DATA bcIrqMode) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = bcIrqMode; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + return (DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bcdefirqmode, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL))?0:GetLastError(); + else + return bcdefirqmode_usb(bcIrqMode); +} + +TMK_DATA bcgetirqmode() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bcgetirqmode, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return bcgetirqmode_usb(); +} + +TMK_DATA bcgetmaxbase() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bcgetmaxbase, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return bcgetmaxbase_usb(); +} + +int bcdefbase(TMK_DATA bcBasePC) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = bcBasePC; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + return (DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bcdefbase, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL))?0:GetLastError(); + else + return bcdefbase_usb(bcBasePC); +} + +TMK_DATA bcgetbase() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bcgetbase, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return bcgetbase_usb(); +} + +void bcputw(TMK_DATA bcAddr, TMK_DATA bcData) +{ + WORD _awVTMK4InBuf[2], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = bcAddr; + _awVTMK4InBuf[1] = bcData; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bcputw, _awVTMK4InBuf, 4, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + bcputw_usb(bcAddr, bcData); +} + +TMK_DATA bcgetw(TMK_DATA bcAddr) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = bcAddr; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bcgetw, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return bcgetw_usb(bcAddr); +} + +DWORD bcgetansw(TMK_DATA bcCtrlCode) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[2]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = bcCtrlCode; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bcgetansw, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 4, &_cbVTMK4Ret, NULL); + return (((DWORD*)(_awVTMK4OutBuf))[0]); + } + else + return bcgetansw_usb(bcCtrlCode); +} + +void bcputblk(TMK_DATA bcAddr, void *pcBuffer, TMK_DATA cwLength) +{ +#ifdef _WIN64 + WORD _awVTMK4InBuf[8], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = bcAddr; +// _awVTMK4InBuf[1] = 0; +// _awVTMK4InBuf[2] = 0; + _awVTMK4InBuf[3] = cwLength; + *(PDWORD64)(_awVTMK4InBuf+4) = (DWORD64)pcBuffer; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bcputblk, _awVTMK4InBuf, 16, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + bcputblk_usb(bcAddr, pcBuffer, cwLength); +#else + WORD _awVTMK4InBuf[4], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = bcAddr; + _awVTMK4InBuf[1] = (WORD)(LOWORD(pcBuffer)); + _awVTMK4InBuf[2] = (WORD)(HIWORD(pcBuffer)); + _awVTMK4InBuf[3] = cwLength; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bcputblk, _awVTMK4InBuf, 8, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + bcputblk_usb(bcAddr, pcBuffer, cwLength); +#endif +} + +void bcgetblk(TMK_DATA bcAddr, void *pcBuffer, TMK_DATA cwLength) +{ +#ifdef _WIN64 + WORD _awVTMK4InBuf[8], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = bcAddr; +// _awVTMK4InBuf[1] = 0; +// _awVTMK4InBuf[2] = 0; + _awVTMK4InBuf[3] = cwLength; + *(PDWORD64)(_awVTMK4InBuf+4) = (DWORD64)pcBuffer; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bcgetblk, _awVTMK4InBuf, 16, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + bcgetblk_usb(bcAddr, pcBuffer, cwLength); +#else + WORD _awVTMK4InBuf[4], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = bcAddr; + _awVTMK4InBuf[1] = (WORD)(LOWORD(pcBuffer)); + _awVTMK4InBuf[2] = (WORD)(HIWORD(pcBuffer)); + _awVTMK4InBuf[3] = cwLength; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bcgetblk, _awVTMK4InBuf, 8, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + bcgetblk_usb(bcAddr, pcBuffer, cwLength); +#endif +} + +int bcdefbus(TMK_DATA bcBus) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = bcBus; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + return (DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bcdefbus, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL))?0:GetLastError(); + else + return bcdefbus_usb(bcBus); +} + +TMK_DATA bcgetbus() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bcgetbus, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return bcgetbus_usb(); +} + +int bcstart(TMK_DATA bcBase, TMK_DATA bcCtrlCode) +{ + WORD _awVTMK4InBuf[2], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = bcBase; + _awVTMK4InBuf[1] = bcCtrlCode; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + return (DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bcstart, _awVTMK4InBuf, 4, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL))?0:GetLastError(); + else + return bcstart_usb(bcBase, bcCtrlCode); +} + +int bcstartx(TMK_DATA bcBase, TMK_DATA bcCtrlCode) +{ + WORD _awVTMK4InBuf[2], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = bcBase; + _awVTMK4InBuf[1] = bcCtrlCode; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + return (DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bcstartx, _awVTMK4InBuf, 4, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL))?0:GetLastError(); + else + return bcstartx_usb(bcBase, bcCtrlCode); +} + +int bcdeflink(TMK_DATA bcBase, TMK_DATA bcCtrlCode) +{ + WORD _awVTMK4InBuf[2], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = bcBase; + _awVTMK4InBuf[1] = bcCtrlCode; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + return (DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bcdeflink, _awVTMK4InBuf, 4, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL))?0:GetLastError(); + else + return bcdeflink_usb(bcBase, bcCtrlCode); +} + +DWORD bcgetlink() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[2]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bcgetlink, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 4, &_cbVTMK4Ret, NULL); + return (((DWORD*)(_awVTMK4OutBuf))[0]); + } + else + return bcgetlink_usb(); +} + +TMK_DATA bcstop() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bcstop, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return bcstop_usb(); +} + +DWORD bcgetstate() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[2]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bcgetstate, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 4, &_cbVTMK4Ret, NULL); + return (((DWORD*)(_awVTMK4OutBuf))[0]); + } + else + return bcgetstate_usb(); +} + +int rtreset() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + return (DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtreset, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL))?0:GetLastError(); + else + return rtreset_usb(); +} + +int rtdefirqmode(TMK_DATA rtIrqMode) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = rtIrqMode; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + return (DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtdefirqmode, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL))?0:GetLastError(); + else + return rtdefirqmode_usb(rtIrqMode); +} + +TMK_DATA rtgetirqmode() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtgetirqmode, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return rtgetirqmode_usb(); +} + +int rtdefmode(TMK_DATA rtMode) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = rtMode; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + return (DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtdefmode, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL))?0:GetLastError(); + else + return rtdefmode_usb(rtMode); +} + +TMK_DATA rtgetmode() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtgetmode, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return rtgetmode_usb(); +} + +TMK_DATA rtgetmaxpage() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtgetmaxpage, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return rtgetmaxpage_usb(); +} + +int rtdefpage(TMK_DATA rtPage) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = rtPage; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + return (DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtdefpage, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL))?0:GetLastError(); + else + return rtdefpage_usb(rtPage); +} + +TMK_DATA rtgetpage() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtgetpage, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return rtgetpage_usb(); +} + +int rtdefpagepc(TMK_DATA rtPagePC) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = rtPagePC; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + return (DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtdefpagepc, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL))?0:GetLastError(); + else + return rtdefpagepc_usb(rtPagePC); +} + +int rtdefpagebus(TMK_DATA rtPageBus) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = rtPageBus; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + return (DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtdefpagebus, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL))?0:GetLastError(); + else + return rtdefpagebus_usb(rtPageBus); +} + +TMK_DATA rtgetpagepc() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtgetpagepc, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return rtgetpagepc_usb(); +} + +TMK_DATA rtgetpagebus() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtgetpagebus, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return rtgetpagebus_usb(); +} + +int rtdefaddress(TMK_DATA rtAddress) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = rtAddress; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + return (DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtdefaddress, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL))?0:GetLastError(); + else + return rtdefaddress_usb(rtAddress); +} + +TMK_DATA rtgetaddress() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtgetaddress, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return rtgetaddress_usb(); +} + +void rtdefsubaddr(TMK_DATA rtDir, TMK_DATA rtSubAddr) +{ + WORD _awVTMK4InBuf[2], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = rtDir; + _awVTMK4InBuf[1] = rtSubAddr; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtdefsubaddr, _awVTMK4InBuf, 4, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + rtdefsubaddr_usb(rtDir, rtSubAddr); +} + +TMK_DATA rtgetsubaddr() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtgetsubaddr, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return rtgetsubaddr_usb(); +} + +void rtputw(TMK_DATA rtAddr, TMK_DATA rtData) +{ + WORD _awVTMK4InBuf[2], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = rtAddr; + _awVTMK4InBuf[1] = rtData; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtputw, _awVTMK4InBuf, 4, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + rtputw_usb(rtAddr, rtData); +} + +TMK_DATA rtgetw(TMK_DATA rtAddr) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = rtAddr; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtgetw, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return rtgetw_usb(rtAddr); +} + +void rtputblk(TMK_DATA rtAddr, void *pcBuffer, TMK_DATA cwLength) +{ +#ifdef _WIN64 + WORD _awVTMK4InBuf[8], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = rtAddr; +// _awVTMK4InBuf[1] = 0; +// _awVTMK4InBuf[2] = 0; + _awVTMK4InBuf[3] = cwLength; + *(PDWORD64)(_awVTMK4InBuf+4) = (DWORD64)pcBuffer; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtputblk, _awVTMK4InBuf, 16, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + rtputblk_usb(rtAddr, pcBuffer, cwLength); +#else + WORD _awVTMK4InBuf[4], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = rtAddr; + _awVTMK4InBuf[1] = (WORD)(LOWORD(pcBuffer)); + _awVTMK4InBuf[2] = (WORD)(HIWORD(pcBuffer)); + _awVTMK4InBuf[3] = cwLength; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtputblk, _awVTMK4InBuf, 8, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + rtputblk_usb(rtAddr, pcBuffer, cwLength); +#endif +} + +void rtgetblk(TMK_DATA rtAddr, void *pcBuffer, TMK_DATA cwLength) +{ +#ifdef _WIN64 + WORD _awVTMK4InBuf[8], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = rtAddr; +// _awVTMK4InBuf[1] = 0; +// _awVTMK4InBuf[2] = 0; + _awVTMK4InBuf[3] = cwLength; + *(PDWORD64)(_awVTMK4InBuf+4) = (DWORD64)pcBuffer; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtgetblk, _awVTMK4InBuf, 16, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + rtgetblk_usb(rtAddr, pcBuffer, cwLength); +#else + WORD _awVTMK4InBuf[4], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = rtAddr; + _awVTMK4InBuf[1] = (WORD)(LOWORD(pcBuffer)); + _awVTMK4InBuf[2] = (WORD)(HIWORD(pcBuffer)); + _awVTMK4InBuf[3] = cwLength; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtgetblk, _awVTMK4InBuf, 8, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + rtgetblk_usb(rtAddr, pcBuffer, cwLength); +#endif +} + +void rtsetanswbits(TMK_DATA rtSetControl) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = rtSetControl; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtsetanswbits, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + rtsetanswbits_usb(rtSetControl); +} + +void rtclranswbits(TMK_DATA rtClrControl) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = rtClrControl; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtclranswbits, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + rtclranswbits_usb(rtClrControl); +} + +TMK_DATA rtgetanswbits() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtgetanswbits, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return rtgetanswbits_usb(); +} + +void rtgetflags(void *pcBuffer, TMK_DATA rtDir, TMK_DATA rtFlagMin, TMK_DATA rtFlagMax) +{ +#ifdef _WIN64 + WORD _awVTMK4InBuf[12], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; +// _awVTMK4InBuf[0] = 0; +// _awVTMK4InBuf[1] = 0; + _awVTMK4InBuf[2] = rtDir; + _awVTMK4InBuf[3] = rtFlagMin; + _awVTMK4InBuf[4] = rtFlagMax; + *(PDWORD64)(_awVTMK4InBuf+8) = (DWORD64)pcBuffer; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtgetflags, _awVTMK4InBuf, 24, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + rtgetflags_usb(pcBuffer, rtDir, rtFlagMin, rtFlagMax); +#else + WORD _awVTMK4InBuf[5], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = (WORD)(LOWORD(pcBuffer)); + _awVTMK4InBuf[1] = (WORD)(HIWORD(pcBuffer)); + _awVTMK4InBuf[2] = rtDir; + _awVTMK4InBuf[3] = rtFlagMin; + _awVTMK4InBuf[4] = rtFlagMax; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtgetflags, _awVTMK4InBuf, 10, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + rtgetflags_usb(pcBuffer, rtDir, rtFlagMin, rtFlagMax); +#endif +} + +void rtputflags(void *pcBuffer, TMK_DATA rtDir, TMK_DATA rtFlagMin, TMK_DATA rtFlagMax) +{ +#ifdef _WIN64 + WORD _awVTMK4InBuf[12], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; +// _awVTMK4InBuf[0] = 0; +// _awVTMK4InBuf[1] = 0; + _awVTMK4InBuf[2] = rtDir; + _awVTMK4InBuf[3] = rtFlagMin; + _awVTMK4InBuf[4] = rtFlagMax; + *(PDWORD64)(_awVTMK4InBuf+8) = (DWORD64)pcBuffer; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtputflags, _awVTMK4InBuf, 24, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + rtputflags_usb(pcBuffer, rtDir, rtFlagMin, rtFlagMax); +#else + WORD _awVTMK4InBuf[5], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = (WORD)(LOWORD(pcBuffer)); + _awVTMK4InBuf[1] = (WORD)(HIWORD(pcBuffer)); + _awVTMK4InBuf[2] = rtDir; + _awVTMK4InBuf[3] = rtFlagMin; + _awVTMK4InBuf[4] = rtFlagMax; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtputflags, _awVTMK4InBuf, 10, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + rtputflags_usb(pcBuffer, rtDir, rtFlagMin, rtFlagMax); +#endif +} + +void rtsetflag() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtsetflag, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + rtsetflag_usb(); +} + +void rtclrflag() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtclrflag, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + rtclrflag_usb(); +} + +TMK_DATA rtgetflag(TMK_DATA rtDir, TMK_DATA rtSubAddr) +{ + WORD _awVTMK4InBuf[2], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = rtDir; + _awVTMK4InBuf[1] = rtSubAddr; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtgetflag, _awVTMK4InBuf, 4, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return rtgetflag_usb(rtDir, rtSubAddr); +} + +TMK_DATA rtgetstate() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtgetstate, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return rtgetstate_usb(); +} + +TMK_DATA rtbusy() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtbusy, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return rtbusy_usb(); +} + +void rtlock(TMK_DATA rtDir, TMK_DATA rtSubAddr) +{ + WORD _awVTMK4InBuf[2], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = rtDir; + _awVTMK4InBuf[1] = rtSubAddr; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtlock, _awVTMK4InBuf, 4, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + rtlock_usb(rtDir, rtSubAddr); +} + +void rtunlock() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtunlock, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + rtunlock_usb(); +} + +TMK_DATA rtgetcmddata(TMK_DATA rtBusCommand) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = rtBusCommand; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtgetcmddata, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return rtgetcmddata_usb(rtBusCommand); +} +void rtputcmddata(TMK_DATA rtBusCommand, TMK_DATA rtData) +{ + WORD _awVTMK4InBuf[2], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = rtBusCommand; + _awVTMK4InBuf[1] = rtData; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtputcmddata, _awVTMK4InBuf, 4, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + rtputcmddata_usb(rtBusCommand, rtData); +} + +int mtreset() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + return (DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_mtreset, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL))?0:GetLastError(); + else + return mtreset_usb(); +} + +TMK_DATA mtgetsw() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_mtgetsw, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return mtgetsw_usb(); +} + +TMK_DATA rtenable(TMK_DATA rtEnable) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = rtEnable; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtenable, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return rtenable_usb(rtEnable); +} + +int mrtgetmaxn() +{ + return _VTMK4mrtMaxNum; +/* + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_mrtgetmaxn, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return ((int)(_awVTMK4OutBuf[0])); +*/ +} + +DWORD mrtconfig(int mrtNumber) +{ + WORD _awVTMK4InBuf[2], _awVTMK4OutBuf[2]; + DWORD _cbVTMK4Ret; + DWORD RTN,RT0,iRT; + int err; + char tmkName[32]; + + if (_hVTMK4VxD[mrtNumber] != NULL) + return 0; + + if (!_VTMK4usbFlag[mrtNumber]) + { + sprintf (tmkName,"%c%c.%cTMK1553BDevice%d",0x5c,0x5c,0x5c,mrtNumber); + _hVTMK4VxD[mrtNumber] = CreateFileA(tmkName, + GENERIC_READ | GENERIC_WRITE, + 0, + NULL, + OPEN_EXISTING, + FILE_ATTRIBUTE_NORMAL, + NULL + ); + if (_hVTMK4VxD[mrtNumber] == INVALID_HANDLE_VALUE) + { + _hVTMK4VxD[mrtNumber] = NULL; + return 0; + } + + _awVTMK4InBuf[0] = (WORD)mrtNumber; + DeviceIoControl(_hVTMK4VxD[mrtNumber], (DWORD)IOCTL_TMK_mrtconfig, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 4, &_cbVTMK4Ret, NULL); + if (_awVTMK4OutBuf[0] != 0 && _awVTMK4OutBuf[1] != 0) + { + RT0 = (DWORD)_awVTMK4OutBuf[0]; + RTN = (DWORD)_awVTMK4OutBuf[1] + RT0 - 1; + // + for (iRT = RT0; iRT < RTN; ++iRT) + { + if (_hVTMK4VxD[iRT] != NULL) + { + err = 1; + break; + } + sprintf (tmkName,"%c%c.%cTMK1553BDevice%d",0x5c,0x5c,0x5c,iRT); + _hVTMK4VxD[iRT] = CreateFileA(tmkName, + GENERIC_READ | GENERIC_WRITE, + 0, + NULL, + OPEN_EXISTING, + FILE_ATTRIBUTE_NORMAL, + NULL + ); + if (_hVTMK4VxD[iRT] == INVALID_HANDLE_VALUE) + { + _hVTMK4VxD[iRT] = NULL; + err = 1; + break; + } + }//for(iRT = RT0; iRT < RTN; iRT++) + if (err) + { + for (--iRT; iRT >= RT0; --iRT) + { + CloseHandle(_hVTMK4VxD[iRT]); + _hVTMK4VxD[iRT] = 0; + } + } + }//if(_awVTMK4OutBuf[0] != 0 && _awVTMK4OutBuf[1] != 0) + else + { + err = 1; + } + if (err) + { + CloseHandle(_hVTMK4VxD[mrtNumber]); + _hVTMK4VxD[mrtNumber] = 0; + return 0; + } + return (_awVTMK4OutBuf[0] + (_awVTMK4OutBuf[1]<<16)); + } + else + return 0; +} + +int mrtselected() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_mrtselected, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return ((int)(_awVTMK4OutBuf[0])); + } + else + return mrtselected_usb(); +} + +TMK_DATA mrtgetstate() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_mrtgetstate, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return mrtgetstate_usb(); +} + +void mrtdefbrcsubaddr0() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_mrtdefbrcsubaddr0, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL); + else + mrtdefbrcsubaddr0_usb(); +} + +int mrtreset() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + return (DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_mrtreset, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL))?0:GetLastError(); + else + return mrtreset_usb(); +} + +TMK_DATA tmktimer(TMK_DATA tmkTimerCtrl) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = tmkTimerCtrl; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_tmktimer, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return tmktimer_usb(tmkTimerCtrl); +} + +DWORD tmkgettimer() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[2]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_tmkgettimer, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 4, &_cbVTMK4Ret, NULL); + return (((DWORD*)(_awVTMK4OutBuf))[0]); + } + else + return tmkgettimer_usb(); +} +TMK_DATA tmkgettimerl() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_tmkgettimerl, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return (TMK_DATA)tmkgettimerl_usb(); +} +DWORD bcgetmsgtime() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[2]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_bcgetmsgtime, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 4, &_cbVTMK4Ret, NULL); + return (((DWORD*)(_awVTMK4OutBuf))[0]); + } + else + return bcgetmsgtime_usb(); +} +DWORD rtgetmsgtime() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[2]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_rtgetmsgtime, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 4, &_cbVTMK4Ret, NULL); + return (((DWORD*)(_awVTMK4OutBuf))[0]); + } + else + return rtgetmsgtime_usb(); +} + +TMK_DATA tmkgethwver() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_tmkgethwver, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return tmkgethwver_usb(); +} + +DWORD tmkgetevtime() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[2]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_tmkgetevtime, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 4, &_cbVTMK4Ret, NULL); + return (((DWORD*)(_awVTMK4OutBuf))[0]); + } + else + return tmkgetevtime_usb(); +} + +TMK_DATA tmkswtimer(TMK_DATA tmkTimerCtrl) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = tmkTimerCtrl; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_tmkswtimer, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return tmkswtimer_usb(tmkTimerCtrl); +} + +DWORD tmkgetswtimer() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[2]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_tmkgetswtimer, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 4, &_cbVTMK4Ret, NULL); + return (((DWORD*)(_awVTMK4OutBuf))[0]); + } + else + return tmkgetswtimer_usb(); +} + +TMK_DATA tmktimeout(TMK_DATA tmkTimeOut) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = tmkTimeOut; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_tmktimeout, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return tmktimeout_usb(tmkTimeOut); +} + +int mrtdefbrcpage(TMK_DATA mrtBrcPage) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = mrtBrcPage; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + return (DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_mrtdefbrcpage, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL))?0:GetLastError(); + else + return mrtdefbrcpage_usb(mrtBrcPage); +} + +TMK_DATA mrtgetbrcpage() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if (!_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_mrtgetbrcpage, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return mrtgetbrcpage_usb(); +} + +int mbcinit(TMK_DATA mbcId) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = mbcId; + if(_VTMK4usbFlag[_VTMK4tmkCurNum] == 0) + return (DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_mbcinit, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL))?0:GetLastError(); + else + return TMK_BAD_NUMBER; +} + +int mbcpreparex(TMK_DATA mbcId, TMK_DATA bcBase, TMK_DATA bcCtrlCode, TMK_DATA mbcDelay) +{ + WORD _awVTMK4InBuf[4], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = mbcId; + _awVTMK4InBuf[1] = bcBase; + _awVTMK4InBuf[2] = bcCtrlCode; + _awVTMK4InBuf[3] = mbcDelay; + if(_VTMK4usbFlag[_VTMK4tmkCurNum] == 0) + return (DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_mbcpreparex, _awVTMK4InBuf, 8, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL))?0:GetLastError(); + else + return TMK_BAD_NUMBER; +} + +int mbcstartx(TMK_DATA mbcId) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = mbcId; + if(_VTMK4usbFlag[_VTMK4tmkCurNum] == 0) + return (DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_mbcstartx, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL))?0:GetLastError(); + else + return TMK_BAD_NUMBER; +} + +TMK_DATA mbcalloc() +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + if(_VTMK4usbFlag[_VTMK4tmkCurNum] == 0) + { + DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_mbcalloc, _awVTMK4InBuf, 0, _awVTMK4OutBuf, 2, &_cbVTMK4Ret, NULL); + return _awVTMK4OutBuf[0]; + } + else + return 0; +} + +int mbcfree(TMK_DATA mbcId) +{ + WORD _awVTMK4InBuf[1], _awVTMK4OutBuf[1]; + DWORD _cbVTMK4Ret; + _awVTMK4InBuf[0] = mbcId; + if(_VTMK4usbFlag[_VTMK4tmkCurNum] == 0) + return (DeviceIoControl(_hVTMK4VxD[_VTMK4tmkCurNum], (DWORD)IOCTL_TMK_mbcfree, _awVTMK4InBuf, 2, _awVTMK4OutBuf, 0, &_cbVTMK4Ret, NULL))?0:GetLastError(); + else + return TMK_BAD_NUMBER; +} + +DWORD MT_Start(DWORD dwBufSize, HANDLE hEvent) +{ + if (_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + return MonitorHwStart_usb(dwBufSize, hEvent); + } + else + return TMK_BAD_NUMBER; +} + +DWORD MT_GetMessage(WORD * Data, DWORD dwBufSize, int FillFlag, DWORD * dwMsWritten) +{ + if (_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + return MonitorHwGetMessage_usb(Data, dwBufSize, FillFlag, dwMsWritten); + } + else + return TMK_BAD_NUMBER; +} + +DWORD MT_Stop() +{ + if (_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + return MonitorHwStop_usb(); + } + else + return TMK_BAD_NUMBER; +} + +unsigned int tmkrawio(unsigned int *buf_out, unsigned int *buf_in) +{ + if (_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + return tmkrawio_usb(buf_out, buf_in); + } + else + return TMK_BAD_NUMBER; +} + +TMK_DATA rtgap(TMK_DATA Gap) +{ + if (_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + return rtgap_usb(Gap); + } + else + return 0; +} + +int tmkreadsn() +{ + if (_VTMK4usbFlag[_VTMK4tmkCurNum]) + { + return tmkreadsn_usb(); + } + else + return TMK_BAD_NUMBER; +} +//#endif diff --git a/WDMTMKv2.h b/WDMTMKv2.h new file mode 100644 index 0000000..3ad16b2 --- /dev/null +++ b/WDMTMKv2.h @@ -0,0 +1,1020 @@ +/*****************************************************************************/ +/* WDMTMK API v4.08 for Microsoft Windows. ELCUS, 1998, 2011. */ +/* Interface to driver TMK1553B.SYS v4.08 */ +/* Interface to driver USB_TA_DRV.dll v1.9.2 for Windows 98/ME/2000/XP */ +/* for Windows 98/ME/2000/XP/Vista/7 */ +/*****************************************************************************/ + +//#ifndef _TMK1553B_ +//#define _TMK1553B_ + +//************************************************************************** +#include +#include +typedef uint16_t WORD; +typedef unsigned __LONG32 DWORD; +typedef void *HANDLE; +typedef int BOOL; +//************************************************************************** + +#define TMK_DATA unsigned short +#define tmkError *ptmkError + +#ifndef _TMK1553B_MRT +#define _TMK1553B_MRT +#endif + +#define TMK_VERSION_MIN 0x0406 /* v4.06 */ +#define TMK_VERSION 0x0408 /* v4.08 */ + +#define EZUSB_MAJOR_VERSION_MIN 02 +#define EZUSB_MINOR_VERSION_MIN 01 + +#ifdef _TMK1553B_MRT +#define MAX_TMK_NUMBER (8+64-1) +#else +#define MAX_TMK_NUMBER (8-1) +#endif //def TMK1553B_MRT + +#ifndef MAX_USBTA_NUM +#define MAX_USBTA_NUM (8-1) +#endif + +#define TMK_INT_TIMER 0x4000 +#define TMK_INT_BUSJAM 0x2000 +#define TMK_INT_FIFO_OVF 0x0400 + +#define MIN_TMK_TYPE 2 +#define MAX_TMK_TYPE 12 + +#define TMK400 2 +#define TMKMPC 3 +#define RTMK400 4 +#define TMKX 5 +#define TMKXI 6 +#define MRTX 7 +#define MRTXI 8 +#define TA 9 +#define TAI 10 +#define MRTA 11 +#define MRTAI 12 + +#define ALL_TMKS 0x00FF + +#define MBC_ALLOC_FAIL 0xFFFF + +#define GET_RT_GAP 0xFFFF +#define RT_GAP_DEFAULT 0 +#define RT_GAP_OPT1 1 + +#define GET_TIMEOUT 0xFFFF + +#define SWTIMER_OFF 0x0000 +#define SWTIMER_ON 0x0400 +#define SWTIMER_EVENT 0x8000 +#define SWTIMER_RESET 0xFBFF + +#define GET_SWTIMER_CTRL 0xFFFF + +#define TIMER_RESET 0xFBFF +#define TIMER_OFF 0x0000 +#define TIMER_16BIT 0x1400 +#define TIMER_32BIT 0x0400 +#define TIMER_1US 0x0000 +#define TIMER_2US 0x0080 +#define TIMER_4US 0x0100 +#define TIMER_8US 0x0180 +#define TIMER_16US 0x0200 +#define TIMER_32US 0x0280 +#define TIMER_64US 0x0300 +#define TIMER_STOP 0x0380 +#define TIMER_SYN 0x0040 +#define TIMER_SYND 0x0020 +#define TIMER_SA 0x001F + +#define TIMER_NOSTOP 0x2000 + +#define TIMER_MASK 0x17FF +#define TIMER_STEP 0x0380 +#define TIMER_BITS 0x3400 + +#define GET_TIMER_CTRL 0xFFFF + +#define DATA_BC_RT 0x00 +#define DATA_BC_RT_BRCST 0x08 +#define DATA_RT_BC 0x01 +#define DATA_RT_RT 0x02 +#define DATA_RT_RT_BRCST 0x0A +#define CTRL_C_A 0x03 +#define CTRL_C_BRCST 0x0B +#define CTRL_CD_A 0x04 +#define CTRL_CD_BRCST 0x0C +#define CTRL_C_AD 0x05 + +#define CC_FMT_1 0x00 +#define CC_FMT_2 0x01 +#define CC_FMT_3 0x02 +#define CC_FMT_4 0x03 +#define CC_FMT_5 0x05 +#define CC_FMT_6 0x04 +#define CC_FMT_7 0x08 +#define CC_FMT_8 0x0A +#define CC_FMT_9 0x0B +#define CC_FMT_10 0x0C + +#define BUS_A 0 +#define BUS_B 1 +#define BUS_1 0 +#define BUS_2 1 + +#define S_ERAO_MASK 0x01 +#define S_MEO_MASK 0x02 +#define S_IB_MASK 0x04 +#define S_TO_MASK 0x08 +#define S_EM_MASK 0x10 +#define S_EBC_MASK 0x20 +#define S_DI_MASK 0x40 +#define S_ELN_MASK 0x80 +#define S_G1_MASK 0x1000 +#define S_G2_MASK 0x2000 + +#define NWORDS_MASK 0x001F +#define CMD_MASK 0x041F +#define SUBADDR_MASK 0x03E0 +#define CI_MASK 0x03E0 +#define HBIT_MASK 0x0200 +#define RT_DIR_MASK 0x0400 +#define ADDRESS_MASK 0xF800 +#define RTFL_MASK 0x0001 +#define DNBA_MASK 0x0002 +#define SSFL_MASK 0x0004 +#define BUSY_MASK 0x0008 +#define BRCST_MASK 0x0010 +#define NULL_MASK 0x00E0 +#define SREQ_MASK 0x0100 +#define ERROR_MASK 0x0400 + +#define SREQ 0x01 +#define BUSY 0x02 +#define SSFL 0x04 +#define RTFL 0x08 +#define DNBA 0x10 + +#define CWB0 0x20 +#define CWB1 0x40 + +#define BC_MODE 0x00 +#define RT_MODE 0x80 +#define MT_MODE 0x100 +#define MRT_MODE 0x280 +#define UNDEFINED_MODE 0xFFFF + +#define RT_TRANSMIT 0x0400 +#define RT_RECEIVE 0x0000 + +#define RT_ERROR_MASK 0x4000 + +#define RT_FLAG 0x8000 +#define RT_FLAG_MASK 0x8000 + +#define RT_HBIT_MODE 0x0001 +#define RT_FLAG_MODE 0x0002 +#define RT_BRCST_MODE 0x0004 +#define RT_DATA_BL 0x2000 +#define RT_GENER1_BL 0x0004 +#define RT_GENER2_BL 0x4000 +#define BC_GENER1_BL 0x0004 +#define BC_GENER2_BL 0x4000 +#define MT_GENER1_BL 0x0004 +#define MT_GENER2_BL 0x4000 +#define TMK_IRQ_OFF 0x8000 + +#define CX_CC_MASK 0x000F +#define CX_CONT_MASK 0x0010 +#define CX_BUS_MASK 0x0020 +#define CX_SIG_MASK 0x8000 +#define CX_INT_MASK 0x0020 + +#define CX_CONT 0x0010 +#define CX_STOP 0x0000 +#define CX_BUS_0 0x0000 +#define CX_BUS_A 0x0000 +#define CX_BUS_1 0x0020 +#define CX_BUS_B 0x0020 +#define CX_NOSIG 0x0000 +#define CX_SIG 0x8000 +#define CX_INT 0x0000 +#define CX_NOINT 0x0020 + +#define SX_NOERR 0 +#define SX_MEO 1 +#define SX_TOA 2 +#define SX_TOD 3 +#define SX_ELN 4 +#define SX_ERAO 5 +#define SX_ESYN 6 +#define SX_EBC 7 + +#define SX_ERR_MASK 0x0007 +#define SX_IB_MASK 0x0008 +#define SX_G1_MASK 0x0010 +#define SX_G2_MASK 0x0020 +#define SX_K2_MASK 0x0100 +#define SX_K1_MASK 0x0200 +#define SX_SCC_MASK 0x3C00 +#define SX_ME_MASK 0x4000 +#define SX_BUS_MASK 0x8000 + +#define SX_BUS_0 0x0000 +#define SX_BUS_A 0x0000 +#define SX_BUS_1 0x8000 +#define SX_BUS_B 0x8000 + +#define GET_IO_DELAY 0xFFFF + +#define RT_ENABLE 0x0000 +#define RT_DISABLE 0x001F +#define RT_GET_ENABLE 0xFFFF + +#define CW(ADDR,DIR,SUBADDR,NWORDS) ((TMK_DATA)(((ADDR)<<11)|(DIR)|((SUBADDR)<<5)|((NWORDS)&0x1F))) +#define CWM(ADDR,COMMAND) ((TMK_DATA)(((ADDR)<<11)|(CI_MASK)|(COMMAND))) +#define CWMC(ADDR,CI,COMMAND) ((TMK_DATA)(((ADDR)<<11)|((CI)&0x03E0)|(COMMAND))) + +/*#define CMD_ILLEGAL 0x000*/ +#define CMD_DYNAMIC_BUS_CONTROL 0x400 +#define CMD_SYNCHRONIZE 0x401 +#define CMD_TRANSMIT_STATUS_WORD 0x402 +#define CMD_INITIATE_SELF_TEST 0x403 +#define CMD_TRANSMITTER_SHUTDOWN 0x404 +#define CMD_OVERRIDE_TRANSMITTER_SHUTDOWN 0x405 +#define CMD_INHIBIT_TERMINAL_FLAG_BIT 0x406 +#define CMD_OVERRIDE_INHIBIT_TERMINAL_FLAG_BIT 0x407 +#define CMD_RESET_REMOTE_TERMINAL 0x408 +#define CMD_TRANSMIT_VECTOR_WORD 0x410 +#define CMD_SYNCHRONIZE_WITH_DATA_WORD 0x011 +#define CMD_TRANSMIT_LAST_COMMAND_WORD 0x412 +#define CMD_TRANSMIT_BUILT_IN_TEST_WORD 0x413 + +#define TMK_ERROR_0 0xE0040000 +#define TMK_BAD_TYPE (1 + TMK_ERROR_0) +#define TMK_BAD_IRQ (2 + TMK_ERROR_0) +#define TMK_BAD_NUMBER (3 + TMK_ERROR_0) +#define BC_BAD_BUS (4 + TMK_ERROR_0) +#define BC_BAD_BASE (5 + TMK_ERROR_0) +#define BC_BAD_LEN (6 + TMK_ERROR_0) +#define RT_BAD_PAGE (7 + TMK_ERROR_0) +#define RT_BAD_LEN (8 + TMK_ERROR_0) +#define RT_BAD_ADDRESS (9 + TMK_ERROR_0) +#define RT_BAD_FUNC (10 + TMK_ERROR_0) +#define BC_BAD_FUNC (11 + TMK_ERROR_0) +#define TMK_BAD_FUNC (12 + TMK_ERROR_0) +#define VTMK_BAD_VERSION (13 + TMK_ERROR_0) + +#define VTMK_tmkconfig 2 +#define VTMK_tmkdone 3 +#define VTMK_tmkgetmaxn 4 +#define VTMK_tmkselect 5 +#define VTMK_tmkselected 6 +#define VTMK_tmkgetmode 7 +#define VTMK_tmksetcwbits 8 +#define VTMK_tmkclrcwbits 9 +#define VTMK_tmkgetcwbits 10 +#define VTMK_tmkdefevent 11 +#define VTMK_tmkgetevd 12 + +#define VTMK_bcreset 13 +#define VTMK_bc_def_tldw 14 +#define VTMK_bc_enable_di 15 +#define VTMK_bc_disable_di 16 +#define VTMK_bcdefirqmode 17 +#define VTMK_bcgetirqmode 18 +#define VTMK_bcgetmaxbase 19 +#define VTMK_bcdefbase 20 +#define VTMK_bcgetbase 21 +#define VTMK_bcputw 22 +#define VTMK_bcgetw 23 +#define VTMK_bcgetansw 24 +#define VTMK_bcputblk 25 +#define VTMK_bcgetblk 26 +#define VTMK_bcdefbus 27 +#define VTMK_bcgetbus 28 +#define VTMK_bcstart 29 +#define VTMK_bcstartx 30 +#define VTMK_bcdeflink 31 +#define VTMK_bcgetlink 32 +#define VTMK_bcstop 33 +#define VTMK_bcgetstate 34 + +#define VTMK_rtreset 35 +#define VTMK_rtdefirqmode 36 +#define VTMK_rtgetirqmode 37 +#define VTMK_rtdefmode 38 +#define VTMK_rtgetmode 39 +#define VTMK_rtgetmaxpage 40 +#define VTMK_rtdefpage 41 +#define VTMK_rtgetpage 42 +#define VTMK_rtdefpagepc 43 +#define VTMK_rtdefpagebus 44 +#define VTMK_rtgetpagepc 45 +#define VTMK_rtgetpagebus 46 +#define VTMK_rtdefaddress 47 +#define VTMK_rtgetaddress 48 +#define VTMK_rtdefsubaddr 49 +#define VTMK_rtgetsubaddr 50 +#define VTMK_rtputw 51 +#define VTMK_rtgetw 52 +#define VTMK_rtputblk 53 +#define VTMK_rtgetblk 54 +#define VTMK_rtsetanswbits 55 +#define VTMK_rtclranswbits 56 +#define VTMK_rtgetanswbits 57 +#define VTMK_rtgetflags 58 +#define VTMK_rtputflags 59 +#define VTMK_rtsetflag 60 +#define VTMK_rtclrflag 61 +#define VTMK_rtgetflag 62 +#define VTMK_rtgetstate 63 +#define VTMK_rtbusy 64 +#define VTMK_rtlock 65 +#define VTMK_rtunlock 66 +#define VTMK_rtgetcmddata 67 +#define VTMK_rtputcmddata 68 + +#define VTMK_mtreset 69 +#define VTMK_mtdefirqmode 70 +#define VTMK_mtgetirqmode 71 +#define VTMK_mtgetmaxbase 72 +#define VTMK_mtdefbase 73 +#define VTMK_mtgetbase 74 +#define VTMK_mtputw 75 +#define VTMK_mtgetw 76 +#define VTMK_mtgetsw 77 +#define VTMK_mtputblk 78 +#define VTMK_mtgetblk 79 +#define VTMK_mtstartx 80 +#define VTMK_mtdeflink 81 +#define VTMK_mtgetlink 82 +#define VTMK_mtstop 83 +#define VTMK_mtgetstate 84 + +#define VTMK_tmkgetinfo 85 +#define VTMK_GetVersion 86 + +#define VTMK_rtenable 87 + +#define VTMK_mrtgetmaxn 88 +#define VTMK_mrtconfig 89 +#define VTMK_mrtselected 90 +#define VTMK_mrtgetstate 91 +#define VTMK_mrtdefbrcsubaddr0 92 +#define VTMK_mrtreset 93 + +#define VTMK_tmktimer 94 +#define VTMK_tmkgettimer 95 +#define VTMK_tmkgettimerl 96 +#define VTMK_bcgetmsgtime 97 +#define VTMK_mtgetmsgtime 98 +#define VTMK_rtgetmsgtime 99 + +#define VTMK_tmkgethwver 100 + +#define VTMK_tmkgetevtime 101 +#define VTMK_tmkswtimer 102 +#define VTMK_tmkgetswtimer 103 + +#define VTMK_tmktimeout 104 + +#define VTMK_mrtdefbrcpage 105 +#define VTMK_mrtgetbrcpage 106 + +#define VTMK_mbcinit 107 +#define VTMK_mbcpreparex 108 +#define VTMK_mbcstartx 109 +#define VTMK_mbcalloc 110 +#define VTMK_mbcfree 111 + +#define CTL_CODE( DeviceType, Function, Method, Access ) ( \ + ((DeviceType) << 16) | ((Access) << 14) | ((Function) << 2) | (Method) \ +) + + +#define METHOD_BUFFERED 0 +#define METHOD_IN_DIRECT 1 +#define METHOD_OUT_DIRECT 2 +#define METHOD_NEITHER 3 +#define FILE_ANY_ACCESS 0 +#define FILE_READ_ACCESS ( 0x0001 ) // file & pipe +#define FILE_WRITE_ACCESS ( 0x0002 ) // file & pipe +#define TMK_KRNLDRVR 0x8000 +#define IOCTL_TMK_tmkconfig CTL_CODE(TMK_KRNLDRVR, VTMK_tmkconfig+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_tmkdone CTL_CODE(TMK_KRNLDRVR, VTMK_tmkdone+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_tmkgetmaxn CTL_CODE(TMK_KRNLDRVR, VTMK_tmkgetmaxn+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_tmkselect CTL_CODE(TMK_KRNLDRVR, VTMK_tmkselect+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_tmkselected CTL_CODE(TMK_KRNLDRVR, VTMK_tmkselected+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_tmkgetmode CTL_CODE(TMK_KRNLDRVR, VTMK_tmkgetmode+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_tmksetcwbits CTL_CODE(TMK_KRNLDRVR, VTMK_tmksetcwbits+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_tmkclrcwbits CTL_CODE(TMK_KRNLDRVR, VTMK_tmkclrcwbits+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_tmkgetcwbits CTL_CODE(TMK_KRNLDRVR, VTMK_tmkgetcwbits+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_tmkdefevent CTL_CODE(TMK_KRNLDRVR, VTMK_tmkdefevent+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_tmkgetevd CTL_CODE(TMK_KRNLDRVR, VTMK_tmkgetevd+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_bcreset CTL_CODE(TMK_KRNLDRVR, VTMK_bcreset+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_bc_def_tldw CTL_CODE(TMK_KRNLDRVR, VTMK_bc_def_tldw+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_bc_enable_di CTL_CODE(TMK_KRNLDRVR, VTMK_bc_enable_di+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_bc_disable_di CTL_CODE(TMK_KRNLDRVR, VTMK_bc_disable_di+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_bcdefirqmode CTL_CODE(TMK_KRNLDRVR, VTMK_bcdefirqmode+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_bcgetirqmode CTL_CODE(TMK_KRNLDRVR, VTMK_bcgetirqmode+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_bcgetmaxbase CTL_CODE(TMK_KRNLDRVR, VTMK_bcgetmaxbase+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_bcdefbase CTL_CODE(TMK_KRNLDRVR, VTMK_bcdefbase+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_bcgetbase CTL_CODE(TMK_KRNLDRVR, VTMK_bcgetbase+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_bcputw CTL_CODE(TMK_KRNLDRVR, VTMK_bcputw+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_bcgetw CTL_CODE(TMK_KRNLDRVR, VTMK_bcgetw+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_bcgetansw CTL_CODE(TMK_KRNLDRVR, VTMK_bcgetansw+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_bcputblk CTL_CODE(TMK_KRNLDRVR, VTMK_bcputblk+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_bcgetblk CTL_CODE(TMK_KRNLDRVR, VTMK_bcgetblk+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_bcdefbus CTL_CODE(TMK_KRNLDRVR, VTMK_bcdefbus+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_bcgetbus CTL_CODE(TMK_KRNLDRVR, VTMK_bcgetbus+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_bcstart CTL_CODE(TMK_KRNLDRVR, VTMK_bcstart+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_bcstartx CTL_CODE(TMK_KRNLDRVR, VTMK_bcstartx+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_bcdeflink CTL_CODE(TMK_KRNLDRVR, VTMK_bcdeflink+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_bcgetlink CTL_CODE(TMK_KRNLDRVR, VTMK_bcgetlink+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_bcstop CTL_CODE(TMK_KRNLDRVR, VTMK_bcstop+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_bcgetstate CTL_CODE(TMK_KRNLDRVR, VTMK_bcgetstate+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) + +#define IOCTL_TMK_rtreset CTL_CODE(TMK_KRNLDRVR, VTMK_rtreset+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtdefirqmode CTL_CODE(TMK_KRNLDRVR, VTMK_rtdefirqmode+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtgetirqmode CTL_CODE(TMK_KRNLDRVR, VTMK_rtgetirqmode+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtdefmode CTL_CODE(TMK_KRNLDRVR, VTMK_rtdefmode+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtgetmode CTL_CODE(TMK_KRNLDRVR, VTMK_rtgetmode+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtgetmaxpage CTL_CODE(TMK_KRNLDRVR, VTMK_rtgetmaxpage+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtdefpage CTL_CODE(TMK_KRNLDRVR, VTMK_rtdefpage+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtgetpage CTL_CODE(TMK_KRNLDRVR, VTMK_rtgetpage+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtdefpagepc CTL_CODE(TMK_KRNLDRVR, VTMK_rtdefpagepc+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtdefpagebus CTL_CODE(TMK_KRNLDRVR, VTMK_rtdefpagebus+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtgetpagepc CTL_CODE(TMK_KRNLDRVR, VTMK_rtgetpagepc+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtgetpagebus CTL_CODE(TMK_KRNLDRVR, VTMK_rtgetpagebus+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtdefaddress CTL_CODE(TMK_KRNLDRVR, VTMK_rtdefaddress+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtgetaddress CTL_CODE(TMK_KRNLDRVR, VTMK_rtgetaddress+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtdefsubaddr CTL_CODE(TMK_KRNLDRVR, VTMK_rtdefsubaddr+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtgetsubaddr CTL_CODE(TMK_KRNLDRVR, VTMK_rtgetsubaddr+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtputw CTL_CODE(TMK_KRNLDRVR, VTMK_rtputw+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtgetw CTL_CODE(TMK_KRNLDRVR, VTMK_rtgetw+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtputblk CTL_CODE(TMK_KRNLDRVR, VTMK_rtputblk+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtgetblk CTL_CODE(TMK_KRNLDRVR, VTMK_rtgetblk+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtsetanswbits CTL_CODE(TMK_KRNLDRVR, VTMK_rtsetanswbits+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtclranswbits CTL_CODE(TMK_KRNLDRVR, VTMK_rtclranswbits+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtgetanswbits CTL_CODE(TMK_KRNLDRVR, VTMK_rtgetanswbits+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtgetflags CTL_CODE(TMK_KRNLDRVR, VTMK_rtgetflags+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtputflags CTL_CODE(TMK_KRNLDRVR, VTMK_rtputflags+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtsetflag CTL_CODE(TMK_KRNLDRVR, VTMK_rtsetflag+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtclrflag CTL_CODE(TMK_KRNLDRVR, VTMK_rtclrflag+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtgetflag CTL_CODE(TMK_KRNLDRVR, VTMK_rtgetflag+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtgetstate CTL_CODE(TMK_KRNLDRVR, VTMK_rtgetstate+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtbusy CTL_CODE(TMK_KRNLDRVR, VTMK_rtbusy+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtlock CTL_CODE(TMK_KRNLDRVR, VTMK_rtlock+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtunlock CTL_CODE(TMK_KRNLDRVR, VTMK_rtunlock+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtgetcmddata CTL_CODE(TMK_KRNLDRVR, VTMK_rtgetcmddata+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtputcmddata CTL_CODE(TMK_KRNLDRVR, VTMK_rtputcmddata+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) + +#define IOCTL_TMK_mtreset CTL_CODE(TMK_KRNLDRVR, VTMK_mtreset+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mtdefirqmode CTL_CODE(TMK_KRNLDRVR, VTMK_mtdefirqmode+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mtgetirqmode CTL_CODE(TMK_KRNLDRVR, VTMK_mtgetirqmode+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mtgetmaxbase CTL_CODE(TMK_KRNLDRVR, VTMK_mtgetmaxbase+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mtdefbase CTL_CODE(TMK_KRNLDRVR, VTMK_mtdefbase+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mtgetbase CTL_CODE(TMK_KRNLDRVR, VTMK_mtgetbase+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mtputw CTL_CODE(TMK_KRNLDRVR, VTMK_mtputw+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mtgetw CTL_CODE(TMK_KRNLDRVR, VTMK_mtgetw+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mtgetsw CTL_CODE(TMK_KRNLDRVR, VTMK_mtgetsw+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mtputblk CTL_CODE(TMK_KRNLDRVR, VTMK_mtputblk+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mtgetblk CTL_CODE(TMK_KRNLDRVR, VTMK_mtgetblk+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mtstartx CTL_CODE(TMK_KRNLDRVR, VTMK_mtstartx+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mtdeflink CTL_CODE(TMK_KRNLDRVR, VTMK_mtdeflink+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mtgetlink CTL_CODE(TMK_KRNLDRVR, VTMK_mtgetlink+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mtstop CTL_CODE(TMK_KRNLDRVR, VTMK_mtstop+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mtgetstate CTL_CODE(TMK_KRNLDRVR, VTMK_mtgetstate+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) + +#define IOCTL_TMK_tmkgetinfo CTL_CODE(TMK_KRNLDRVR, VTMK_tmkgetinfo+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_GetVersion CTL_CODE(TMK_KRNLDRVR, VTMK_GetVersion+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) + +#define IOCTL_TMK_rtenable CTL_CODE(TMK_KRNLDRVR, VTMK_rtenable+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) + +#define IOCTL_TMK_mrtgetmaxn CTL_CODE(TMK_KRNLDRVR, VTMK_mrtgetmaxn+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mrtconfig CTL_CODE(TMK_KRNLDRVR, VTMK_mrtconfig+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mrtselected CTL_CODE(TMK_KRNLDRVR, VTMK_mrtselected+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mrtgetstate CTL_CODE(TMK_KRNLDRVR, VTMK_mrtgetstate+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mrtdefbrcsubaddr0 CTL_CODE(TMK_KRNLDRVR, VTMK_mrtdefbrcsubaddr0+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mrtreset CTL_CODE(TMK_KRNLDRVR, VTMK_mrtreset+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) + +#define IOCTL_TMK_tmktimer CTL_CODE(TMK_KRNLDRVR, VTMK_tmktimer+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_tmkgettimer CTL_CODE(TMK_KRNLDRVR, VTMK_tmkgettimer+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_tmkgettimerl CTL_CODE(TMK_KRNLDRVR, VTMK_tmkgettimerl+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_bcgetmsgtime CTL_CODE(TMK_KRNLDRVR, VTMK_bcgetmsgtime+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mtgetmsgtime CTL_CODE(TMK_KRNLDRVR, VTMK_mtgetmsgtime+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_rtgetmsgtime CTL_CODE(TMK_KRNLDRVR, VTMK_rtgetmsgtime+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) + +#define IOCTL_TMK_tmkgethwver CTL_CODE(TMK_KRNLDRVR, VTMK_tmkgethwver+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) + +#define IOCTL_TMK_tmkgetevtime CTL_CODE(TMK_KRNLDRVR, VTMK_tmkgetevtime+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_tmkswtimer CTL_CODE(TMK_KRNLDRVR, VTMK_tmkswtimer+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_tmkgetswtimer CTL_CODE(TMK_KRNLDRVR, VTMK_tmkgetswtimer+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) + +#define IOCTL_TMK_tmktimeout CTL_CODE(TMK_KRNLDRVR, VTMK_tmktimeout+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) + +#define IOCTL_TMK_mrtdefbrcpage CTL_CODE(TMK_KRNLDRVR, VTMK_mrtdefbrcpage+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mrtgetbrcpage CTL_CODE(TMK_KRNLDRVR, VTMK_mrtgetbrcpage+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) + +#define IOCTL_TMK_mbcinit CTL_CODE(TMK_KRNLDRVR, VTMK_mbcinit+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mbcpreparex CTL_CODE(TMK_KRNLDRVR, VTMK_mbcpreparex+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mbcstartx CTL_CODE(TMK_KRNLDRVR, VTMK_mbcstartx+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mbcalloc CTL_CODE(TMK_KRNLDRVR, VTMK_mbcalloc+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_TMK_mbcfree CTL_CODE(TMK_KRNLDRVR, VTMK_mbcfree+0x800, METHOD_NEITHER, FILE_ANY_ACCESS) + +#define Ezusb_IOCTL_INDEX 0x0800 +#define FILE_DEVICE_UNKNOWN 0x00000022 + +#define IOCTL_EZUSB_GET_DRIVER_VERSION CTL_CODE(FILE_DEVICE_UNKNOWN, Ezusb_IOCTL_INDEX+29, METHOD_BUFFERED, FILE_ANY_ACCESS) +#define IOCTL_EZUSB_SET_CURPROC CTL_CODE(FILE_DEVICE_UNKNOWN, Ezusb_IOCTL_INDEX+34, METHOD_BUFFERED, FILE_ANY_ACCESS) + +typedef struct _EZUSB_DRIVER_VERSION +{ + WORD MajorVersion; + WORD MinorVersion; + WORD BuildVersion; +} EZUSB_DRIVER_VERSION, *PEZUSB_DRIVER_VERSION; + +typedef struct +{ + short nType; + char szName[10]; + unsigned short wPorts1; + unsigned short wPorts2; + unsigned short wIrq1; + unsigned short wIrq2; + unsigned short wIODelay; +} TTmkConfigData; + +typedef struct +{ + int nInt; + unsigned short wMode; + union + { + struct + { + unsigned short wResult; + unsigned short wAW1; + unsigned short wAW2; + } bc; + struct + { + unsigned short wBase; + unsigned short wResultX; + } bcx; + struct + { + unsigned short wStatus; + unsigned short wCmd; + } rt; + struct + { + unsigned short wBase; + unsigned short wResultX; + } mt; + struct + { + unsigned short wStatus; + } mrt; + struct + { + unsigned short wRequest; +// DWORD dwTimer; + } tmk; + struct + { + unsigned short wData1; + unsigned short wData2; + } raw; + }; +} TTmkEventData; + +DWORD TmkOpen(); +void TmkClose(); +void tmkgetinfo(TTmkConfigData *pConfD); +void tmkgetevd( TTmkEventData *pEvD ); +void tmkdefevent( HANDLE hEvent, BOOL fEventSet ); +int tmkgetmaxn(); +int tmkconfig( int tmkNumber ); +int tmkdone( int tmkNumber ); +int tmkselect( int tmkNumber ); +int tmkselected(); +TMK_DATA tmkgetmode(); +int tmkdefdac(int dacValue); +int tmkgetdac(int *dacValue, int *dacMode); +void tmksetcwbits( TMK_DATA tmkSetControl ); +void tmkclrcwbits( TMK_DATA tmkClrControl ); +TMK_DATA tmkgetcwbits(); +int bcreset(); +void bc_def_tldw( TMK_DATA wTLDW ); +void bc_enable_di(); +void bc_disable_di(); +int bcdefirqmode( TMK_DATA bcIrqMode ); +TMK_DATA bcgetirqmode(); +TMK_DATA bcgetmaxbase(); +int bcdefbase( TMK_DATA bcBasePC ); +TMK_DATA bcgetbase(); +void bcputw( TMK_DATA bcAddr, TMK_DATA bcData ); +TMK_DATA bcgetw( TMK_DATA bcAddr ); +DWORD bcgetansw( TMK_DATA bcCtrlCode ); +void bcputblk( TMK_DATA bcAddr, void *pcBuffer, TMK_DATA cwLength ); +void bcgetblk( TMK_DATA bcAddr, void *pcBuffer, TMK_DATA cwLength ); +int bcdefbus( TMK_DATA bcBus ); +TMK_DATA bcgetbus(); +int bcstart( TMK_DATA bcBase, TMK_DATA bcCtrlCode ); +int bcstartx( TMK_DATA bcBase, TMK_DATA bcCtrlCode ); +int bcdeflink( TMK_DATA bcBase, TMK_DATA bcCtrlCode ); +DWORD bcgetlink(); +TMK_DATA bcstop(); +DWORD bcgetstate(); +int rtreset(); +int rtdefirqmode( TMK_DATA rtIrqMode ); +TMK_DATA rtgetirqmode(); +int rtdefmode( TMK_DATA rtMode ); +TMK_DATA rtgetmode(); +TMK_DATA rtgetmaxpage(); +int rtdefpage( TMK_DATA rtPage ); +TMK_DATA rtgetpage(); +int rtdefpagepc( TMK_DATA rtPagePC ); +int rtdefpagebus( TMK_DATA rtPageBus ); +TMK_DATA rtgetpagepc(); +TMK_DATA rtgetpagebus(); +int rtdefaddress( TMK_DATA rtAddress ); +TMK_DATA rtgetaddress(); +void rtdefsubaddr( TMK_DATA rtDir, TMK_DATA rtSubAddr); +TMK_DATA rtgetsubaddr(); +void rtputw( TMK_DATA rtAddr, TMK_DATA rtData ); +TMK_DATA rtgetw( TMK_DATA rtAddr ); +void rtputblk( TMK_DATA rtAddr, void *pcBuffer, TMK_DATA cwLength ); +void rtgetblk( TMK_DATA rtAddr, void *pcBuffer, TMK_DATA cwLength ); +void rtsetanswbits( TMK_DATA rtSetControl ); +void rtclranswbits( TMK_DATA rtClrControl ); +TMK_DATA rtgetanswbits(); +void rtgetflags( void *pcBuffer, TMK_DATA rtDir, TMK_DATA rtFlagMin, TMK_DATA rtFlagMax ); +void rtputflags( void *pcBuffer, TMK_DATA rtDir, TMK_DATA rtFlagMin, TMK_DATA rtFlagMax ); +void rtsetflag(); +void rtclrflag(); +TMK_DATA rtgetflag( TMK_DATA rtDir, TMK_DATA rtSubAddr ); +TMK_DATA rtgetstate(); +TMK_DATA rtbusy(); +void rtlock( TMK_DATA rtDir, TMK_DATA rtSubAddr ); +void rtunlock(); +TMK_DATA rtgetcmddata( TMK_DATA rtBusCommand ); +void rtputcmddata( TMK_DATA rtBusCommand, TMK_DATA rtData ); +int mtreset(); +TMK_DATA mtgetsw(); +#define mtdefirqmode bcdefirqmode +#define mtgetirqmode bcgetirqmode +#define mtgetmaxbase bcgetmaxbase +#define mtdefbase bcdefbase +#define mtgetbase bcgetbase +#define mtputw bcputw +#define mtgetw bcgetw +#define mtputblk bcputblk +#define mtgetblk bcgetblk +#define mtstartx bcstartx +#define mtdeflink bcdeflink +#define mtgetlink bcgetlink +#define mtstop bcstop +#define mtgetstate bcgetstate + +TMK_DATA rtenable(TMK_DATA rtEnable); + +int mrtgetmaxn(); +DWORD mrtconfig(int tmkNumber); +int mrtselected(); +TMK_DATA mrtgetstate(); +void mrtdefbrcsubaddr0(); +int mrtreset(); + +TMK_DATA tmktimer(TMK_DATA tmkTimerCtrl); +DWORD tmkgettimer(); +TMK_DATA tmkgettimerl(); +DWORD bcgetmsgtime(); +#define mtgetmsgtime bcgetmsgtime +DWORD rtgetmsgtime(); +TMK_DATA tmkgethwver(); + +DWORD tmkgetevtime(); +TMK_DATA tmkswtimer(TMK_DATA tmkTimerCtrl); +DWORD tmkgetswtimer(); + +TMK_DATA tmktimeout(TMK_DATA tmkTimeOut); + +int mrtdefbrcpage(TMK_DATA mrtBrcPage); +TMK_DATA mrtgetbrcpage(); + +int mbcinit(TMK_DATA mbcId); +int mbcpreparex(TMK_DATA mbcId, TMK_DATA bcBase, TMK_DATA bcCtrlCode, TMK_DATA mbcDelay); +int mbcstartx(TMK_DATA mbcId); +TMK_DATA mbcalloc(); +int mbcfree(TMK_DATA mbcId); + +DWORD MT_Start(DWORD dwBufSize, HANDLE hEvent); +DWORD MT_GetMessage(WORD * Data, DWORD dwBufSize, int FillFlag, DWORD * dwMsWritten); +DWORD MT_Stop(); + +unsigned int tmkrawio(unsigned int *buf_out, unsigned int *buf_in); +TMK_DATA rtgap(TMK_DATA Gap); +int tmkreadsn(); + +typedef struct +{ + int nInt; + unsigned int empty; + unsigned int wMode; + unsigned int awEvData[3]; +// PEPROCESS hProc; + unsigned int empty1; + unsigned int empty2; +} TListEvD, *pTListEvD; + +typedef int (__cdecl *htmkconfig_usb) (int tmkNumber, int wType, int PortsAddr1, int PortsAddr2); +typedef int (__cdecl *htmkdone_usb) (int tmkNumber); +typedef int (__cdecl *htmkselect_usb)(int tmkNumber); +typedef void (__cdecl *htmkdefevent_usb)(void *hEvent); +typedef int (__cdecl *hRead_DLL_EvD_usb)(TListEvD *evd); +typedef void (__cdecl *htmksetcwbits_usb)(TMK_DATA tmkSetControl); +typedef void (__cdecl *htmkclrcwbits_usb)(TMK_DATA tmkClrControl); +typedef TMK_DATA (__cdecl *htmkgetcwbits_usb)(); +typedef TMK_DATA (__cdecl *htmkgetmode_usb)(); +typedef int (__cdecl *htmkdefdac_usb)(int dacValue); +typedef int (__cdecl *htmkgetdac_usb)(int *value, int *mode); +typedef int (__cdecl *hbcreset_usb)(); +typedef int (__cdecl *hbcdefirqmode_usb)(TMK_DATA bcIrqMode); +typedef TMK_DATA (__cdecl *hbcgetirqmode_usb)(); +typedef TMK_DATA (__cdecl *hbcgetmaxbase_usb)(); +typedef int (__cdecl *hbcdefbase_usb)(TMK_DATA bcBasePC); +typedef TMK_DATA (__cdecl *hbcgetbase_usb)(); +typedef void (__cdecl *hbcputw_usb)(TMK_DATA bcAddr, TMK_DATA bcData); +typedef TMK_DATA (__cdecl *hbcgetw_usb)(TMK_DATA bcAddr); +typedef DWORD (__cdecl *hbcgetansw_usb)(TMK_DATA bcCtrlCode); +typedef void (__cdecl *hbcputblk_usb)(TMK_DATA bcAddr, void *pcBuffer, TMK_DATA cwLength); +typedef void (__cdecl *hbcgetblk_usb)(TMK_DATA bcAddr, void *pcBuffer, TMK_DATA cwLength); +typedef int (__cdecl *hbcdefbus_usb)(TMK_DATA bcBus); +typedef TMK_DATA (__cdecl *hbcgetbus_usb)(); +typedef int (__cdecl *hbcstart_usb)(TMK_DATA bcBase, TMK_DATA bcCtrlCode); +typedef int (__cdecl *hbcstartx_usb)(TMK_DATA bcBase, TMK_DATA bcCtrlCode); +typedef int (__cdecl *hbcdeflink_usb)(TMK_DATA bcBase, TMK_DATA bcCtrlCode); +typedef DWORD (__cdecl *hbcgetlink_usb)(); +typedef TMK_DATA (__cdecl *hbcstop_usb)(); +typedef DWORD (__cdecl *hbcgetstate_usb)(); +typedef int (__cdecl *hrtreset_usb)(); +typedef int (__cdecl *hrtdefirqmode_usb)(TMK_DATA rtIrqMode); +typedef TMK_DATA (__cdecl *hrtgetirqmode_usb)(); +typedef int (__cdecl *hrtdefmode_usb)(TMK_DATA rtMode); +typedef TMK_DATA (__cdecl *hrtgetmode_usb)(); +typedef TMK_DATA (__cdecl *hrtgetmaxpage_usb)(); +typedef int (__cdecl *hrtdefpage_usb)(TMK_DATA rtPage); +typedef TMK_DATA (__cdecl *hrtgetpage_usb)(); +typedef int (__cdecl *hrtdefpagepc_usb)(TMK_DATA rtPagePC); +typedef int (__cdecl *hrtdefpagebus_usb)(TMK_DATA rtPageBus); +typedef TMK_DATA (__cdecl *hrtgetpagepc_usb)(); +typedef TMK_DATA (__cdecl *hrtgetpagebus_usb)(); +typedef int (__cdecl *hrtdefaddress_usb)(TMK_DATA rtAddress); +typedef TMK_DATA (__cdecl *hrtgetaddress_usb)(); +typedef void (__cdecl *hrtdefsubaddr_usb)(TMK_DATA rtDir, TMK_DATA rtSubAddr); +typedef TMK_DATA (__cdecl *hrtgetsubaddr_usb)(); +typedef void (__cdecl *hrtputw_usb)(TMK_DATA rtAddr, TMK_DATA rtData); +typedef TMK_DATA (__cdecl *hrtgetw_usb)(TMK_DATA rtAddr); +typedef void (__cdecl *hrtputblk_usb)(TMK_DATA rtAddr, void *pcBuffer, TMK_DATA cwLength); +typedef void (__cdecl *hrtgetblk_usb)(TMK_DATA rtAddr, void *pcBuffer, TMK_DATA cwLength); +typedef void (__cdecl *hrtsetanswbits_usb)(TMK_DATA rtSetControl); +typedef void (__cdecl *hrtclranswbits_usb)(TMK_DATA rtClrControl); +typedef TMK_DATA (__cdecl *hrtgetanswbits_usb)(); +typedef void (__cdecl *hrtgetflags_usb)(void *pcBuffer, TMK_DATA rtDir, TMK_DATA rtFlagMin, TMK_DATA rtFlagMax); +typedef void (__cdecl *hrtputflags_usb)(void *pcBuffer, TMK_DATA rtDir, TMK_DATA rtFlagMin, TMK_DATA rtFlagMax); +typedef void (__cdecl *hrtsetflag_usb)(); +typedef void (__cdecl *hrtclrflag_usb)(); +typedef TMK_DATA (__cdecl *hrtgetflag_usb)(TMK_DATA rtDir, TMK_DATA rtSubAddr); +typedef void (__cdecl *hrtputflag_usb)(TMK_DATA rtDir, TMK_DATA rtSubAddr, TMK_DATA rtFlag); +typedef TMK_DATA (__cdecl *hrtgetstate_usb)(); +typedef TMK_DATA (__cdecl *hrtbusy_usb)(); +typedef void (__cdecl *hrtlock_usb)(TMK_DATA rtDir, TMK_DATA rtSubAddr); +typedef void (__cdecl *hrtunlock_usb)(); +typedef TMK_DATA (__cdecl *hrtgetcmddata_usb)(TMK_DATA rtBusCommand); +typedef void (__cdecl *hrtputcmddata_usb)(TMK_DATA rtBusCommand, TMK_DATA rtData); +typedef int (__cdecl *hmtreset_usb)(); +typedef TMK_DATA (__cdecl *hmtgetsw_usb)(); +typedef TMK_DATA (__cdecl *hrtenable_usb)(TMK_DATA rtEnable); +typedef int (__cdecl *hmrtselected_usb)(); +typedef TMK_DATA (__cdecl *hmrtgetstate_usb)(); +typedef void (__cdecl *hmrtdefbrcsubaddr0_usb)(); +typedef int (__cdecl *hmrtreset_usb)(); +typedef TMK_DATA (__cdecl *htmktimer_usb)(TMK_DATA TimerCtrl); +typedef DWORD (__cdecl *htmkgettimer_usb)(); +typedef DWORD (__cdecl *htmkgettimerl_usb)(); +typedef DWORD (__cdecl *hbcgetmsgtime_usb)(); +typedef DWORD (__cdecl *hrtgetmsgtime_usb)(); +typedef TMK_DATA (__cdecl *htmkgethwver_usb)(); +typedef DWORD (__cdecl *htmkgetevtime_usb)(); +typedef TMK_DATA (__cdecl *htmkswtimer_usb)(TMK_DATA tmkTimerCtrl); +typedef DWORD (__cdecl *htmkgetswtimer_usb)(); +typedef TMK_DATA (__cdecl *htmktimeout_usb)(TMK_DATA tmkTimeOut); +typedef int (__cdecl *hmrtdefbrcpage_usb)(TMK_DATA mrtBrcPage); +typedef TMK_DATA (__cdecl *hmrtgetbrcpage_usb)(); + +typedef DWORD (__cdecl *hMonitorHwStart_usb)(DWORD dwBufSize, HANDLE hEvent); +typedef DWORD (__cdecl *hMonitorHwGetMessage_usb)(WORD * Data, DWORD dwBufSize, BOOL FillFlag, DWORD * dwMsWritten); +typedef DWORD (__cdecl *hMonitorHwStop_usb)(void); + +typedef unsigned int (__cdecl *htmkrawio_usb)(unsigned int *buf_out, unsigned int *buf_in); +typedef TMK_DATA (__cdecl *hrtgap_usb)(TMK_DATA Gap); +typedef int (__cdecl *htmkreadsn_usb)(void); + +int ftmkError = -1; + +int ftmkconfig_usb (int tmkNumber, int wType, int PortsAddr1, int PortsAddr2){return -1;} +int ftmkdone_usb (int tmkNumber){return -1;} +int ftmkselect_usb(int tmkNumber){return -1;} +void ftmkdefevent_usb(void *hEvent){} +int fRead_DLL_EvD_usb(TListEvD *evd){return -1;} +void ftmksetcwbits_usb(TMK_DATA tmkSetControl){} +void ftmkclrcwbits_usb(TMK_DATA tmkClrControl){} +TMK_DATA ftmkgetcwbits_usb(){return -1;} +TMK_DATA ftmkgetmode_usb(){return -1;} +int ftmkdefdac_usb(int dacValue){return -1;} +int ftmkgetdac_usb(int *value, int *mode){return -1;} +int fbcreset_usb(){return -1;} +int fbcdefirqmode_usb(TMK_DATA bcIrqMode){return -1;} +TMK_DATA fbcgetirqmode_usb(){return -1;} +TMK_DATA fbcgetmaxbase_usb(){return -1;} +int fbcdefbase_usb(TMK_DATA bcBasePC){return -1;} +TMK_DATA fbcgetbase_usb(){return -1;} +void fbcputw_usb(TMK_DATA bcAddr, TMK_DATA bcData){} +TMK_DATA fbcgetw_usb(TMK_DATA bcAddr){return -1;} +DWORD fbcgetansw_usb(TMK_DATA bcCtrlCode){return -1;} +void fbcputblk_usb(TMK_DATA bcAddr, void *pcBuffer, TMK_DATA cwLength){} +void fbcgetblk_usb(TMK_DATA bcAddr, void *pcBuffer, TMK_DATA cwLength){} +int fbcdefbus_usb(TMK_DATA bcBus){return -1;} +TMK_DATA fbcgetbus_usb(){return -1;} +int fbcstart_usb(TMK_DATA bcBase, TMK_DATA bcCtrlCode){return -1;} +int fbcstartx_usb(TMK_DATA bcBase, TMK_DATA bcCtrlCode){return -1;} +int fbcdeflink_usb(TMK_DATA bcBase, TMK_DATA bcCtrlCode){return -1;} +DWORD fbcgetlink_usb(){return -1;} +TMK_DATA fbcstop_usb(){return -1;} +DWORD fbcgetstate_usb(){return -1;} +int frtreset_usb(){return -1;} +int frtdefirqmode_usb(TMK_DATA rtIrqMode){return -1;} +TMK_DATA frtgetirqmode_usb(){return -1;} +int frtdefmode_usb(TMK_DATA rtMode){return -1;} +TMK_DATA frtgetmode_usb(){return -1;} +TMK_DATA frtgetmaxpage_usb(){return -1;} +int frtdefpage_usb(TMK_DATA rtPage){return -1;} +TMK_DATA frtgetpage_usb(){return -1;} +int frtdefpagepc_usb(TMK_DATA rtPagePC){return -1;} +int frtdefpagebus_usb(TMK_DATA rtPageBus){return -1;} +TMK_DATA frtgetpagepc_usb(){return -1;} +TMK_DATA frtgetpagebus_usb(){return -1;} +int frtdefaddress_usb(TMK_DATA rtAddress){return -1;} +TMK_DATA frtgetaddress_usb(){return -1;} +void frtdefsubaddr_usb(TMK_DATA rtDir, TMK_DATA rtSubAddr){} +TMK_DATA frtgetsubaddr_usb(){return -1;} +void frtputw_usb(TMK_DATA rtAddr, TMK_DATA rtData){} +TMK_DATA frtgetw_usb(TMK_DATA rtAddr){return -1;} +void frtputblk_usb(TMK_DATA rtAddr, void *pcBuffer, TMK_DATA cwLength){} +void frtgetblk_usb(TMK_DATA rtAddr, void *pcBuffer, TMK_DATA cwLength){} +void frtsetanswbits_usb(TMK_DATA rtSetControl){} +void frtclranswbits_usb(TMK_DATA rtClrControl){} +TMK_DATA frtgetanswbits_usb(){return -1;} +void frtgetflags_usb(void *pcBuffer, TMK_DATA rtDir, TMK_DATA rtFlagMin, TMK_DATA rtFlagMax){} +void frtputflags_usb(void *pcBuffer, TMK_DATA rtDir, TMK_DATA rtFlagMin, TMK_DATA rtFlagMax){} +void frtsetflag_usb(){} +void frtclrflag_usb(){} +TMK_DATA frtgetflag_usb(TMK_DATA rtDir, TMK_DATA rtSubAddr){return -1;} +void frtputflag_usb(TMK_DATA rtDir, TMK_DATA rtSubAddr, TMK_DATA rtFlag){} +TMK_DATA frtgetstate_usb(){return -1;} +TMK_DATA frtbusy_usb(){return -1;} +void frtlock_usb(TMK_DATA rtDir, TMK_DATA rtSubAddr){} +void frtunlock_usb(){} +TMK_DATA frtgetcmddata_usb(TMK_DATA rtBusCommand){return -1;} +void frtputcmddata_usb(TMK_DATA rtBusCommand, TMK_DATA rtData){} +int fmtreset_usb(){return -1;} +TMK_DATA fmtgetsw_usb(){return -1;} +TMK_DATA frtenable_usb(TMK_DATA rtEnable){return -1;} +int fmrtselected_usb(){return -1;} +TMK_DATA fmrtgetstate_usb(){return -1;} +void fmrtdefbrcsubaddr0_usb(){} +int fmrtreset_usb(){return -1;} +TMK_DATA ftmktimer_usb(TMK_DATA TimerCtrl){return -1;} +DWORD ftmkgettimer_usb(){return -1;} +DWORD ftmkgettimerl_usb(){return -1;} +DWORD fbcgetmsgtime_usb(){return -1;} +DWORD frtgetmsgtime_usb(){return -1;} +TMK_DATA ftmkgethwver_usb(){return -1;} +DWORD ftmkgetevtime_usb(){return -1;} +TMK_DATA ftmkswtimer_usb(TMK_DATA tmkTimerCtrl){return -1;} +DWORD ftmkgetswtimer_usb(){return -1;} +TMK_DATA ftmktimeout_usb(WORD tmkTimeOut){return -1;} +int fmrtdefbrcpage_usb(TMK_DATA mrtBrcPage){return -1;} +TMK_DATA fmrtgetbrcpage_usb(){return 0;} + +DWORD fMonitorHwStart_usb(DWORD dwBufSize, HANDLE hEvent){return -1;} +DWORD fMonitorHwGetMessage_usb(WORD * Data, DWORD dwBufSize, BOOL FillFlag, DWORD * dwMsWritten){return -1;} +DWORD fMonitorHwStop_usb(void){return -1;} + +unsigned int ftmkrawio_usb(unsigned int *buf_out, unsigned int *buf_in){return -1;} +TMK_DATA frtgap_usb(TMK_DATA Gap){return -1;} +int ftmkreadsn_usb(void){return -1;} + +int *ptmkError; + +htmkconfig_usb tmkconfig_usb = ftmkconfig_usb; +htmkdone_usb tmkdone_usb = ftmkdone_usb; +htmkselect_usb tmkselect_usb = ftmkselect_usb; +htmkdefevent_usb tmkdefevent_usb = ftmkdefevent_usb; +hRead_DLL_EvD_usb Read_DLL_EvD_usb = fRead_DLL_EvD_usb; +htmksetcwbits_usb tmksetcwbits_usb = ftmksetcwbits_usb; +htmkclrcwbits_usb tmkclrcwbits_usb = ftmkclrcwbits_usb; +htmkgetcwbits_usb tmkgetcwbits_usb = ftmkgetcwbits_usb; +htmkgetmode_usb tmkgetmode_usb = ftmkgetmode_usb; +htmkdefdac_usb tmkdefdac_usb = ftmkdefdac_usb; +htmkgetdac_usb tmkgetdac_usb = ftmkgetdac_usb; +hbcreset_usb bcreset_usb = fbcreset_usb; +hbcdefirqmode_usb bcdefirqmode_usb = fbcdefirqmode_usb; +hbcgetirqmode_usb bcgetirqmode_usb = fbcgetirqmode_usb; +hbcgetmaxbase_usb bcgetmaxbase_usb = fbcgetmaxbase_usb; +hbcdefbase_usb bcdefbase_usb = fbcdefbase_usb; +hbcgetbase_usb bcgetbase_usb = fbcgetbase_usb; +hbcputw_usb bcputw_usb = fbcputw_usb; +hbcgetw_usb bcgetw_usb = fbcgetw_usb; +hbcgetansw_usb bcgetansw_usb = fbcgetansw_usb; +hbcputblk_usb bcputblk_usb = fbcputblk_usb; +hbcgetblk_usb bcgetblk_usb = fbcgetblk_usb; +hbcdefbus_usb bcdefbus_usb = fbcdefbus_usb; +hbcgetbus_usb bcgetbus_usb = fbcgetbus_usb; +hbcstart_usb bcstart_usb = fbcstart_usb; +hbcstartx_usb bcstartx_usb = fbcstartx_usb; +hbcdeflink_usb bcdeflink_usb = fbcdeflink_usb; +hbcgetlink_usb bcgetlink_usb = fbcgetlink_usb; +hbcstop_usb bcstop_usb = fbcstop_usb; +hbcgetstate_usb bcgetstate_usb = fbcgetstate_usb; +hrtreset_usb rtreset_usb = frtreset_usb; +hrtdefirqmode_usb rtdefirqmode_usb = frtdefirqmode_usb; +hrtgetirqmode_usb rtgetirqmode_usb = frtgetirqmode_usb; +hrtdefmode_usb rtdefmode_usb = frtdefmode_usb; +hrtgetmode_usb rtgetmode_usb = frtgetmode_usb; +hrtgetmaxpage_usb rtgetmaxpage_usb = frtgetmaxpage_usb; +hrtdefpage_usb rtdefpage_usb = frtdefpage_usb; +hrtgetpage_usb rtgetpage_usb = frtgetpage_usb; +hrtdefpagepc_usb rtdefpagepc_usb = frtdefpagepc_usb; +hrtdefpagebus_usb rtdefpagebus_usb = frtdefpagebus_usb; +hrtgetpagepc_usb rtgetpagepc_usb = frtgetpagepc_usb; +hrtgetpagebus_usb rtgetpagebus_usb = frtgetpagebus_usb; +hrtdefaddress_usb rtdefaddress_usb = frtdefaddress_usb; +hrtgetaddress_usb rtgetaddress_usb = frtgetaddress_usb; +hrtdefsubaddr_usb rtdefsubaddr_usb = frtdefsubaddr_usb; +hrtgetsubaddr_usb rtgetsubaddr_usb = frtgetsubaddr_usb; +hrtputw_usb rtputw_usb = frtputw_usb; +hrtgetw_usb rtgetw_usb = frtgetw_usb; +hrtputblk_usb rtputblk_usb = frtputblk_usb; +hrtgetblk_usb rtgetblk_usb = frtgetblk_usb; +hrtsetanswbits_usb rtsetanswbits_usb = frtsetanswbits_usb; +hrtclranswbits_usb rtclranswbits_usb = frtclranswbits_usb; +hrtgetanswbits_usb rtgetanswbits_usb = frtgetanswbits_usb; +hrtgetflags_usb rtgetflags_usb = frtgetflags_usb; +hrtputflags_usb rtputflags_usb = frtputflags_usb; +hrtsetflag_usb rtsetflag_usb = frtsetflag_usb; +hrtclrflag_usb rtclrflag_usb = frtclrflag_usb; +hrtgetflag_usb rtgetflag_usb = frtgetflag_usb; +hrtputflag_usb rtputflag_usb = frtputflag_usb; +hrtgetstate_usb rtgetstate_usb = frtgetstate_usb; +hrtbusy_usb rtbusy_usb = frtbusy_usb; +hrtlock_usb rtlock_usb = frtlock_usb; +hrtunlock_usb rtunlock_usb = frtunlock_usb; +hrtgetcmddata_usb rtgetcmddata_usb = frtgetcmddata_usb; +hrtputcmddata_usb rtputcmddata_usb = frtputcmddata_usb; +hmtreset_usb mtreset_usb = fmtreset_usb; +hmtgetsw_usb mtgetsw_usb = fmtgetsw_usb; +hrtenable_usb rtenable_usb = frtenable_usb; +hmrtselected_usb mrtselected_usb = fmrtselected_usb; +hmrtgetstate_usb mrtgetstate_usb = fmrtgetstate_usb; +hmrtdefbrcsubaddr0_usb mrtdefbrcsubaddr0_usb = fmrtdefbrcsubaddr0_usb; +hmrtreset_usb mrtreset_usb = fmrtreset_usb; +htmktimer_usb tmktimer_usb = ftmktimer_usb; +htmkgettimer_usb tmkgettimer_usb = ftmkgettimer_usb; +htmkgettimerl_usb tmkgettimerl_usb = ftmkgettimerl_usb; +hbcgetmsgtime_usb bcgetmsgtime_usb = fbcgetmsgtime_usb; +hrtgetmsgtime_usb rtgetmsgtime_usb = frtgetmsgtime_usb; +htmkgethwver_usb tmkgethwver_usb = ftmkgethwver_usb; +htmkgetevtime_usb tmkgetevtime_usb = ftmkgetevtime_usb; +htmkswtimer_usb tmkswtimer_usb = ftmkswtimer_usb; +htmkgetswtimer_usb tmkgetswtimer_usb = ftmkgetswtimer_usb; +htmktimeout_usb tmktimeout_usb = ftmktimeout_usb; +hmrtdefbrcpage_usb mrtdefbrcpage_usb = fmrtdefbrcpage_usb; +hmrtgetbrcpage_usb mrtgetbrcpage_usb = fmrtgetbrcpage_usb; + +hMonitorHwStart_usb MonitorHwStart_usb = fMonitorHwStart_usb; +hMonitorHwGetMessage_usb MonitorHwGetMessage_usb = fMonitorHwGetMessage_usb; +hMonitorHwStop_usb MonitorHwStop_usb = fMonitorHwStop_usb; + +htmkrawio_usb tmkrawio_usb = ftmkrawio_usb; +hrtgap_usb rtgap_usb = frtgap_usb; +htmkreadsn_usb tmkreadsn_usb = ftmkreadsn_usb; diff --git a/bcmil.cpp b/bcmil.cpp new file mode 100644 index 0000000..9c16c4b --- /dev/null +++ b/bcmil.cpp @@ -0,0 +1,195 @@ +#include +#include "bcmil.h" +#include "WDMTMKv2.cpp" +//#include + +//TTmkEventData tmkEvD; +HANDLE hBcEvent; +//HANDLE hRtEvent; + +int nTmk; +unsigned long dwGoodStarts = 0, dwBusyStarts = 0, dwErrStarts = 0, dwStatStarts = 0; +unsigned long dwStarts = 0L; +TMK_DATA wSubAddr, wState, wStatus; + +MIL::MIL(int dev_index) //open the driver, configuration, create event +{ + qDebug() << "MIL constructor"; + if (TmkOpen()) + { + qDebug() << "TmkOpen() error"; + closeAllrt(); + //closeAll(); + } + else + { + if ((dev_index > tmkgetmaxn()) || (dev_index < 0)) + { + closeAllrt(); + //closeAll(); + } + else + { + this->m_TmkIndex = dev_index; + + if (tmkconfig(this->m_TmkIndex)) + { + closeAllrt(); + //closeAll(); + } + } + } +} + +/*int MIL::WaitInt(TMK_DATA wCtrlCode) +{ + //Wait for an interrupt + DWORD k; + k = WaitForSingleObject(hBcEvent, 1000); + switch (k) + { + case WAIT_OBJECT_0: + ResetEvent(hBcEvent); + break; + + case WAIT_TIMEOUT: + qDebug() << "Interrupt timeout error\n"; + return 1; + + default: + qDebug() << "k = " << k; + qDebug() << "Interrupt wait error\n"; + return 1; + } + + // Get interrupt data + // We do not need to check tmkEvD.nInt because bcstartx with CX_NOSIG + // guarantees us only single interrupt of single type nInt == 3 + tmkgetevd(&tmkEvD); + + if (tmkEvD.bcx.wResultX & SX_IB_MASK) + { + // We have set bit(s) in Status Word + if (((tmkEvD.bcx.wResultX & SX_ERR_MASK) == SX_NOERR) || ((tmkEvD.bcx.wResultX & SX_ERR_MASK) == SX_TOD)) + { + wStatus = bcgetansw(wCtrlCode); // We have either no errors or Data Time Out (No Data) error + if (wStatus & BUSY_MASK) // We have BUSY bit set + ++dwBusyStarts; + else // We have unknown bit(s) set + ++dwStatStarts; + } + else // We have an error + ++dwErrStarts; + } + else if (tmkEvD.bcx.wResultX & SX_ERR_MASK) // We have an error + ++dwErrStarts; + else // We have a completed message + ++dwGoodStarts; + + ++dwStarts; + return 0; +}*/ + +/*void MIL::closeAll() +{ + qDebug() << "Close All"; + //printf("\nGood: %ld, Busy: %ld, Error: %ld, Status: %ld\n", dwGoodStarts, dwBusyStarts, dwErrStarts, dwStatStarts); + bcreset(); + //Close all opened things + CloseHandle(hBcEvent); + tmkdone(ALL_TMKS); + TmkClose(); +}*/ + +void MIL::closeAllrt() +{ + qDebug() << "Close All"; + //printf("\nGood: %ld, Busy: %ld, Error: %ld, Status: %ld\n", dwGoodStarts, dwBusyStarts, dwErrStarts, dwStatStarts); + rtreset(); + //Close all opened things + CloseHandle(hBcEvent); + tmkdone(ALL_TMKS); + TmkClose(); +} + +MIL::~MIL() +{ + qDebug() << "MIL destructor"; +} + +/*BC_MIL::BC_MIL(int dev_index): MIL(dev_index) +{ + qDebug() << "BC_MIL constructor"; + //Find first configured device + for (nTmk = 0; nTmk <= MAX_TMK_NUMBER; ++nTmk) + if (!tmkselect(nTmk)) + break; + if (nTmk > MAX_TMK_NUMBER) + { + qDebug() << "tmkselect error"; + closeAll(); + } + //Try to reset in BC mode + if (bcreset()) + { + qDebug() << "bcreset error"; + closeAll(); + } +} + +BC_MIL::~BC_MIL() +{ + qDebug() << "BC_MIL destructor"; +}*/ + +RT_MIL::RT_MIL(int dev_index, unsigned short Addr): MIL(dev_index) +{ + qDebug() << "RT_MIL constructor"; + this->m_Addr = Addr; + + //Find first configured device + for (nTmk = 0; nTmk <= MAX_TMK_NUMBER; ++nTmk) + if (!tmkselect(nTmk)) + break; + if (nTmk > MAX_TMK_NUMBER) + { + qDebug() << "tmkselect error"; + closeAllrt(); + } + //Try to reset in RT mode + if (rtreset()) + { + qDebug() << "rtreset error"; + closeAllrt(); + } + //Set RT address, set flag mode, enable data irqs + rtdefaddress(Addr); + rtdefmode(rtgetmode()|RT_FLAG_MODE); + //rtdefmode(rtgetmode()&~RT_FLAG_MODE); + rtdefirqmode(rtgetirqmode()&~RT_DATA_BL); + + for (wSubAddr = 1; wSubAddr <= 30; ++wSubAddr) + { + //Ready to receive, not ready to transmit + rtdefsubaddr(RT_RECEIVE, wSubAddr); + rtclrflag(); + rtdefsubaddr(RT_TRANSMIT, wSubAddr); + rtclrflag(); + } + + hBcEvent = CreateEvent(NULL, TRUE, FALSE, NULL); + if (!hBcEvent) + { + qDebug() << "create event error"; + closeAllrt(); + } + ResetEvent(hBcEvent); + tmkdefevent(hBcEvent, TRUE); +} + +RT_MIL::~RT_MIL() +{ + qDebug() << "RT_MIL destructor"; +} + + diff --git a/bcmil.h b/bcmil.h new file mode 100644 index 0000000..3820239 --- /dev/null +++ b/bcmil.h @@ -0,0 +1,98 @@ +#ifndef BCMIL_H +#define BCMIL_H + +#include + +//******************* +//#include "WDMTMKv2.h" +//#include "windows.h" +//******************* +/*typedef struct +{ + int nInt; + unsigned short wMode; + union + { + struct + { + unsigned short wResult; + unsigned short wAW1; + unsigned short wAW2; + } bc; + struct + { + unsigned short wBase; + unsigned short wResultX; + } bcx; + struct + { + unsigned short wStatus; + unsigned short wCmd; + } rt; + struct + { + unsigned short wBase; + unsigned short wResultX; + } mt; + struct + { + unsigned short wStatus; + } mrt; + struct + { + unsigned short wRequest; +// DWORD dwTimer; + } tmk; + struct + { + unsigned short wData1; + unsigned short wData2; + } raw; + }; +} TTmkEventData1;*/ + +#define TMK_DATA unsigned short +typedef void *HANDLE; + +//class BC_MIL; +//class RT_MIL; +class MIL:public QObject +{ + Q_OBJECT +public: + + MIL(int dev_index); + ~MIL(); + + //int WaitInt(TMK_DATA wCtrlCode); + //void closeAll(); + void closeAllrt(); + //bool GetEvent(TTmkEventData1 *pEv, unsigned short Timeout); + +protected: + + int m_TmkIndex; + //HANDLE m_hEvent; +}; + +/*class BC_MIL:public MIL +{ +public: + + BC_MIL(int dev_index); + ~BC_MIL(void); +}; +*/ +class RT_MIL:public MIL +{ +public: + + RT_MIL(int dev_indexi, unsigned short Addr); + ~RT_MIL(); + +protected: + + unsigned short m_Addr; +}; + +#endif // BCMIL_H diff --git a/cmdwrd.cpp b/cmdwrd.cpp new file mode 100644 index 0000000..07094c2 --- /dev/null +++ b/cmdwrd.cpp @@ -0,0 +1,87 @@ +#include "mainwindow.h" +#include "cmdwrd.h" + +extern unsigned char HexBinFlag; + +CommandWord::CommandWord() +{ + addrRTf = 0; + Kf = 0; + subAddrf = 0; + numDWf = 0; + + cmdCode.insert(dynBC, "Принять упр-е интерфейсом"); + cmdCode.insert(sync1, "Синхронизация"); + cmdCode.insert(transSW, "Передать ОС"); + cmdCode.insert(initST, "Начать самоконтроль ОУ"); + cmdCode.insert(transS, "Блокировать передатчик"); + cmdCode.insert(overrTS, "Разблокировать передатчик"); + cmdCode.insert(inhTFB, "Блок-ть признак неиспр-ти ОУ"); + cmdCode.insert(overrITF, "Разблок-ть признак неиспр-ти ОУ"); + cmdCode.insert(resetRT, "Уст-ть ОУ в исх-е состояние"); + cmdCode.insert(transVW, "Передать вект-ое слово"); + cmdCode.insert(sync2, "Синхронизация (с СД)"); + cmdCode.insert(transLC, "Передать послед-ю команду"); + cmdCode.insert(transBW, "Передать слово ВСК ОУ"); + cmdCode.insert(selectedSW, "Блок-ть i-й передатчик"); + cmdCode.insert(overrSTS, "Разблок-ть i-й передатчик"); + + for(uint8_t i = 0b01001; i < 0b10000; i++) + cmdCode.insert(i, "Резерв"); + + for(uint8_t i = 0b10110; i < 0b11111; i++) + cmdCode.insert(i, "Резерв"); +} + +uint8_t CommandWord::addrRTFind(uint16_t cmdw) +{ + CW.all = cmdw; + return CW.addrRT; +} + +uint8_t CommandWord::KFind(uint16_t cmdw) +{ + CW.all = cmdw; + return CW.K; +} + +uint8_t CommandWord::subAddrFind(uint16_t cmdw) +{ + CW.all = cmdw; + return CW.subAddr; +} + +uint8_t CommandWord::numDWFind(uint16_t cmdw) +{ + CW.all = cmdw; + return CW.numDW; +} + +void CommandWord::description(QString CmdW) +{ + uint16_t cmdw; + bool result; + + if(HexBinFlag) + cmdw = CmdW.toInt(&result, 16); + else + cmdw = CmdW.toInt(&result, 2); + + if(result == false) + QMessageBox::warning(0, "Ошибка", "Недопустимое значение КС"); + else if((HexBinFlag == 0) && (CmdW.length() != 16)) + QMessageBox::warning(0, "Ошибка", "Недопустимое значение КС"); + else if((HexBinFlag == 1) && (CmdW.length() != 4)) + QMessageBox::warning(0, "Ошибка", "Недопустимое значение КС"); + else + { + addrRTf = addrRTFind(cmdw); + Kf = KFind(cmdw); + subAddrf = subAddrFind(cmdw); + numDWf = numDWFind(cmdw); + } +} + +CommandWord::~CommandWord() +{ +} diff --git a/cmdwrd.h b/cmdwrd.h new file mode 100644 index 0000000..05c0df0 --- /dev/null +++ b/cmdwrd.h @@ -0,0 +1,45 @@ +#ifndef CMDWRD_H +#define CMDWRD_H + +#include "declarations.h" + +class CommandWord:public QObject +{ + Q_OBJECT +public: + + typedef union { + uint16_t all; + struct { + unsigned numDW: 5; // DW - data word + unsigned subAddr: 5; + unsigned K: 1; // translate/receive flag + unsigned addrRT: 5; // RT - remote terminal + }; + } CW_t; + + CW_t CW; + + uint8_t addrRTf; + uint8_t Kf; + uint8_t subAddrf; + uint8_t numDWf; + + QHash cmdCode; + + //01001 - 01111 reserved, 10110 - 11111 reserved + enum codeName {dynBC, sync1, transSW, initST, transS, + overrTS, inhTFB, overrITF, resetRT, transVW = 0b10000, + sync2, transLC, transBW, selectedSW, overrSTS}; + + void description(QString CmdW); + uint8_t addrRTFind(uint16_t cmdw); + uint8_t KFind(uint16_t cmdw); + uint8_t subAddrFind(uint16_t cmdw); + uint8_t numDWFind(uint16_t cmdw); + + CommandWord(); + ~CommandWord(); +}; + +#endif // CMDWRD_H diff --git a/declarations.h b/declarations.h new file mode 100644 index 0000000..68fe40a --- /dev/null +++ b/declarations.h @@ -0,0 +1,22 @@ +#ifndef DECLARATIONS_H +#define DECLARATIONS_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#endif // DECLARATIONS_H diff --git a/main.cpp b/main.cpp new file mode 100644 index 0000000..5030ce3 --- /dev/null +++ b/main.cpp @@ -0,0 +1,14 @@ +#include "mainwindow.h" +//#include "testinfo.h" + +#include + +int main(int argc, char *argv[]) +{ + QApplication a(argc, argv); + MainWindow w; + w.show(); + + //QTest::qExec(new testInfo, argc, argv); + return a.exec(); +} diff --git a/mainwindow.cpp b/mainwindow.cpp new file mode 100644 index 0000000..40c9ddc --- /dev/null +++ b/mainwindow.cpp @@ -0,0 +1,325 @@ +#include "mainwindow.h" +//#include "windows.h" +//#include "WDMTMKv2.cpp" +#include "bcmil.cpp" + +TTmkEventData tmkEvD; +extern HANDLE hBcEvent; + +//#define RT_ADDR 10 + +//const int fInstMode = 1; + +unsigned short awBuf[32]; + +TMK_DATA wBase, wMaxBase, wLen; +extern TMK_DATA wSubAddr, wState; + +unsigned char HexBinFlag = 1; //1 - hex, 0 - bin + +MainWindow::MainWindow() +{ + init_mainwindowobj(); + init_table(); + init_connections(); +} + +void MainWindow::init_mainwindowobj() +{ + qDebug() << "Startyem"; + + Window_1 = new QWidget; + Window_2 = new QWidget; + + HexBinButton = new QPushButton("Hex/Bin"); + HexBinLabel = new QLabel("Hex"); + + CmdWordLabel = new QLabel("Enter the command word:"); + CmdWordLineEdit = new QLineEdit; + EnterCmdWordButton = new QPushButton("Start"); + DataTable = new QTableWidget; + + QGridLayout *layout_g = new QGridLayout(Window_2); + layout_g->addWidget(HexBinButton, 0, 1); + layout_g->addWidget(HexBinLabel, 0, 0); + layout_g->addWidget(CmdWordLabel, 1, 0); // Row 0, Column 0 + layout_g->addWidget(CmdWordLineEdit, 2, 0); + layout_g->addWidget(EnterCmdWordButton, 3, 0); + + Window_2->setLayout(layout_g); + setCentralWidget(Window_2); + + QVBoxLayout *layout = new QVBoxLayout(Window_1); + layout->addWidget(Window_2); + layout->addWidget(DataTable); + + Window_1->setLayout(layout); + setCentralWidget(Window_1); +} + +void MainWindow::init_connections() +{ + /*connect(EnterCmdWordButton, + SIGNAL(clicked()), + this, + SLOT(getlineedit()));*/ + /*connect(EnterCmdWordButton, + SIGNAL(clicked()), + this, + SLOT(sendcmdwrd()));*/ + connect(EnterCmdWordButton, + SIGNAL(clicked()), + this, + SLOT(rthandler())); + connect(HexBinButton, + SIGNAL(clicked()), + this, + SLOT(HexBinChange())); +} + +QString intToBinaryString(int number) +{ + return QString::number(number,2); +} + +QString intToDecString(int number) +{ + return QString::number(number,10); +} + +/*void MainWindow::getlineedit() +{ + qDebug() << "Entered the button command word"; + QString CmdW = CmdWordLineEdit->text(); + qDebug() << CmdW; + + QScopedPointer NewCmdWord(new CommandWord()); + NewCmdWord->description(CmdW); + + set_item(DataTable, 0, 0, "Адрес устройства", false); + set_item(DataTable, 0, 1, intToBinaryString(NewCmdWord->addrRTf), false); + set_item(DataTable, 0, 2, intToDecString(NewCmdWord->addrRTf), false); + + if(NewCmdWord->Kf) + { + set_item(DataTable, 1, 0, "Передача", false); + set_item(DataTable, 1, 1, intToBinaryString(NewCmdWord->Kf), false); + set_item(DataTable, 1, 2, intToDecString(NewCmdWord->Kf), false); + } + else + { + set_item(DataTable, 1, 0, "Прием", false); + set_item(DataTable, 1, 1, intToBinaryString(NewCmdWord->Kf), false); + set_item(DataTable, 1, 2, intToDecString(NewCmdWord->Kf), false); + } + + if((NewCmdWord->subAddrf == 0) || (NewCmdWord->subAddrf == 31)) + { + set_item(DataTable, 2, 0, "Режим управления", false); + set_item(DataTable, 2, 1, intToBinaryString(NewCmdWord->subAddrf), false); + set_item(DataTable, 2, 2, intToDecString(NewCmdWord->subAddrf), false); + } + else + { + set_item(DataTable, 2, 0, "Подадрес", false); + set_item(DataTable, 2, 1, intToBinaryString(NewCmdWord->subAddrf), false); + set_item(DataTable, 2, 2, intToDecString(NewCmdWord->subAddrf), false); + } + + if((NewCmdWord->subAddrf == 0) || (NewCmdWord->subAddrf == 31)) + { + set_item(DataTable, 3, 0, NewCmdWord->cmdCode.value(NewCmdWord->numDWf), false); + set_item(DataTable, 3, 1, intToBinaryString(NewCmdWord->numDWf), false); + set_item(DataTable, 3, 2, intToDecString(NewCmdWord->numDWf), false); + } + else + { + if(NewCmdWord->numDWf == 0) + { + set_item(DataTable, 3, 0, "Число СД", false); + set_item(DataTable, 3, 1, intToBinaryString(32), false); + set_item(DataTable, 3, 2, intToDecString(32), false); + } + else + { + set_item(DataTable, 3, 0, "Число СД", false); + set_item(DataTable, 3, 1, intToBinaryString(NewCmdWord->numDWf), false); + set_item(DataTable, 3, 2, intToDecString(NewCmdWord->numDWf), false); + } + } +}*/ + +void MainWindow::HexBinChange() +{ + switch(HexBinFlag) + { + case 0: //было bin + HexBinLabel->setText("Hex"); + HexBinFlag = 1; + break; + + case 1: //было hex + HexBinLabel->setText("Bin"); + HexBinFlag = 0; + break; + } +} + +void MainWindow::init_table() +{ + int ColCount = 3; + int RowCount = 4; + QStringList header; + header << "Биты КС" << "Бинарное представление" << "Десятичное представление"; + + DataTable->setColumnCount(ColCount); + DataTable->setRowCount(RowCount); + DataTable->setHorizontalHeaderLabels(header); + DataTable->verticalHeader()->setVisible(true); + + DataTable->setColumnWidth(0,200); + DataTable->setColumnWidth(1,160); + DataTable->setColumnWidth(2,160); + + for(int i = 0; i < RowCount; i++) + { + DataTable->setRowHeight(i,20); + for(int j = 0; j < ColCount; j++) + set_item(DataTable, i, j, "%", false); + } +} + + + +void MainWindow::set_item(QTableWidget *pTable, int indRow, + int indCol, QString data, bool editFlag) +{ + QColor color; + color.black(); + QTableWidgetItem *itm = + new QTableWidgetItem(data); + pTable->setItem(indRow,indCol,itm); + + if (editFlag) {} + else + { + pTable->item(indRow, indCol)->setFlags(Qt::ItemIsSelectable| + Qt::ItemIsDragEnabled| + Qt::ItemIsUserCheckable); + } + pTable->item(indRow, indCol)->setTextColor(color); +} + +/*void MainWindow::sendcmdwrd() +{ + qDebug() << "send1"; + QScopedPointer NewBC(new BC_MIL(0)); + qDebug() << "send2"; + wBase = 0; + wMaxBase = bcgetmaxbase(); + srand(1); + + //Select base + if (wBase > wMaxBase) + wBase = 0; + bcdefbase(wBase); + qDebug() << "send3"; + + //Prepare data to RT + //wSubAddr = rand() & 0x1F; + wSubAddr = 0x1F;; + //if (fInstMode) + // wSubAddr |= 0x10; + //wLen = rand() & 0x1F; + wLen = 0x1; + if (wLen == 0) + wLen = 32; + for (int i = 0; i < wLen; ++i) + awBuf[i] = (wSubAddr<<8) | i; + qDebug() << "send4"; + + //Try to send data to RT until it answers with Clear Status + bcputw(0, CW(RT_ADDR, RT_RECEIVE, wSubAddr, wLen)); + bcputblk(1, awBuf, wLen); + do + { + //bcstartx(wBase, DATA_BC_RT | CX_STOP | CX_BUS_A | CX_NOSIG); + bcstartx(wBase, DATA_BC_RT | CX_STOP | CX_BUS_B | CX_NOSIG); + if (NewBC->WaitInt(DATA_BC_RT)) + NewBC->closeAll(); + } while ((tmkEvD.bcx.wResultX & (SX_ERR_MASK | SX_IB_MASK)) != 0); + qDebug() << "send5"; + NewBC->closeAll(); +}*/ + +void MainWindow::rthandler() +{ + qDebug() << "rt1"; + QScopedPointer NewRT(new RT_MIL(0, 1)); + qDebug() << "rt2"; + + int i = 0; + while (i != 1000) + { + i++; + if (tmkselect(0)) + { + qDebug() << "tmk select error"; + NewRT->closeAllrt(); + } + //Wait for an interrupt + switch (WaitForSingleObject(hBcEvent, 1000)) + { + case WAIT_OBJECT_0: + qDebug() << "Interrupt"; + //New message has arrived + ResetEvent(hBcEvent); + do + { + //Get interrupt data + tmkgetevd(&tmkEvD); + //Check interrupt type + if (tmkEvD.nInt == 3) + { + wSubAddr = (tmkEvD.rt.wStatus >> 5) &0x1F; + wLen = tmkEvD.rt.wStatus & 0x1F; + if (wLen == 0) + wLen = 32; + if ((tmkEvD.rt.wStatus & RT_DIR_MASK) == RT_RECEIVE) + { + //If we received some data then copy the data from Rx subaddres to + //Tx subaddress and process flags + if ((rtgetflag(RT_RECEIVE, wSubAddr) & RT_FLAG_MASK) == 0) + { + //qDebug() << "Flag read error"; + NewRT->closeAllrt(); + } + rtdefsubaddr(RT_RECEIVE, wSubAddr); + rtgetblk(0, awBuf, wLen); + rtclrflag(); + rtdefsubaddr(RT_TRANSMIT, wSubAddr); + rtputblk(0, awBuf, wLen); + rtsetflag(); + } + } + } while (tmkEvD.nInt != 0); //Loop while we have not processed all interrupts + + break; + + case WAIT_TIMEOUT: + // No new messages + qDebug() << "No new messages"; + break; + + default: + qDebug() << "Interrupt wait error"; + NewRT->closeAllrt(); + break; + } + } + NewRT->closeAllrt(); +} + +MainWindow::~MainWindow() +{ +} diff --git a/mainwindow.h b/mainwindow.h new file mode 100644 index 0000000..54c3a65 --- /dev/null +++ b/mainwindow.h @@ -0,0 +1,55 @@ +#ifndef MAINWINDOW_H +#define MAINWINDOW_H + +#include "declarations.h" + +class MainWindow:public QMainWindow +{ + Q_OBJECT +public: + void init_mainwindowobj(); //the function of this class + void init_connections(); + explicit MainWindow(); //constructor + ~MainWindow(); //destructor + +private: + void init_table(); + void set_item(QTableWidget *pTable, int indRow, + int indCol, QString data, bool editFlag); + +public slots: + //void getlineedit(); + //void sendcmdwrd(); + void rthandler(); + void HexBinChange(); + +private: + QWidget *Window_1 = new QWidget; + QWidget *Window_2 = new QWidget; + + QLabel *HexBinLabel; + QPushButton *HexBinButton; + + QLabel *CmdWordLabel; + QLineEdit *CmdWordLineEdit; + QPushButton *EnterCmdWordButton; + QTableWidget *DataTable; + +protected: + + void keyPressEvent(QKeyEvent *event) override + { + if (loopActive) + { + loopActive = false; + qDebug() << "Key pressed! Stopping loop."; + } + QWidget::keyPressEvent(event); + } + +public: + + bool loopActive = true; +}; + +#endif // MAINWINDOW_H diff --git a/testinfo.cpp b/testinfo.cpp new file mode 100644 index 0000000..339e08f --- /dev/null +++ b/testinfo.cpp @@ -0,0 +1,310 @@ +/*#include +#include "testinfo.h" +#include +#include "declarations.h" +#include + +HANDLE hEvent; +TTmkEventData tmkEvD; + +void testInfo::init() +{ + if (isFailed) + { + qDebug() << "Skip"; + QSKIP(""); + } +} + +void testInfo::cleanup() +{ + bool a = QTest::currentTestFailed(); + if (a) + isFailed = a; +} + +void testInfo::cleanupTestCase() +{ + qDebug() << "TmkClose()"; + TmkClose(); + if (hEvent) + CloseHandle(hEvent); +} + +void testInfo::testcreateevent() +{ + hEvent = CreateEvent(NULL, TRUE, FALSE, NULL); + QVERIFY(hEvent); +} + +void testInfo::testTmkOpen() +{ + DWORD a; + + a = TmkOpen(); + QCOMPARE(a, DWORD(0)); +} + +void testInfo::testtmkgetmaxn() +{ + QCOMPARE(tmkgetmaxn(), (int)(0)); +} + +void testInfo::testmrtgetmaxn() +{ + QCOMPARE(mrtgetmaxn(), (int)(0)); +} + +void testInfo::testtmkconfig() +{ + int hTmk = 0; + + QCOMPARE(tmkconfig(hTmk), (int)(0)); +} + +void testInfo::testtmkselect() +{ + int hTmk = 0; + + QCOMPARE(tmkselect(hTmk), (int)(0)); +} + +void testInfo::testtmkgetinfo() +{ + TTmkConfigData tmkCfg; + int hTmk = 0; + + tmkgetinfo(&tmkCfg); + QCOMPARE(hTmk, (int)(0)); //Device Number + QCOMPARE(tmkCfg.nType, (short)(9)); //Device Type + QCOMPARE(tmkCfg.szName, "TA1USB"); //Device Name + QCOMPARE(tmkCfg.wPorts1, (unsigned short)(0)); //Device I/O Ports + + if (tmkCfg.wPorts2 == (unsigned short)(0xFFFF)) //Device I/O Ports + ; + else + QCOMPARE(tmkCfg.wPorts2, (unsigned short)(0)); + + if (tmkCfg.wIrq2 == (unsigned short)(0xFF)) + QCOMPARE(tmkCfg.wIrq1, (unsigned short)(0)); //Device Interrupt + else + { + QCOMPARE(tmkCfg.wIrq1, (unsigned short)(0)); //Device Interrupts + QCOMPARE(tmkCfg.wIrq2, (unsigned short)(0)); + } + + QCOMPARE(tmkCfg.wIODelay, (unsigned short)(0)); //Device I/O Delay +} + +void testInfo::testtmkgethwver() +{ + QCOMPARE(tmkgethwver(), (unsigned short)(11)); +} + +void testInfo::testbcreset() +{ + QCOMPARE(bcreset(), (int)(0)); +} + +void testInfo::testbcgetmaxbase() +{ + QCOMPARE(bcgetmaxbase(), (unsigned short)(1023)); +} + +void testInfo::testbcputgetw() +{ + int fError; + unsigned short wBase, wAddr; + unsigned short wMaxBase = bcgetmaxbase(); + + for (wBase = 0; wBase <= wMaxBase; ++wBase) + { + bcdefbase(wBase); + for (wAddr = 0; wAddr <= 63; ++wAddr) + { + bcputw(wAddr, wAddr|(wBase<<6)); + } + } + + fError = 0; + for (wBase = 0; wBase <= wMaxBase; ++wBase) + { + bcdefbase(wBase); + for (wAddr = 0; wAddr <= 63; ++wAddr) + { + if (bcgetw(wAddr) != (unsigned short)(wAddr|(wBase<<6))) + fError = 1; + } + } + + QCOMPARE(fError, (int)(0)); +} + +void testInfo::testbcputgetblk() +{ + int fError; + unsigned short awBuf[64]; + unsigned short wBase, wAddr; + unsigned short wMaxBase = bcgetmaxbase(); + + for (wBase = 0; wBase <= wMaxBase; ++wBase) + { + bcdefbase(wBase); + for (wAddr = 0; wAddr <= 63; ++wAddr) + { + awBuf[63-wAddr] = wBase+(wAddr<<8); + } + bcputblk(0, awBuf, 64); + } + + fError = 0; + for (wBase = 0; wBase <= wMaxBase; ++wBase) + { + bcdefbase(wBase); + bcgetblk(0, awBuf, 64); + for (wAddr = 0; wAddr <= 63; ++wAddr) + { + if (awBuf[63-wAddr] != (wBase+(wAddr<<8))) + fError = 1; + } + } + + QCOMPARE(fError, (int)(0)); +} + +void testInfo::testrtreset() +{ + QCOMPARE(rtreset(), (int)(0)); +} + +void testInfo::testrtgetmaxpage() +{ + QCOMPARE(rtgetmaxpage(), (unsigned short)(0)); +} + +void testInfo::testrtputgetw() +{ + int fError; + unsigned short wPage, wAddr, wSubAddr; + unsigned short wMaxPage = rtgetmaxpage(); + + for (wPage = 0; wPage <= wMaxPage; ++wPage) + { + rtdefpage(wPage); + for (wSubAddr = 0; wSubAddr <= 0x1F; ++wSubAddr) + { + rtdefsubaddr(RT_RECEIVE, wSubAddr); + for (wAddr = 0; wAddr <= 31; ++wAddr) + rtputw(wAddr, wAddr|(wSubAddr<<8)|(wPage<<13)); + rtdefsubaddr(RT_TRANSMIT, wSubAddr); + for (wAddr = 0; wAddr <= 31; ++wAddr) + rtputw(wAddr, (wAddr+32)|(wSubAddr<<8)|(wPage<<13)); + } + } + + fError = 0; + for (wPage = 0; wPage <= wMaxPage; ++wPage) + { + rtdefpage(wPage); + for (wSubAddr = 0; wSubAddr <= 0x1F; ++wSubAddr) + { + rtdefsubaddr(RT_RECEIVE, wSubAddr); + for (wAddr = 0; wAddr <= 31; ++wAddr) + { + if (rtgetw(wAddr) != (wAddr|(wSubAddr<<8)|(wPage<<13))) + fError = 1; + } + rtdefsubaddr(RT_TRANSMIT, wSubAddr); + for (wAddr = 0; wAddr <= 31; ++wAddr) + { + if (rtgetw(wAddr) != ((wAddr+32)|(wSubAddr<<8)|(wPage<<13))) + fError = 1; + } + } + } + + QCOMPARE(fError, (int)(0)); +} + +void testInfo::testrtputgetblk() +{ + int fError; + unsigned short awBuf[64]; + unsigned short wPage, wAddr, wSubAddr; + unsigned short wMaxPage = rtgetmaxpage(); + + for (wPage = 0; wPage <= wMaxPage; ++wPage) + { + rtdefpage(wPage); + for (wSubAddr = 0; wSubAddr <= 0x1F; ++wSubAddr) + { + rtdefsubaddr(RT_RECEIVE, wSubAddr); + for (wAddr = 0; wAddr <= 31; ++wAddr) + awBuf[31-wAddr] = wSubAddr|(wAddr<<8)|(wPage<<13); + rtputblk(0, awBuf, 32); + rtdefsubaddr(RT_TRANSMIT, wSubAddr); + for (wAddr = 0; wAddr <= 31; ++wAddr) + awBuf[31-wAddr] = (wSubAddr+32)|(wAddr<<8)|(wPage<<13); + rtputblk(0, awBuf, 32); + } + } + + fError = 0; + for (wPage = 0; wPage <= wMaxPage; ++wPage) + { + rtdefpage(wPage); + for (wSubAddr = 0; wSubAddr <= 0x1F; ++wSubAddr) + { + rtdefsubaddr(RT_RECEIVE, wSubAddr); + rtgetblk(0, awBuf, 32); + for (wAddr = 0; wAddr <= 31; ++wAddr) + { + if (awBuf[31-wAddr] != (wSubAddr|(wAddr<<8)|(wPage<<13))) + fError = 1; + } + rtdefsubaddr(RT_TRANSMIT, wSubAddr); + rtgetblk(0, awBuf, 32); + for (wAddr = 0; wAddr <= 31; ++wAddr) + { + if (awBuf[31-wAddr] != ((wSubAddr+32)|(wAddr<<8)|(wPage<<13))) + fError = 1; + } + } + } + + QCOMPARE(fError, (int)(0)); +} + +void testInfo::testgetInt() +{ + bcreset(); + tmkdefevent(hEvent, TRUE); + tmkgetevd(&tmkEvD); + QCOMPARE(tmkEvD.nInt, (int)(0)); + bcdefbase(0); + bcputw(0, 0xFFE1); + bcstart(0, CTRL_C_BRCST); + + switch (WaitForSingleObject(hEvent, 1000)) + { + case WAIT_OBJECT_0: + ResetEvent(hEvent); + qDebug() << "We got interrupt!"; + break; + + case WAIT_TIMEOUT: + qDebug() << "We didn't get interrupt!"; + break; + + default: + qDebug() << "Somebody abandon our interrupt waiting!"; + break; + } + + tmkgetevd(&tmkEvD); + QCOMPARE(tmkEvD.nInt, (int)(1)); + + tmkdefevent(0,TRUE); +} +*/ + diff --git a/testinfo.h b/testinfo.h new file mode 100644 index 0000000..93a9fb7 --- /dev/null +++ b/testinfo.h @@ -0,0 +1,49 @@ +/*#ifndef TESTINFO_H +#define TESTINFO_H + +#include +#include + +class testInfo:public QObject +{ + Q_OBJECT + +private slots: + + void testcreateevent(); + + void testTmkOpen(); + void testtmkgetmaxn(); + void testmrtgetmaxn(); + void testtmkconfig(); + void testtmkselect(); + void testtmkgetinfo(); + void testtmkgethwver(); + + //Now we'll test onboard RAM in Bus Controller mode + void testbcreset(); + void testbcgetmaxbase(); + void testbcputgetw(); + void testbcputgetblk(); + + //Now we'll test onboard RAM in Remote Terminal mode + void testrtreset(); + void testrtgetmaxpage(); + void testrtputgetw(); + void testrtputgetblk(); + + + //Now we'll test interrupt in Bus Controller mode + void testgetInt(); + + void init(); + void cleanup(); + void cleanupTestCase(); + +protected: + + bool isFailed = false; +}; + +#endif // TESTINFO_H +*/