开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 并口编程 > 查看源码
ParallelPort.cpp
资源名称：parallelportexam.rar.zip　[点击查看]
上传用户：angelica
上传日期：2010-03-17
资源大小：17k
文件大小：32k
源码类别：

并口编程

开发平台：

Visual C++

ParallelPort.cpp：源码内容
  1. /*
  2. Module : PARALLEL.CPP
  3. Purpose: Implementation for an MFC class to encapsulate parallel ports
  4. Created: PJN / 28-12-1999
  5. History: PJN / 06-03-2000 Code now throws an exception if no Win32 parallel ports are available
  6.          PJN / 04-04-2000 Code handles the case where it is run on NT / Windows 2000 by throwing
  7.                           an exception                 
  8.          PJN / 19-07-2000 1. Now works on NT / Windows 2000 thanks to DriverLINX Port I/O Driver
  9.                           2. Made all typedefs and enums local to the appropiate class rather
  10.                           than polluting the global namespace
  11.          PJN / 12-04-2003 1. Updated copyright details. 
  12.                           2. Updated documentation to refer to new DriverLinx web site.
  13.                           3. Code now issues compile time message if conio or afxpriv are not in 
  14.                           your PCH.
  15.          PJN / 11-06-2003 1. Reviewed all places where exceptions are throw and the details which
  16.                           are logged in TRACE statements.
  19. Copyright (c) 1999 - 2003 by PJ Naughter.  (Web: www.naughter.com, Email: pjna@naughter.com)
  21. All rights reserved.
  23. Copyright / Usage Details:
  25. You are allowed to include the source code in any product (commercial, shareware, freeware or otherwise) 
  26. when your product is released in binary form. You are allowed to modify the source code in any way you want 
  27. except you cannot modify the copyright details at the top of each module. If you want to distribute source 
  28. code with your application, then you are only allowed to distribute versions released by the author. This is 
  29. to maintain a single distribution point for the source code. 
  31. */
  33. /////////////////////////////////  Includes  //////////////////////////////////
  34. #include "stdafx.h"
  35. #include "ParallelPort.h"
  36. #ifndef _INC_CONIO
  37. #pragma message("To avoid this message, please put conio.h in your PCH (normally stdafx.h)")
  38. #include <conio.h>
  39. #endif
  40. #ifndef __AFXPRIV_H__
  41. #pragma message("To avoid this message, please put afxpriv.h in your PCH (normally stdafx.h)")
  42. #include <afxpriv.h>
  43. #endif
  48. ///////////////////////////////// Defines / Statics ///////////////////////////
  50. #ifdef _DEBUG
  51. #define new DEBUG_NEW
  52. #undef THIS_FILE
  53. static char THIS_FILE[] = __FILE__;
  54. #endif
  56. int CParallelPort::sm_nRefCount = 0;
  57. BOOL CParallelPort::sm_bRunningOnNT = FALSE;
  58. HINSTANCE CParallelPort::sm_hDLINX = NULL;
  59. CParallelPort::LPDLPORTREADPORTUCHAR CParallelPort::sm_lpfnDlPortReadUchar = NULL;
  60. CParallelPort::LPDLPORTWRITEPORTUCHAR CParallelPort::sm_lpfnDlPortWriteUchar = NULL;
  61. CArray<CParallelPortSettings, CParallelPortSettings&> CParallelPort::sm_Ports;
  66. //////////////////////////////// Implementation ///////////////////////////////
  69. ////////// Exception handling code
  71. void AfxThrowParallelException(DWORD dwError /* = 0 */)
  72. {
  73. if (dwError == 0)
  74. dwError = ::GetLastError();
  76. CParallelException* pException = new CParallelException(dwError);
  78. TRACE(_T("Warning: throwing CParallelException for error %dn"), dwError);
  79. THROW(pException);
  80. }
  82. BOOL CParallelException::GetErrorMessage(LPTSTR pstrError, UINT nMaxError, PUINT pnHelpContext)
  83. {
  84. ASSERT(pstrError != NULL && AfxIsValidString(pstrError, nMaxError));
  86. if (pnHelpContext != NULL)
  87. *pnHelpContext = 0;
  89. LPTSTR lpBuffer;
  90. BOOL bRet = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
  91.                       NULL,  m_dwError, MAKELANGID(LANG_NEUTRAL, SUBLANG_SYS_DEFAULT),
  92.                       (LPTSTR) &lpBuffer, 0, NULL);
  94. if (bRet == FALSE)
  95. *pstrError = '';
  96. else
  97. {
  98. lstrcpyn(pstrError, lpBuffer, nMaxError);
  99. bRet = TRUE;
  101. LocalFree(lpBuffer);
  102. }
  104. return bRet;
  105. }
  107. CString CParallelException::GetErrorMessage()
  108. {
  109.   CString rVal;
  110.   LPTSTR pstrError = rVal.GetBuffer(4096);
  111.   GetErrorMessage(pstrError, 4096, NULL);
  112.   rVal.ReleaseBuffer();
  113.   return rVal;
  114. }
  116. CParallelException::CParallelException(DWORD dwError)
  117. {
  118. m_dwError = dwError;
  119. }
  121. CParallelException::~CParallelException()
  122. {
  123. }
  125. IMPLEMENT_DYNAMIC(CParallelException, CException)
  127. #ifdef _DEBUG
  128. void CParallelException::Dump(CDumpContext& dc) const
  129. {
  130. CObject::Dump(dc);
  132. dc << "m_dwError = " << m_dwError;
  133. }
  134. #endif
  138. ////////// Settings class
  140. CParallelPortSettings::CParallelPortSettings()
  141. {
  142.   m_nBaseAddress = 0;
  143.   m_Type         = ParallelTypeUndefined;
  144.   m_ECPMode      = ECPModeUndefined;
  145. }
  147. CParallelPortSettings::CParallelPortSettings(const CParallelPortSettings& state)
  148. {
  149.   *this = state;
  150. }
  152. CParallelPortSettings& CParallelPortSettings::operator=(const CParallelPortSettings& state)
  153. {
  154.   m_nBaseAddress = state.m_nBaseAddress;
  155.   m_Type         = state.m_Type;   
  156.   m_ECPMode      = state.m_ECPMode;
  158.   return *this;
  159. }
  163. ////////// The actual parallel port class
  165. CParallelPort::CParallelPort()
  166. {
  167.   m_hPort = INVALID_HANDLE_VALUE;
  168.   m_nPortIndex = -1;
  169.   m_nBaseAddress = 0;
  170.   m_dwTimeout = 1000;  //Default timeout is 1 second
  172.   //Test for presence of parallel ports at the standard addresses of 0x3BC, 0x378 and 0x278
  173.   if (sm_nRefCount == 0)
  174.   {
  175.     ++sm_nRefCount;
  177.     //Initialize the DriverLINX driver if on NT / Windows 2000
  178.     sm_bRunningOnNT = RunningOnNT();
  179.     if (sm_bRunningOnNT)
  180.     {
  181.       if (!InitializeDriverLINX())
  182.       {
  183.         TRACE(_T("CParallelPort::CParallelPort, Running on Windows NT, Windows 2000, Windows XP or Windows 2003 and the DriverLINX PORTIO driver is not installedn"));
  184.         AfxThrowParallelException(ERROR_CALL_NOT_IMPLEMENTED);
  185.       }
  186.     }
  188.     //Open LPT1 - LPT3 as a precaution against other processes trying to write 
  189.     //to the port while we are detecting them
  190.     HANDLE hPort1 = CreateFile(_T("\\.\LPT1"), GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
  191.     HANDLE hPort2 = CreateFile(_T("\\.\LPT2"), GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
  192.     HANDLE hPort3 = CreateFile(_T("\\.\LPT3"), GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
  194.     //Must have at least one port available in Win32 to continue to attempt
  195.     //detection of the ports
  196.     int nWin32Ports = 0;
  197.     if (hPort1 != INVALID_HANDLE_VALUE)
  198.       ++nWin32Ports;
  199.     if (hPort2 != INVALID_HANDLE_VALUE)
  200.       ++nWin32Ports;
  201.     if (hPort3 != INVALID_HANDLE_VALUE)
  202.       ++nWin32Ports;
  203.     if (nWin32Ports == 0)
  204.     {
  205.       TRACE(_T("CParallelPort::CParallelPort, No parallel ports are available to Win32 SDKn"));
  206.       AfxThrowParallelException(ERROR_DEV_NOT_EXIST);
  207.     }
  209.     //Try to detect the details of the 3 standard ports
  210.     CParallelPortSettings settings;
  211.     if (GetPort(0x3BC, settings))
  212.       sm_Ports.Add(settings);
  214.     if (sm_Ports.GetSize() < nWin32Ports) 
  215.       if (GetPort(0x378, settings))
  216.         sm_Ports.Add(settings);
  218.     if (sm_Ports.GetSize() < nWin32Ports) 
  219.       if (GetPort(0x278, settings))
  220.         sm_Ports.Add(settings);
  222.     if (sm_Ports.GetSize() == 0)
  223.       TRACE(_T("CParallelPort::CParallelPort, Could not detect any parallel ports on this machinen"));
  225.     //Don't forget to close the 3 SDK handles we had open
  226.     CloseHandle(hPort3);
  227.     CloseHandle(hPort2);
  228.     CloseHandle(hPort1);
  229.   }
  230. }
  232. CParallelPort::~CParallelPort()
  233. {
  234.   //decrement the reference count and 
  235.   //free the DriverLINX pointers if necessary
  236.   --sm_nRefCount;
  237.   if (sm_nRefCount == 0)
  238.     DeInitializeDriverLINX();
  240.   Close();
  241. }
  243. IMPLEMENT_DYNAMIC(CParallelPort, CObject)
  245. #ifdef _DEBUG
  246. void CParallelPort::Dump(CDumpContext& dc) const
  247. {
  248. CObject::Dump(dc);
  250. dc << _T("m_hPort = ") << m_hPort << _T("n");
  251. }
  252. #endif
  254. void CParallelPort::Open(int nPort)
  255. {
  256.   //Call Close just in case we already have the port open
  257.   Close();
  259.   m_nPortIndex = nPort - 1;
  260.   if (m_nPortIndex < sm_Ports.GetSize())
  261.   {
  262.     //Cache the base address of the port for performance reasons
  263.     m_nBaseAddress = sm_Ports.ElementAt(m_nPortIndex).m_nBaseAddress;
  265.     //Call CreateFile to open up the parallel port. This prevents other apps 
  266.     //causing problems when we do the Port IO directly.
  267.     CString sPort;
  268.     sPort.Format(_T("\\.\LPT%d"), nPort);
  269.     m_hPort = CreateFile(sPort, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
  270.     if (m_hPort == INVALID_HANDLE_VALUE)
  271.     {
  272.       DWORD dwLastError = GetLastError();
  273.       TRACE(_T("CParallelPort::Open, Failed to open parallel port, LPT%d, Error:%dn"), nPort, dwLastError);
  274.       Close();
  275.       AfxThrowParallelException(dwLastError);
  276.     }
  277.   }
  278.   else
  279.   {
  280.     TRACE(_T("CParallelPort::Open, Could not find the parallel port, LPT%dn"), nPort);
  281.     Close();
  282.     AfxThrowParallelException(ERROR_FILE_NOT_FOUND);
  283.   }
  284. }
  286. BOOL CParallelPort::IsOpen() const
  287. {
  288.   return (m_hPort != INVALID_HANDLE_VALUE);
  289. }
  291. void CParallelPort::Close()
  292. {
  293.   if (IsOpen())
  294.   {
  295.     BOOL bSuccess = CloseHandle(m_hPort);
  296.     m_hPort = INVALID_HANDLE_VALUE;
  297.     m_nPortIndex = -1;
  298.     m_nBaseAddress = 0;
  299.     if (!bSuccess)
  300.       TRACE(_T("CParallelPort::Close, Failed to close the parallel port, GetLastError:%dn"), GetLastError());
  301.   }
  302. }
  304. void CParallelPort::SetECPMode(CParallelPortSettings::ECPPortMode mode)
  305. {
  306.   ASSERT(IsOpen()); //Port must be open 
  307.   CParallelPortSettings& settings = sm_Ports.ElementAt(m_nPortIndex);
  308.   ASSERT(settings.m_Type == CParallelPortSettings::ParallelTypeECP); //Must be an ECP port
  309.   ASSERT(mode != CParallelPortSettings::ECPModeUndefined);
  311.   unsigned short nEcrAddress = (unsigned short)(m_nBaseAddress + 0x402);
  313.   //Read the ECR & clear bits 5, 6 & 7
  314.   int nEcrData = _inp(nEcrAddress) & 0x1F;
  315.   
  316.   //Write the selected value to bits 5, 6 & 7
  317.   switch (mode)
  318.   {
  319.     case CParallelPortSettings::ECPModeSPP:            nEcrData |= (0 << 5); break;
  320.     case CParallelPortSettings::ECPModePS2:            nEcrData |= (1 << 5); break;
  321.     case CParallelPortSettings::ECPModeFastCentronics: nEcrData |= (2 << 5); break;
  322.     case CParallelPortSettings::ECPModeECP:            nEcrData |= (3 << 5); break;
  323.     case CParallelPortSettings::ECPModeEPP:            nEcrData |= (4 << 5); break;
  324.     case CParallelPortSettings::ECPModeTest:           nEcrData |= (6 << 5); break;
  325.     case CParallelPortSettings::ECPModeConfiguration:  nEcrData |= (7 << 5); break;
  326.     default: ASSERT(FALSE);                           break;
  327.   }
  328.   _outp(nEcrAddress, nEcrData);
  330.   //Update the value in our cached array
  331.   settings.m_ECPMode = mode;
  332. }
  334. CParallelPortSettings::ECPPortMode CParallelPort::GetECPMode()
  335. {
  336.   ASSERT(IsOpen()); //Port must be open 
  337.   CParallelPortSettings& settings = sm_Ports.ElementAt(m_nPortIndex);
  338.   ASSERT(settings.m_Type == CParallelPortSettings::ParallelTypeECP); //Must be an ECP port
  340.   CParallelPortSettings::ECPPortMode t = ReadECPMode(settings.m_nBaseAddress);
  341.   ASSERT(t == settings.m_ECPMode);
  343.   return settings.m_ECPMode;
  344. }
  346. CParallelPortSettings::ECPPortMode CParallelPort::ReadECPMode(unsigned short nBaseAddress)
  347. {
  348.   CParallelPortSettings::ECPPortMode mode = CParallelPortSettings::ECPModeUndefined;
  349.   int nEcrData = _inp((unsigned short)(nBaseAddress+0x402));
  350.   nEcrData = (nEcrData & 0xE0) >> 5;
  351.   switch (nEcrData)
  352.   { 
  353.     case 0: mode = CParallelPortSettings::ECPModeSPP;            break;
  354.     case 1: mode = CParallelPortSettings::ECPModePS2;            break;
  355.     case 2: mode = CParallelPortSettings::ECPModeFastCentronics; break;
  356.     case 3: mode = CParallelPortSettings::ECPModeECP;            break;
  357.     case 4: mode = CParallelPortSettings::ECPModeEPP;            break;
  358.     case 6: mode = CParallelPortSettings::ECPModeTest;           break;
  359.     case 7: mode = CParallelPortSettings::ECPModeConfiguration;  break;
  360.     default: break;
  361.   }
  362.   return mode;
  363. }
  365. BOOL CParallelPort::GetPort(unsigned short nBaseAddress, CParallelPortSettings& settings)
  366. {
  367.   BOOL bSuccess = FALSE;
  369.   //First try to detect an ECP port
  370.   if (GetECPPort(nBaseAddress))
  371.   {
  372.     settings.m_nBaseAddress = nBaseAddress;
  373.     settings.m_Type = CParallelPortSettings::ParallelTypeECP;
  374.     settings.m_ECPMode = ReadECPMode(nBaseAddress);
  375.     bSuccess = TRUE;
  376.   }
  377.   else
  378.   {
  379.     //If its not an ECP, look for an EPP.
  380.     //If the baseaddress is 3BCh, skip the EPP test.
  381.     //EPPs aren't allowed at 3BCh due to possible conflicts
  382.     //with video memory
  383.     BOOL bFoundEPP = FALSE;
  385.     if (nBaseAddress != 0x3BC)
  386.     {
  387.       bFoundEPP = GetEPPPort(nBaseAddress);
  388.       if (bFoundEPP)
  389.       {
  390.         settings.m_nBaseAddress = nBaseAddress;
  391.         settings.m_Type = CParallelPortSettings::ParallelTypeEPP;
  392.         settings.m_ECPMode = CParallelPortSettings::ECPModeUndefined;
  393.         bSuccess = TRUE;
  394.       }
  395.     }
  397.     if (!bFoundEPP)
  398.     {
  399.       //If its not an EPP, look for an SPP.
  400.       if (GetSPPPort(nBaseAddress))
  401.       {
  402.         //Test for a PS/2 port only if the SPP exists.
  403.         //because if the port doesn't exist, it will 
  404.         //pass the PS/2 test!
  405.         if (GetPS2Port(nBaseAddress))
  406.           settings.m_Type = CParallelPortSettings::ParallelTypePS2;
  407.         else
  408.           settings.m_Type = CParallelPortSettings::ParallelTypeSPP;
  410.         settings.m_nBaseAddress = nBaseAddress;
  411.         settings.m_ECPMode = CParallelPortSettings::ECPModeUndefined;
  412.         bSuccess = TRUE;
  413.       }
  414.     }
  415.   }
  417.   if (!bSuccess)
  418.   {
  419.     settings.m_nBaseAddress = 0;
  420.     settings.m_Type = CParallelPortSettings::ParallelTypeUndefined;
  421.     settings.m_ECPMode = CParallelPortSettings::ECPModeUndefined;
  422.   }  
  424.   return bSuccess;
  425. }
  427. BOOL CParallelPort::GetECPPort(unsigned short nBaseAddress)
  428. {
  429.   //If the ECP is idle and the FIFO empty,
  430.   //in the ECP's Ecp (at base address+402h),
  431.   //bit 1 (Fifo full)=0, and bit 0 (Fifo empty)=1.
  432.   //The first test is to see if these bits differ from the
  433.   //corresponding bits in the control port (at base address+2).
  434.   //If so a further test is to write 34h to the Ecr, 
  435.   //then read it back. Bit 1 is read/write and bit 0 is read-only.
  436.   //If the value read is 35h, the port is an ECP.
  437.   BOOL bSuccess = FALSE;
  438.  
  439.   unsigned short nEcrAddress = (unsigned short)(nBaseAddress+0x402);
  440.   int nEcrData = _inp(nEcrAddress);
  441.   
  442.   //Read bits 0 and 1 and control port bit 1
  443.   int nEcrBit0 = nEcrData & 0x1;
  444.   int nEcrBit1 = (nEcrData & 0x2) >> 1;
  445.   int nControlBit1 = (ReadControl(nBaseAddress) & 0x2) >> 1;
  447.   if (nEcrBit0 == 1 && nEcrBit1 == 0)
  448.   {
  449.     //Compare control bit 1 to ECR bit 1
  450.     //Toggle the control bit if necessary
  451.     //to be sure the two registers are different.
  452.     if (nControlBit1 == 0)
  453.     {
  454.       WriteControl(nBaseAddress, 0xF);
  455.       nControlBit1 = (ReadControl(nBaseAddress) & 0x2) >> 1;
  456.     }
  458.     if (nEcrBit1 != nControlBit1)
  459.     {
  460.       int nOriginalEcrData = nEcrData;
  461.       _outp(nEcrAddress, 0x34);
  462.       if (_inp(nEcrAddress) == 0x35)
  463.         bSuccess = TRUE;
  465.       //Restore the ECR to its original value
  466.       _outp(nEcrAddress, nOriginalEcrData);
  467.     }
  468.   }
  470.   return bSuccess;
  471. }
  473. BOOL CParallelPort::GetEPPPort(unsigned short nBaseAddress)
  474. {
  475.   //Write to an EPP register, then read it back.
  476.   //If the read matches the write, it's probably an EPP
  477.   BOOL bSuccess = FALSE;
  479.   //Use nEppAddressPort for testing, SPP's, ECP's and PS/2 ports
  480.   //do not have this register
  481.   unsigned short nEppAddressPort = (unsigned short) (nBaseAddress+3);
  482.   _outp(nEppAddressPort, 0x55);
  484.   //Clear the timeout bit after each EPP operation
  485.   int nTimeoutBit = GetEPPTimeoutBit(nBaseAddress);
  486.   int nRead = _inp(nEppAddressPort);
  487.   nTimeoutBit = GetEPPTimeoutBit(nBaseAddress);
  488.   if (nRead == 0x55)
  489.   {
  490.     _outp(nEppAddressPort, 0xAA);
  491.     nTimeoutBit = GetEPPTimeoutBit(nBaseAddress);
  492.     nRead = _inp(nEppAddressPort);
  493.     nTimeoutBit = GetEPPTimeoutBit(nBaseAddress);
  494.     if (nRead == 0xAA)
  495.       bSuccess = TRUE;
  496.   }  
  498.   return bSuccess;
  499. }
  501. int CParallelPort::GetEPPTimeoutBit(unsigned short nBaseAddress)
  502. {
  503.   //Reads and clears the EPP timeout bit (Statis port bit 0)
  504.   //Should be done after each EPP operation.
  505.   //The method for clearing the bit varies, so try 3 ways
  506.   //1. Write 1 to status port bit 0
  507.   //2. Write 0 to status port bit 1
  508.   //3. Read the status port again
  509.   int nReturn = (ReadStatus(nBaseAddress) & 0x1);
  510.   unsigned short nStatusPortAddress = (unsigned short)(nBaseAddress+1);
  511.   _outp(nStatusPortAddress, 1);
  512.   _outp(nStatusPortAddress, 0);
  513.   nReturn = (ReadStatus(nBaseAddress) & 0x1);
  514.   return nReturn;
  515. }
  517. BOOL CParallelPort::GetPS2Port(unsigned short nBaseAddress)
  518. {
  519.   //First try to tristate (disable) the data outputs by
  520.   //setting bit 5 of the control port. Then write 2 values
  521.   //to the data port and read each one back. If the values
  522.   //match, the data outputs are not disabled and the port
  523.   //is not bidirectional. If the values don't match, the data 
  524.   //outputs are disabled and the port is didirectional
  525.   BOOL bSuccess = FALSE;
  527.   //Set control port bit 5
  528.   WriteControl(nBaseAddress, 0x2F);
  530.   //Write the first byte and read it back
  531.   WriteData(nBaseAddress, 0x55);
  533.   //If it doesn't match, the port is bidirectional
  534.   if (ReadData(nBaseAddress) == 0x55)
  535.   {      
  536.     WriteData(nBaseAddress, 0xAA);
  538.     //If it doesn't match, the port is bidirectional
  539.     if (ReadData(nBaseAddress) != 0xAA)
  540.       bSuccess = TRUE;
  541.   }
  542.   else
  543.     bSuccess = TRUE;
  545.   //Reset control port bit 5
  546.   WriteControl(nBaseAddress, 0xF);
  548.   return bSuccess;
  549. }
  551. BOOL CParallelPort::GetSPPPort(unsigned short nBaseAddress)
  552. {
  553.   //Write two bytes and read them back. If the
  554.   //reads matches the writes, the port exists
  555.   BOOL bSuccess = FALSE;
  556.   
  557.   //Be sure that control port bit 5 = 0 (Data outputs enabled)
  558.   WriteControl(nBaseAddress, 0xF);
  560.   //Perform the first write  
  561.   WriteData(nBaseAddress, 0x55);
  562.   if (ReadData(nBaseAddress) == 0x55)
  563.   {
  564.     WriteData(nBaseAddress, 0xAA);
  565.     bSuccess = (ReadData(nBaseAddress) == 0xAA);
  566.   }
  568.   return bSuccess;
  569. }
  571. void CParallelPort::WriteControl(unsigned short nBaseAddress, int nData)
  572. {
  573.   //The control port is at offset nBaseAddress + 2.
  574.   //Bits 0, 1 & 3 need to be inverted  
  575.   _outp((unsigned short)(nBaseAddress+2), nData ^ 0xB);
  576. }
  578. int CParallelPort::ReadControl(unsigned short nBaseAddress)
  579. {
  580.   //The control port is at offset nBaseAddress + 2.
  581.   //Bits 0, 1 & 3 need to be inverted  
  582.   return (_inp((unsigned short)(nBaseAddress+2)) ^ 0xB);
  583. }
  585. void CParallelPort::WriteData(unsigned short nBaseAddress, int nData)
  586. {
  587.   //The data port is at offset nBaseAddress.
  588.   _outp(nBaseAddress, nData);
  589. }
  591. int CParallelPort::ReadData(unsigned short nBaseAddress)
  592. {
  593.   //The data port is at offset nBaseAddress.
  594.   return _inp(nBaseAddress);
  595. }
  597. int CParallelPort::ReadStatus(unsigned short nBaseAddress)
  598. {
  599.   //The status port is at offset nBaseAddress + 1.
  600.   //Bit 7 need to be inverted  
  601.   return (_inp((unsigned short)(nBaseAddress+1)) ^ 0x80);
  602. }
  604. void CParallelPort::WriteControl(int nData)
  605. {
  606.   ASSERT(IsOpen()); //Port must be open
  607.   WriteControl(m_nBaseAddress, nData);  
  608. }
  610. int CParallelPort::ReadControl()
  611. {
  612.   ASSERT(IsOpen()); //Port must be open
  613.   return ReadControl(m_nBaseAddress);  
  614. }
  616. void CParallelPort::WriteData(int nData)
  617. {
  618.   ASSERT(IsOpen()); //Port must be open
  619.   WriteData(m_nBaseAddress, nData);  
  620. }
  622. int CParallelPort::ReadData()
  623. {
  624.   ASSERT(IsOpen()); //Port must be open
  625.   return ReadData(m_nBaseAddress);  
  626. }
  628. int CParallelPort::ReadStatus()
  629. {
  630.   ASSERT(IsOpen()); //Port must be open
  631.   return ReadStatus(m_nBaseAddress);  
  632. }
  634. BOOL CParallelPort::ReadByteUsingNibbleMode(BYTE& byData)
  635. {
  636.   ASSERT(IsOpen()); //Port must be open
  638.   //Read a byte of data at the status port, in 2 nibbles
  640.   //When S6 = 0, set D3 to 0
  641.   int S6;
  642.   DWORD dwStartTicks = GetTickCount();
  643.   do
  644.   {
  645.     S6 = (ReadStatus(m_nBaseAddress) & 0x40) >> 6;
  647.     //Check the timeout has not elapsed
  648.     if ((GetTickCount() - dwStartTicks) > m_dwTimeout)
  649.       return FALSE;
  650.   }
  651.   while (S6 == 1);
  652.   WriteData(m_nBaseAddress, 0);
  654.   //When the peripheral responds by setting S6=1, Set D3=1
  655.   //nLowNibble then holds 4 bits of data
  656.   int nLowNibble;
  657.   do
  658.   {
  659.     nLowNibble = ReadStatus(m_nBaseAddress);
  660.     S6 = (nLowNibble & 0x40) >> 6;
  662.     //Check the timeout has not elapsed
  663.     if ((GetTickCount() - dwStartTicks) > m_dwTimeout)
  664.       return FALSE;
  665.   }
  666.   while (S6 == 0);
  667.   WriteData(m_nBaseAddress, 8);
  669.   //When S6 = 0, set D3 to 0
  670.   do
  671.   {
  672.     S6 = (ReadStatus(m_nBaseAddress) & 0x40) >> 6;
  674.     //Check the timeout has not elapsed
  675.     if ((GetTickCount() - dwStartTicks) > m_dwTimeout)
  676.       return FALSE;
  677.   }
  678.   while (S6 == 1);
  679.   WriteData(m_nBaseAddress, 0);
  681.   //When the peripheral responds by setting S6=1, Set D3=1
  682.   //nHighNibble then holds 4 bits of data
  683.   int nHighNibble;
  684.   do
  685.   {
  686.     nHighNibble = ReadStatus(m_nBaseAddress);
  687.     S6 = (nHighNibble & 0x40) >> 6;
  689.     //Check the timeout has not elapsed
  690.     if ((GetTickCount() - dwStartTicks) > m_dwTimeout)
  691.       return FALSE;
  692.   }
  693.   while (S6 == 0);
  694.   WriteData(m_nBaseAddress, 8);
  696.   //Recombine the two nibbles back into the byte
  697.   byData = (BYTE) (((nLowNibble & 0x8) >> 3) +
  698.                    ((nLowNibble & 0x10) >> 3) +
  699.                    ((nLowNibble & 0x20) >> 3) +
  700.                    ((nLowNibble & 0x80) >> 4) +
  701.                    ((nHighNibble & 0x8) << 1) +
  702.                    ((nHighNibble & 0x10) << 1) +
  703.                    ((nHighNibble & 0x20) << 1) +
  704.                    ((nHighNibble & 0x80))); 
  706.   return TRUE;
  707. }
  709. BOOL CParallelPort::WriteByteUsingNibbleMode(BYTE byData)
  710. {
  711.   ASSERT(IsOpen()); //Port must be open
  713.   //Write a byte to the data port, in 2 nibbles.
  714.   //The remote system reads the data at its status port.
  715.   //The data bits are D0, D1, D2 and D4.
  716.   //D3 is the strobe
  717.   int nLowNibble = byData & 0x07;
  718.   nLowNibble |= (byData & 0x08) << 1;
  719.   int nHighNibble = (byData & 0x70) >> 4;
  720.   nHighNibble |= (byData & 0x80) >> 3;
  722.   //When S6=1 (not busy), write the low nibble and set D3=0.
  723.   int S6;
  724.   DWORD dwStartTicks = GetTickCount();  
  725.   do
  726.   {
  727.     S6 = (ReadStatus(m_nBaseAddress) & 0x40) >> 6;
  729.     //Check the timeout has not elapsed
  730.     if ((GetTickCount() - dwStartTicks) > m_dwTimeout)
  731.       return FALSE;
  732.   }
  733.   while (S6 == 0);
  734.   WriteData(m_nBaseAddress, nLowNibble);
  736.   //When the peripheral responds by setting S6=0, Set D3=1.
  737.   do
  738.   {
  739.     S6 = (ReadStatus(m_nBaseAddress) & 0x40) >> 6;
  741.     //Check the timeout has not elapsed
  742.     if ((GetTickCount() - dwStartTicks) > m_dwTimeout)
  743.       return FALSE;
  744.   }
  745.   while (S6 == 1);
  746.   WriteData(m_nBaseAddress, nLowNibble | 0x8);
  748.   //When S6=1, write the high nibble and set D3=0
  749.   do
  750.   {
  751.     S6 = (ReadStatus(m_nBaseAddress) & 0x40) >> 6;
  753.     //Check the timeout has not elapsed
  754.     if ((GetTickCount() - dwStartTicks) > m_dwTimeout)
  755.       return FALSE;
  756.   }
  757.   while (S6 == 0);
  758.   WriteData(m_nBaseAddress, nHighNibble);
  760.   //When the peripheral responds by setting S6=0, Set D3=1.
  761.   do
  762.   {
  763.     S6 = (ReadStatus(m_nBaseAddress) & 0x40) >> 6;
  765.     //Check the timeout has not elapsed
  766.     if ((GetTickCount() - dwStartTicks) > m_dwTimeout)
  767.       return FALSE;
  768.   }
  769.   while (S6 == 1);
  770.   WriteData(m_nBaseAddress, nHighNibble | 0x8);
  772.   return TRUE;
  773. }
  775. BOOL CParallelPort::ReadUsingNibbleMode(void* lpBuf, DWORD dwBytes)
  776. {
  777.   //Validate the parameters
  778.   ASSERT(lpBuf);
  780.   //Read each byte into lpBuf  
  781.   BYTE* lpByteBuf = (BYTE*) lpBuf;
  782.   for (DWORD i=0; i<dwBytes; i++)
  783.   {
  784.     if (!ReadByteUsingNibbleMode(lpByteBuf[i]))
  785.       return FALSE;
  786.   }
  787.   return TRUE;
  788. }
  790. BOOL CParallelPort::WriteUsingNibbleMode(const void* lpBuf, DWORD dwBytes)
  791. {
  792.   //Validate the parameters
  793.   ASSERT(lpBuf);
  795.   //Write each byte from lpBuf  
  796.   const BYTE* lpByteBuf = (const BYTE*) lpBuf;
  797.   for (DWORD i=0; i<dwBytes; i++)
  798.   {
  799.     if (!WriteByteUsingNibbleMode(lpByteBuf[i]))
  800.       return FALSE;
  801.   }
  802.   return TRUE;
  803. }
  805. int CParallelPort::_inp(unsigned short port)
  806. {
  807.   if (sm_bRunningOnNT)
  808.   {
  809.     ASSERT(sm_lpfnDlPortReadUchar);
  810.     return sm_lpfnDlPortReadUchar(port);
  811.   }
  812.   else
  813.     return ::_inp(port);
  814. }
  816. int CParallelPort::_outp(unsigned short port, int databyte)
  817. {
  818.   if (sm_bRunningOnNT)
  819.   {
  820.     ASSERT(sm_lpfnDlPortWriteUchar);
  821.     sm_lpfnDlPortWriteUchar(port, (UCHAR) databyte);
  822.     return databyte;
  823.   }
  824.   else
  825.     return ::_outp(port, databyte);
  826. }
  828. BOOL CParallelPort::InitializeDriverLINX()
  829. {
  830.   //Load up the DriverLINX dll and get the function pointers we are interested in
  831.   ASSERT(sm_hDLINX == NULL);
  832.   BOOL bSuccess = FALSE;
  833.   sm_hDLINX = LoadLibrary(_T("DLPORTIO.DLL"));
  834.   if (sm_hDLINX)
  835.   {
  836.     //Get the function pointers
  837.     sm_lpfnDlPortReadUchar = (LPDLPORTREADPORTUCHAR) GetProcAddress(sm_hDLINX, "DlPortReadPortUchar");
  838.     sm_lpfnDlPortWriteUchar = (LPDLPORTWRITEPORTUCHAR) GetProcAddress(sm_hDLINX, "DlPortWritePortUchar");
  840.     //If any of the functions are not installed then fail the load
  841.     if (sm_lpfnDlPortReadUchar == NULL ||
  842.         sm_lpfnDlPortWriteUchar == NULL)
  843.     {
  844.       TRACE(_T("CParallelPort::InitializeDriverLINX, Failed to get one of the function pointer`s in the DriverLINX dlln"));
  845.       DeInitializeDriverLINX();
  846.     }
  847.     else
  848.       bSuccess = TRUE;
  849.   }
  850.   else
  851.     TRACE(_T("CParallelPort::InitializeDriverLINX, Could not find the load the DriverLINX dll, please ensure DriverLINX driver is installedn"));
  853.   return bSuccess;
  854. }
  856. void CParallelPort::DeInitializeDriverLINX()
  857. {
  858.   if (sm_hDLINX)
  859.   {
  860.     //Unload the dll and reset the function pointers to NULL    
  861.     FreeLibrary(sm_hDLINX);
  862.     sm_hDLINX = NULL;
  863.     sm_lpfnDlPortReadUchar = NULL;
  864.     sm_lpfnDlPortWriteUchar = NULL;
  865.   }
  866. }
  868. BOOL CParallelPort::PortPresent(int nPort)
  869. {
  870.   BOOL bSuccess = FALSE;
  872.   //Try to open the port 
  873.   CString sPort;
  874.   sPort.Format(_T("\\.\LPT%d"), nPort);
  875.   HANDLE hPort = ::CreateFile(sPort, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
  876.   if (hPort != INVALID_HANDLE_VALUE)
  877.   {
  878.     bSuccess = TRUE;
  880.     //Close the port, now that we don't need it anymore
  881.     ::CloseHandle(hPort);
  882.   }
  883.   else
  884.   {
  885.     //Determine if the port exists based on the error code.
  886.     DWORD dwError = GetLastError();
  888.     //Check to see if the error was because some other app had the port open or a general failure
  889.     if (dwError == ERROR_ACCESS_DENIED || dwError == ERROR_GEN_FAILURE)
  890.       bSuccess = TRUE;
  891.   }
  893.   return bSuccess;
  894. }
  896. BOOL CParallelPort::RunningOnNT()
  897. {
  898.   OSVERSIONINFO osvi;
  899.   memset(&osvi, 0, sizeof(OSVERSIONINFO));
  900.   osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
  901.   VERIFY(GetVersionEx(&osvi));
  902.   return (osvi.dwPlatformId == VER_PLATFORM_WIN32_NT);
  903. }
  905. CParallelPortSettings CParallelPort::GetSettings() const
  906. {
  907.   ASSERT(IsOpen()); //Port must be open 
  908.   return sm_Ports.GetAt(m_nPortIndex);
  909. }
  913. ////////// The file transfer class
  915. CParallelPortFileTransfer::CParallelPortFileTransfer(CParallelPort* pPort)
  916. {
  917.   m_pPort = NULL;
  918.   ASSERT(pPort != NULL);
  919.   ASSERT(pPort->IsOpen());
  921.   //Ensure the Port is set to SPP mode if it is an ECP port
  922.   CParallelPortSettings settings = pPort->GetSettings();
  923.   if (settings.m_Type == CParallelPortSettings::ParallelTypeECP)
  924.     pPort->SetECPMode(CParallelPortSettings::ECPModeSPP);
  926.   //Initialize D3 (strobe) to 1
  927.   pPort->WriteData(0x8);
  929.   //Wait for the opposite end to set D3=1 (not busy)
  930.   int S6;
  931.   DWORD dwStartTicks = GetTickCount();
  932.   do
  933.   {
  934.     S6 = (pPort->ReadStatus() & 0x40) >> 6;
  936.     //Check the timeout has not elapsed
  937.     if ((GetTickCount() - dwStartTicks) > pPort->GetTimeout())
  938.     {
  939.       TRACE(_T("CParallelPortFileTransfer::CParallelPortFileTransfer, Could not setup file transfer, other end busyn"));
  940.       AfxThrowParallelException(ERROR_TIMEOUT);
  941.     }
  942.   }
  943.   while (S6 == 0);
  945.   //Store away the port pointer for use in other class methods
  946.   m_pPort = pPort;
  947. }
  949. CParallelPortFileTransfer::~CParallelPortFileTransfer()
  950. {
  951.   m_pPort = NULL;
  952. }
  954. void CParallelPortFileTransfer::SendFile(const CString& sLocalFile)
  955. {
  956.   ASSERT(m_pPort); //Initialize failed
  958. //For correct operation of the T2A macro, see MFC Tech Note 59
  959. USES_CONVERSION;
  961.   //First try to open the file to send
  962.   CFile file;
  963.   CFileException ex;
  964.   if (file.Open(sLocalFile, CFile::modeRead | CFile::shareDenyWrite), &ex)
  965.   {
  966.     //first send the filename (excluding the path) (size if _MAX_PATH)
  967.     TCHAR pszPath[_MAX_PATH];
  968.     TCHAR pszFname[_MAX_FNAME];
  969.     TCHAR pszExt[_MAX_EXT];
  970.     _tsplitpath(sLocalFile, NULL, NULL, pszFname, pszExt);
  971.     _tmakepath(pszPath, NULL, NULL, pszFname, pszExt);
  973.     //Now need to convert the filename to ASCII so that a UNICODE
  974.     //client can take to an ASCII server
  975.     char pszAsciiPath[_MAX_PATH];
  976.     char* pszTemp = T2A(pszPath);
  977.     ZeroMemory(pszAsciiPath, _MAX_PATH);
  978.     strcpy(pszAsciiPath, pszTemp);
  980.     //Do the actual send of the filename
  981.     if (!m_pPort->WriteUsingNibbleMode(pszAsciiPath, _MAX_PATH))
  982.     {
  983.       TRACE(_T("CParallelPortFileTransfer::SendFile, Failed to send the filenamen"));
  984.       AfxThrowParallelException(ERROR_TIMEOUT);
  985.     }
  987.     try
  988.     {
  989.       //Then send the size of the file (as 4 bytes).
  990.       DWORD dwLength = file.GetLength();
  991.       if (!m_pPort->WriteUsingNibbleMode(&dwLength, sizeof(DWORD)))
  992.       {
  993.         TRACE(_T("CParallelPortFileTransfer::SendFile, Failed to send the file lengthn"));
  994.         AfxThrowParallelException(ERROR_TIMEOUT);
  995.       }
  997.       //Then the actual file contents ifself (4k at a time)
  998.       BYTE byData[4096];
  999.       int nBytesRead;
  1000.       do
  1001.       {
  1002.         nBytesRead = file.Read(byData, 4096);
  1003.         if (!m_pPort->WriteUsingNibbleMode(byData, nBytesRead))
  1004.         {
  1005.           TRACE(_T("CParallelPortFileTransfer::SendFile, Failed to send the file contentsn"));
  1006.           AfxThrowParallelException(ERROR_TIMEOUT);
  1007.         }
  1008.       }
  1009.       while (nBytesRead);
  1010.     }
  1011.     catch(CFileException* pEx)
  1012.     {
  1013.       DWORD dwLastError = pEx->m_lOsError;
  1014.       TRACE(_T("CParallelPortFileTransfer::SendFile, An error occurred reading from the file to send, Error:%dn"), dwLastError);
  1015.       delete pEx;
  1016.       AfxThrowParallelException(dwLastError);
  1017.     }
  1018.   }
  1019.   else
  1020.   {
  1021.     TRACE(_T("CParallelPortFileTransfer::SendFile, Could not open the file to send, %sn"), sLocalFile);
  1022.     AfxThrowParallelException(ex.m_lOsError);
  1023.   }
  1024. }
  1026. void CParallelPortFileTransfer::ReceiveFile(const CString& sLocalFile)
  1027. {
  1028. //For correct operation of the T2A macro, see MFC Tech Note 59
  1029. USES_CONVERSION;
  1031.   //First try to open the file to send
  1032.   CFile file;
  1033.   CFileException ex;
  1034.   if (file.Open(sLocalFile, CFile::modeCreate | CFile::modeWrite | CFile::shareDenyWrite, &ex))
  1035.   {
  1036.     //Receive the filename
  1037.     char pszAsciiPath[_MAX_PATH];
  1038.     if (!m_pPort->ReadUsingNibbleMode(pszAsciiPath, _MAX_PATH))
  1039.     {
  1040.       TRACE(_T("CParallelPortFileTransfer::ReceiveFile, Failed to receive the filenamen"));
  1042.       //Delete the local file
  1043.       file.Close();
  1044.       DeleteFile(sLocalFile);
  1046.       //Throw the exception
  1047.       AfxThrowParallelException(ERROR_TIMEOUT);
  1048.     }
  1050.     try
  1051.     {
  1052.       //Receive the size of the file (as 4 bytes).
  1053.       DWORD dwLength;
  1054.       if (!m_pPort->ReadUsingNibbleMode(&dwLength, sizeof(DWORD)))
  1055.       {
  1056.         TRACE(_T("CParallelPortFileTransfer::ReceiveFile, Failed to receive the file lengthn"));
  1057.   
  1058.         //Delete the local file
  1059.         file.Close();
  1060.         DeleteFile(sLocalFile);
  1062.         //Throw the exception
  1063.         AfxThrowParallelException(ERROR_TIMEOUT);
  1064.       }
  1066.       //Then the actual file contents ifself (4k at a time)
  1067.       BYTE byData[4096];
  1068.       DWORD dwBytesLeft = dwLength;
  1069.       do
  1070.       {
  1071.         DWORD dwBytesToRead;
  1072.         if (dwBytesLeft > 4096)
  1073.           dwBytesToRead = 4096;
  1074.         else
  1075.           dwBytesToRead = dwBytesLeft;
  1076.           
  1077.         if (!m_pPort->ReadUsingNibbleMode(byData, dwBytesToRead))
  1078.         {
  1079.           TRACE(_T("CParallelPortFileTransfer::ReceiveFile, Failed to receive the file contentsn"));
  1081.           //Delete the local file
  1082.           file.Close();
  1083.           DeleteFile(sLocalFile);
  1085.           //Throw the exception
  1086.           AfxThrowParallelException(ERROR_TIMEOUT);
  1087.         }
  1089.         file.Write(byData, dwBytesToRead);
  1090.         dwBytesLeft -= dwBytesToRead;
  1091.       }
  1092.       while (dwBytesLeft);
  1093.     }
  1094.     catch(CFileException* pEx)
  1095.     {
  1096.       DWORD dwLastError = pEx->m_lOsError;
  1097.       TRACE(_T("CParallelPortFileTransfer::ReceiveFile, An error occurred writing the file which was being received, Error:%dn"), dwLastError);
  1098.       delete pEx;
  1099.       AfxThrowParallelException(dwLastError);
  1100.     }
  1101.   }
  1102.   else
  1103.   {
  1104.     TRACE(_T("CParallelPortFileTransfer::ReceiveFile, Could not open the file to receive into, %s, Error:%dn"), sLocalFile, ex.m_lOsError);
  1105.     AfxThrowParallelException(ex.m_lOsError);
  1106.   }
  1107. }