Client Server Programm

Ja aber wie?

Nilix Nilix schrieb:
> RS232

Das ist mir schon klar, dass die Verbindung mit einem RS232 zu 
realisieren ist.

Hast du vielleicht einen Beispiel Code zu Hilfe?

Dominik S. schrieb:
> Du bist mal lustig...
>
> Verrätst uns weder, um welche Art "embedded Modul" es sich handelt (Was
> für ein Controller? Welche Programmiersprache?), noch welche Sprach du
> am PC verwendest.
> Wie soll man da Beispielcode geben?

Da hast du vollkommen Recht :-)

embedded Modul: TMS320C2000
Controller: F28035
Programmiersprache: C

Für welchen Protokoll zu Übertragung ist für meine Anwendung am besten 
geeignet?

HLDC, Modbus....

Ich habe mir was überlegt (Anhang).

Was soll in der Header schreiben?
Länger der Daten ist klar
bei Daten: Soll ich anfang und ende mitreinpacken?
CRC aus (Daten+Länge)?

Kann mir niemenden helfen?

cyblord ---- schrieb:
> Niemand weiß was du brauchst. Wie wärs wenn du dir selber überlegst, was
> dein Protokoll leisten sollte?

Mein Protokoll soll die übergbene cmd(Command) von der Client an der 
Server weiterleiten und dort werden ausgeführt.

Da ich Client/Server auf ganz low Level noch nie gemacht habe, ist mir 
das ganze nicht zu 100% klar wie ich am schlauesten umgehen muss.

Es ist wie ich oben geschrieben habe:
Die Verbindung zwischen der Client(PC, Visual Studio) und der 
Server(Code Composer Studio Embedded Modul) ist durch ein RS232 
gewährleistet.

Der Server muss eigentlich bestimmte vordefnierte Funktionalität 
ausführen.

ZB:
Client(PC):  bei eine Eingabe von 1 in Konsole (Visual Studio)
Server(Embedded Modul): (Code Compose Studio) 1 heisst Led 1 und 2 
blinken lassen ...

Für diese Anwendung brauche ich keine TCP oder UDP Protokoll

Danke in Voraus

Es kommt ganz darauf an, was du machen willst... Man kann auch 
Zeitstempel reinmachen, Bits für odd und even usw...
Aber warum willst du das Rad neu erfinden? Es gibt eigentlich genug 
Protokolle auf dieser Welt, die bereits spezifiziert sind.
Außerdem: für RS232 per USB beispielsweise ist doch schon alles fertig. 
USB übernimmt alles für dich und du musst nix mehr absichern.

Schau dir mal das ISO-OSI-Schichtenmodell an und dann überlege dir: 
warum hat man das so entwickelt?

cyblord ---- schrieb:
> Sorry. Ich habe keine Ahnung was du möchtest.

Danke für die Antwort erst mal:

Wie kann ich eine Verbindung zwischen den Server und der Client 
herstellen?

Zb: Bei eine erfolgreiche Verbindung dem Client(PC, Visual Studio) mit 
dem Server (Embedded Modul, Code Composer Studio) eine Ausgabe in 
Terminal Program (Connect ist erfolgreich)

cyblord ---- schrieb:
> Dachte du willst das per RS232 machen!? Im Visual Studio gibs die
> SerialPort Klasse, damit geht das.

Ja schon: Die Verbindung wird mit RS232 gemacht, aber der Client wird 
mit Visual Studio gesteuert.

Ich versuche gerade einen Programm mit Visual studio 2010 zu schreiben, 
der mir die Verbindung mit dem Serial Port herstellt und es hängt an 
alles. habe zwar einen Beispiel im Internet gefunden aber weiss es nicht 
wie ich das anwenden kann?
http://msdn.microsoft.com/de-de/library/system.io.ports.serialport.aspx?cs-save-lang=1&cs-lang=cpp#code-snippet-1

Vielen Dank
Es hat funktioniert.
Ich kann doch eine Verbindung herstellen.
Nur noch eine Frage bei bei diesem Links wo es einen Beispiel Code in 
C++ geschrieben ist funktioniert es nicht.
Es wird folgende Fehler gegeben: "#using" erfordert C++/CLI-Modus.

Es hat bestimmt mit einer Einstellung zu tun.

Das sind aber eigentlich keine Embedded-Probleme mehr.
Code-Beispiel zeigen wäre sinnvoll. Du hast auch hoffentlich natives C++ 
und kein C++ CLI Projekt gemacht, oder?

ja Ich habe habe ganze normale c++ Console Application Projeckt 
erstellt.

Hier ist das Beispielcode:


#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();
}

Ich habe ganze normale Console Application Projeckt erstellt

Brater schrieb:
> Das sind aber eigentlich keine Embedded-Probleme mehr.
> Code-Beispiel zeigen wäre sinnvoll. Du hast auch hoffentlich natives C++
> und kein C++ CLI Projekt gemacht, oder?

Projekt muss ein CLI Projekt erstellt werden.
Das habe ich gemacht.
Es tritt einen Problem beim öffnen der SerialPort:
_serialPort->Open();

Da kommt eine Fehlermeldung:
Seh bitte Anhang