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. Meine Frage ist: Wie kann ich diese Verbindung erst mal herstellen(kein UDP,TCP)? Wie soll ich diese Protokoll definieren? Danke in Voraus
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?
Maxim schrieb: > Hast du vielleicht einen Beispiel Code zu Hilfe? 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?
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....
Maxim schrieb: > Für welchen Protokoll zu Übertragung ist für meine Anwendung am besten > geeignet? > > HLDC, Modbus.... Eigenes Protokoll ausdenken?
Angehängte Dateien:
-
protokoll.png
1,1 KB
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)?
Niemand weiß was du brauchst. Wie wärs wenn du dir selber überlegst, was dein Protokoll leisten sollte? Die Skizze oben funktioniert so schon. Die Frage ist, ist es das was DU brauchst. Warum einen Header wenn du anscheinend keine Verwendung dafür hast? Der Header könnte z.B. aus einem oder mehreren Startzeichen zur Synchronisierung bestehen. Oben beschreibst du schon einen Teil. Du willst Kommandos senden. Dann sollte dein Protokol sich daran orientieren. Nicht einfach beliebig lange Daten zulassen. Sind die Daten überhaupt von Variabler Länge? Oben wird davon nichts erwähnt. Wenn du z.B. ein Command-Byte hast (Verb, WAS soll getan werden) und dann noch 1 Byte welches spezifiert welche Entität angesprochen wird (Noun, mit wem soll es getan werden), dann reicht auch: Start - Command - Noun - CRC - END Also überleg doch einfach mal was du konkret brauchst. gruß cyblord
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
Sorry. Ich habe keine Ahnung was du möchtest. Das Protokoll definiert welche Bytes hin und her übertragen werden und welche Information diese Bytes enthalten. Dabei ist das Medium egal und das hat auch nichts damit zu tun was der Empfänger dann mit diesen Infos macht. > Für diese Anwendung brauche ich keine TCP oder UDP Protokoll Stimmt. Und selbst wenn du das über Netzwerk machen würdest, dann müssten deine Netzwerkstacks diese Protokolle implementieren und du müsstest immernoch dein eigenes oben als Anwendungsschicht draufsetzen. > Der Server muss eigentlich bestimmte vordefnierte Funktionalität > ausführen. Dann musst du ihn so programmieren, dass er die Bytes via RS232 empfängt und gemäß deinem Protokoll auswertet. Dann weiß er was er tun soll und kann es tun. Wieso fängst du nicht mal so an, dass der PC genau 1 Byte sendet. Und je nach dem welches, tut der Server was bestimmtes. Das wär ein Anfang. gruß cyblord
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)
Maxim schrieb: > Wie kann ich eine Verbindung zwischen den Server und der Client > herstellen? Dachte du willst das per RS232 machen!? Im Visual Studio gibs die SerialPort Klasse, damit geht das. > 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) Wie ist eine erfolgreiche Verbindung definiert? Das PC Programm könnte pollen und sobald der Server antwortet weiß der PC dass die Verbindung da ist.
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.
Das ist ok so. Verbindung per RS232. PC Programm wird in VS geschrieben. Könntest du jetzt nochmal KONKRET dein Problem schildern? Was geht denn jetzt nicht? Wo hängts?
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
Schau dir mal das an: http://code.msdn.microsoft.com/windowsdesktop/SerialPort-brief-Example-ac0d5004
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();
}
Angehängte Dateien:
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
Thread beobachten
Seitenaufteilung abschaltenBitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.