SerialPort

Hallo alle Zusammen:

ich habe folgende vor:

Einen Client(PC) Server(Embedded Modul) Konzept zu entwerfen.
Es muss einen ganzen Simple Verbindung (Client->Server)(Point zu Point)
hergestellt werden.

--> Meine Vorgehen sieht so aus:
von PC bzw. Visual Studio werden an der Konsole (mit Testatur)bestimmt
Command (Diesen Command sind schon definiert als Beispiel beim eine
Eingabe von 1 Led von 1 bis 8 blinken lassen)eingegeben.
Die eingegebenen Command werden weitergeleitet an der(Embedded Modul),
der Sie ausführt und das Ergebnis in einem Terminal Programm ausgibt.

--> Als nächste :
wollte ich mit dem Clien anfangen und zwar eine serialPort Verbindung zu herstellen.
Ich habe aus dem Internet einen TestCod, der ich ausprobiert habe in dem ich einen CLR_Console_Application Projekt erstellt habe.

Das lieft fast richtig nur tritt einen Problem in einem Stellen und zwar beim:

_serialPort->Open();

Das Fehler besagt, dass die SerialPort nicht geöffnet werden könnte.

anbei das QuellenCode:

// TestSerialPort_CLR_Console_Application.cpp : main project file.

#include "stdafx.h"
#using <System.dll>

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

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

public:
    static void Main()
    {
        String^ name;
        String^ message;
        StringComparer^ stringComparer = StringComparer::OrdinalIgnoreCase;
        Thread^ readThread = gcnew Thread(gcnew ThreadStart(PortChat::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 = 500;
        _serialPort->WriteTimeout = 500;

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

        Console::Write("Name: ");
        name = Console::ReadLine();

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

        while (_continue)
        {
            message = Console::ReadLine();

            if (stringComparer->Equals("quit", message))
            {
                _continue = false;
            }
            else
            {
                _serialPort->WriteLine(
                    String::Format("<{0}>: {1}", name, message) );
            }
        }

        readThread->Join();
        _serialPort->Close();
    }

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

    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()
{
    PortChat::Main();
}

Für jeden Tipp bin dankbar

die programmiersprache sieht nicht nach c++ aus, wirst wohl im falschen forum gelandet sein

theta

Falsches Forum: C++/CLI wäre korrekt.

Es ist c++ aber halt nicht native c++ sondern CLI Konsole Application

C++ Forumbot

Dieser Thread wurde von Moderator/in SeppJ aus dem Forum C++ (auch C++0x und C++11) in das Forum C++/CLI mit .NET verschoben.

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.

MaximGast schrieb:

Es ist c++ aber halt nicht native c++ sondern CLI Konsole Application

für mich sind abwandlungen von c++ kein c++ mehr

SeppJ

MaximGast schrieb:

Es ist c++ aber halt nicht native c++ sondern CLI Konsole Application

Dies ist Englisch aber halt nicht native Englisch sondern Deutsch.

Wie kann ich bitte ganz normal mit Standard c++ eine serialPort verbindung herstellen ...

mit standard c++ ohne zusatzbibliotheken? gar nicht.

Hallo alle zusammen,

ich versuche eine Windows Form Application mit Visual Studio 2012 in C++/CLI zu schreiben.

ich versuche mit einenm ComboBox alle ComPorts einzulesen und in der Combobox reinzufügen.

Nur bekomme ich eine leere Liste.

Hier anbei einen Abschnitt von meinem Quellencode:

using namespace System;
	using namespace System::ComponentModel;
	using namespace System::Collections;
	using namespace System::Windows::Forms;
	using namespace System::Data;
	using namespace System::Drawing;
	using namespace System::IO::Ports;

	/// <summary>
	/// Zusammenfassung für MyForm
	/// </summary>
	public ref class MyForm : public System::Windows::Forms::Form
	{
	public:
		MyForm(void)
		{
			InitializeComponent();
//Port finden
			findPorts();
........

// findPorts Methode

#pragma endregion

	private: void findPorts(void)
			 {
		    array<Object^>^ objectArray = SerialPort::GetPortNames();
			this->comboBox1->Items->AddRange( objectArray );

			 }

was mache ich den Falsch ?

theta

MaximGast schrieb:

Wie kann ich bitte ganz normal mit Standard c++ eine serialPort verbindung herstellen ...

Für native C++ (kein .NET) kannst du z.B. die serial_port Klasse aus Boost.Asio oder die Klasse CSerial aus http://www.codeproject.com/Articles/992/Serial-library-for-C verwenden.