views:

75

answers:

6

I seem to be having a bit of a TEXT / UNICODE problem when using the windows CreateFile function for addressing a serial port. Can someone please help point out my error?

I'm writing a Win32 console application in VC++ using VS 2008.

I can create a handle to address the serial port like this:

#include <iostream>    
#include <windows.h>
#include <string>

int main()
{

   HANDLE hSerial;

   hSerial = CreateFile( L"\\\\.\\COM20",
                         GENERIC_READ | GENERIC_WRITE,
                         0,
                         0,
                         OPEN_EXISTING,
                         FILE_ATTRIBUTE_NORMAL,
                         0);`

   return 0;
}

That works just fine (the \\\\.\\ bit is required for comports greater than COM9 and works for those up to COM9 also). The problem is that my comport will not always be COM20, so I'd like to have the user specify what it is.

Here are some things I've tried:

#include <iostream>    
#include <windows.h>
#include <string>

int main()
{
   std::string comNum;
   std::cout << "\n\nEnter the port (ex: COM20): ";
   std::cin >> comNum;
   std::string comPrefix = "\\\\.\\";
   std::string comID = comPrefix+comNum;

   HANDLE hSerial;

   hSerial = CreateFile( comID,
                         GENERIC_READ | GENERIC_WRITE,
                         0,
                         0,
                         OPEN_EXISTING,
                         FILE_ATTRIBUTE_NORMAL,
                         0);`

   return 0;
}

This does not compile and returns the error: error C2664: 'CreateFileW' : cannot convert parameter 1 from 'std::string' to 'LPCWSTR'

I thought maybe specifying CreateFileA would work then, but that gave basically the same error.

I also tried :

/*
everything else the same
*/   

hSerial = CreateFile( TEXT(comID),
                      GENERIC_READ | GENERIC_WRITE,
                      0,
                      0,
                      OPEN_EXISTING,
                      FILE_ATTRIBUTE_NORMAL,
                      0);`

which also does not compile and returns: error C2065: 'LcomID' : undeclared identifier

I am not much of an expert but I have been working on this for a while now. Can someone tell me how to replace L"\\\\.\\COM20" in such a way that the user can specify the comport and so that CreateFile will still work? Thanks!

+2  A: 

You can either use std::wstring and std::wcin, std::wcout to perform input directly in "unicode strings", or you can look into Microsoft's conversion functions.

If you go for the 1st option (recommended), you still need to use the c_str() function to gain access to a LPCWSTR value (pointer to const wchar_t).

Sample solution (also not use of CreateFileW syntax, to prevent issues with UNICODE macro):

#include <iostream>    
#include <windows.h>
#include <string>

int main()
{
   std::wstring comNum;
   std::wcout << L"\n\nEnter the port (ex: COM20): ";
   std::wcin >> comNum;
   std::wstring comPrefix = L"\\\\.\\";
   std::wstring comID = comPrefix+comNum;

   HANDLE hSerial;

   hSerial = CreateFileW( comID.c_str(),
                     GENERIC_READ | GENERIC_WRITE,
                     0,
                     0,
                     OPEN_EXISTING,
                     FILE_ATTRIBUTE_NORMAL,
                     0);`

   return 0;
}
André Caron
Awesome thank you!
John
A: 

As an additional reference, have a look at the ATL conversions macros (eg: CA2CW, etc.). These (if used properly) can handle pretty much all simple conversion cases inline, with little fuss.

In your example, you can use std::string, then use:

CreateFile( CA2CT( comID.c_str() ), ... );
Nick
A: 

If (for some reason) you decide to keep working with ANSI strings, then take a look at the MultiByteToWideChar function. But ANSI strings are pretty much obsolete.

myeviltacos
A: 

I ran into this recently. I simply disabled Unicode, as Unicode was wholly out of scope for this application.

Paul Nathan
You can't disable Unicode. It's the native character set of Windows. You probably chose to use the wrapper functions such as `CreateFileA`. You should know that they will always convert their arguments to Unicode (outside your control) and then call the Unicode equivalent.
MSalters
@MSalters: #undef UNICODE and then turn off the various Wide Character compilation settings.
Paul Nathan
@Paul Nathan: That doesn't actually disable Unicode. The `#undef` causes `CreateFile` to be #defined as `CreateFileA`, as I suspected. That still is a wrapper for `CreateFileW` . The `*W` functions are not disabled by such #defines. Newer APIs, _including COM_ , are not affected by this #define; they are always Unicode. Hence, if you do not want to deal with two character sets, choose Unicode only. if you choose ANSI, you always have to consider how that interacts with Unicode behind the scenes.
MSalters
@MSalters. Gah.
Paul Nathan
+1  A: 

If you want to continue using std::string, then use its c_str() method when calling CreateFileA(), eg:

hSerial = CreateFileA( comID.c_str(), ...);
Remy Lebeau - TeamB
+1, This is sufficient for the stated problem (serial port names).
MSalters
A: 

General info on string conversions here: http://www.codeproject.com/KB/string/cppstringguide2.aspx

AngryWhenHungry