serial port communication using C++/CLR

See more:

C++/CLI

Hi guys,
I am currently undertaking the GPS programming in C++. I found that on MSDN it has shown that it is really easy if using C++/CLR to implement serial port communication.
I therefore programmed my code for this function. Currently it can be complied but it looks like it has "overflow" problem. I have no idea to such kind of problems (if you cope the file into your computer and you will find that). Can anybody help me, any helps and suggestions could be appreciated in advance. I prefer that you indicate where and why i am wrong on my code.
I attahced the original code as follws, the function of the codes aim to set serial port index, connect serial port and write the received data from buffer in a file. i am sorry for too long code, but actually the following functions have the same functions. :)

#include <iostream>
#include <fstream>
#include <string>

#using <System.dll>

using namespace std;
using namespace System;
using namespace System::IO::Ports;
using namespace System::Threading;

public ref class PortCommunication
{
private:
static bool _continue;
static SerialPort^ _serialPort;

public:
    static void Main()
    {
        String^ DataReceiving;
        String^ message;
        Thread^ readThread = gcnew Thread(gcnew ThreadStart(PortCommunication::Read));

        // Create a new SerialPort object with default settings.
        _serialPort = gcnew SerialPort();

        // Allow the user to set the appropriate properties.
        _serialPort->PortName = SetPortName(_serialPort->PortName);
        _serialPort->BaudRate = SetPortBaudRate(_serialPort->BaudRate);
        _serialPort->Parity = SetPortParity(_serialPort->Parity);
        _serialPort->DataBits = SetPortDataBits(_serialPort->DataBits);
        _serialPort->StopBits = SetPortStopBits(_serialPort->StopBits);
        _serialPort->Handshake = SetPortHandshake(_serialPort->Handshake);

        // Set the read/write timeouts
        _serialPort->ReadTimeout = 5000;
        _serialPort->WriteTimeout = 5000;

        _serialPort->Open();
        _continue = true;
        readThread->Start();

        Console::Write("Data Receiving: ");
        DataReceiving = _serialPort->ReadLine();

        cout << "KKK" << DataReceiving << endl;

        //read data from serial port
        //message = _serialPort::Read();
        //message = Console::ReadLine();

        string buffer;

        PortCommunication::MarshalString(DataReceiving, buffer);

        PortCommunication::WriteDataToFile(buffer);

        Console::WriteLine("Type QUIT to exit");

    }

    // convert the system string to std:: string
    static void MarshalString ( String ^ s, string& os )
    {
            using namespace Runtime::InteropServices;
            const char* chars =
            (const char*)(Marshal::StringToHGlobalAnsi(s)).ToPointer();
            os = chars;
            Marshal::FreeHGlobal(IntPtr((void*)chars));
    }

    // write buffer data to txt file
    static void WriteDataToFile(string sentence)
    {
         char quit = 'c';
         //string str;

        //open file to write
         ofstream outfile ("GPSdata1.txt", ios_base::out);

        if(!outfile) {
                cerr << "cannot open  GPSdata.txt file !!!\n";
                exit (-1);
        }

        //allow user to write to file
        while (quit != 'q' && quit != 'Q')
        {
            //getline(sentence, str);
            cout << sentence << endl;
            outfile << sentence << endl;
            cout<<"Enter q to quit or c to continue entering data.\n";
            cin >> quit;
        }

        //close file
        outfile.close();
    }

    //read function
    static void Read()
    {
        while (_continue)
        {
            try
            {
                String^ message = _serialPort->ReadLine();
                Console::WriteLine(message);
            }
            catch (TimeoutException ^) { }
        }
    }

    // set up the partName
    static String^ SetPortName(String^ defaultPortName)
    {
        String^ portName;

        Console::WriteLine("Available Ports:");
        for each (String^ s in SerialPort::GetPortNames())
        {
            Console::WriteLine("   {0}", s);
        }

        Console::Write("COM port({0}): ", defaultPortName);
        portName = Console::ReadLine();

        if (portName == "")
        {
            portName = defaultPortName;
        }
        return portName;
    }

     static Int32 SetPortBaudRate(Int32 defaultPortBaudRate)
    {
        String^ baudRate;

        Console::Write("Baud Rate({0}): ", defaultPortBaudRate);
        baudRate = Console::ReadLine();

        if (baudRate == "")
        {
            baudRate = defaultPortBaudRate.ToString();
        }

        return Int32::Parse(baudRate);
    }

     static Parity SetPortParity(Parity defaultPortParity)
    {
        String^ parity;

        Console::WriteLine("Available Parity options:");
        for each (String^ s in Enum::GetNames(Parity::typeid))
        {
            Console::WriteLine("   {0}", s);
        }

        Console::Write("Parity({0}):", defaultPortParity.ToString());
        parity = Console::ReadLine();

        if (parity == "")
        {
            parity = defaultPortParity.ToString();
        }

        return (Parity)Enum::Parse(Parity::typeid, parity);
    }

    static Int32 SetPortDataBits(Int32 defaultPortDataBits)
    {
        String^ dataBits;

        Console::Write("Data Bits({0}): ", defaultPortDataBits);
        dataBits = Console::ReadLine();

        if (dataBits == "")
        {
            dataBits = defaultPortDataBits.ToString();
        }

        return Int32::Parse(dataBits);
    }

     static StopBits SetPortStopBits(StopBits defaultPortStopBits)
    {
        String^ stopBits;

        Console::WriteLine("Available Stop Bits options:");
        for each (String^ s in Enum::GetNames(StopBits::typeid))
        {
            Console::WriteLine("   {0}", s);
        }

        Console::Write("Stop Bits({0}):", defaultPortStopBits.ToString());
        stopBits = Console::ReadLine();

        if (stopBits == "")
        {
            stopBits = defaultPortStopBits.ToString();
        }

        return (StopBits)Enum::Parse(StopBits::typeid, stopBits);
    }

     static Handshake SetPortHandshake(Handshake defaultPortHandshake)
    {
        String^ handshake;

        Console::WriteLine("Available Handshake options:");
        for each (String^ s in Enum::GetNames(Handshake::typeid))
        {
            Console::WriteLine("   {0}", s);
        }

        Console::Write("Handshake({0}):", defaultPortHandshake.ToString());
        handshake = Console::ReadLine();

        if (handshake == "")
        {
            handshake = defaultPortHandshake.ToString();
        }

        return (Handshake)Enum::Parse(Handshake::typeid, handshake);
    }
};

int main()
{
    PortCommunication::Main();
}