Frage zu serieller Schnittstelle! DRINGEND Bitte!

[MiguelDERgroße (Gast)]

Also, hi leute, ich bin total verzweifelt, und hoffe ihr könnt mir 
helfen!
Ich möchte über die serielle Schnittstelle "einfach" daten senden!
Ich möchte Daten mittels C++ über die serielle Schnittstelle raussenden!
(genauer gesagt an den AVR)
ich definiere mir zum beispiel "h" und möchte dann eben dieses h 
raussenden und der andere PC oder eben der AVR soll das empfangen über 
die serielle! ich hab hier mal was das senden betrifft was 
zusammengebastelt!
es gibt zwar keine Fehler, aber ich weiß noch nicht ob es daten sendet, 
bzw. wie der andere das dann empfangen kann!
ich muss dazu sagen, dass ich was solche, schon etwas schwerere dinge 
nicht so bewandert bin in c++, deshalb eine praktische erklärung, das 
ich mir was vorstellen kann, wie ich das dann einbinde wäre nett!
ich hoffe ihr könnt mir weiterhelfen und ich werde bald in der lage sein 
"hallo" über die serielle rauszusenden und auf nem anderen pc zu 
empfangen!

#include <windows.h>
#include <stdio.h>
#include <mmsystem.h>
#include <cstdlib>
#include <iostream>
#include "Serial.h" //einlesen der Headerdatei
#include "Serial.cpp" //implementieren der .cpp datei

using namespace std;

CSerial COMPort; // für serielle übertragung auf den AVR

//Definieren der variabeln
unsigned char out_byte; 

int main(int argc, char *argv[])
{
   
   COMPort.Open(1,19200); // Hier wird der COM Port geöffnet erste Zahl = Comportnummer z.B. COM1, zweite Zahl = Übertragungsrate

          char h_str [10]; 
          h_str [1] = 'H';
          h_str [2] = 'A';
          h_str [3] = 'L';
          h_str [4] = 'L';
          h_str [5] = 'O';

          COMPort.SendData(h_str, sizeof(h_str)); // SendData( Daten die gesendet werden sollen, größe der Daten) beispiel SendData(h_str,2) Sendet die ersten beiden FElder von h_str
          
          //printf("%s",h_str);
          //getchar();
    
    COMPort.Close();
    return EXIT_SUCCESS;

}

Beste grüße

Miguel

[yalu (Gast)]

Ob das, was in Serial.h und Serial.cpp richtig ist, weißt du besser als
die Leser hier. Aber auch dein main enthält noch Fehler:

Arrays beginnen immer mit dem Index 0. h_str besteht auso aus den
Elementen h_str[0], h_str[1], ..., h_str[9]. Deswegen müssen die
Zuweisungen folgendemaßen aussehen:

          h_str [0] = 'H';
          h_str [1] = 'A';
          h_str [2] = 'L';
          h_str [3] = 'L';
          h_str [4] = 'O';

sizeof(h_str) ist 10, weil h_str aus 10 Elementen der Größe 1 besteht.
Du möchtest aber wahrscheinlich nicht 10 Zeichen senden, sondern nur 5,
nämlich die Buchstaben des Worts "HALLO". Also muss es heißen

          COMPort.SendData(h_str, 5);

Vielleicht funktioniert die Sache damit ja schon. Hast du einen zweiten
PC, mit dem du die Daten empfangen und anzeigen lassen kannst? Wenn
nicht, kannst du auch an der Schnittstelle des PC die Tx- und
Rx-Leitungen miteinander verbinden (Loopback) und in dein obiges
Programm nach COMPort.SendData() geeignete Anweisungen zum Empfang von
Daten einfügen. Wenn du alles richtig gemacht hast, müssten du damit die
gesendeten Daten wieder zurückgelesen werden.

Um die Tx- udn Rx-Leitungen zu verbinden, steckst du einfach eine
Sub-D-Buchse, bei der du Pin 2 und Pin 3 mit etwas Lötzinn überbrückt
hast, in den COM-Port des PC.

[HildeK (Gast)]

Es könnte auch sein, das COM1 mit der Nummer '0' geöffnet werden muss.

[MiguelDERkleine (Gast)]

Das klingt gut!
weißt du zufällig wie ich das empfangen einbaue?
bin mit dem latein am ende!

lg

Miguel

[Sven P. (Gast)]

MiguelDERgroße wrote:

#include "Serial.cpp" //implementieren der .cpp datei

Das ist falsch, Programmodule werden NIEMALS mit 'include' 
eingebunden. Include immer nur mit Header-Dateien, für den Rest gibt es 
den Linker.

          char h_str [10];
          h_str [1] = 'H';
          h_str [2] = 'A';
          h_str [3] = 'L';
          h_str [4] = 'L';
          h_str [5] = 'O';

Abgesehen davon, dass ein Nullbyte fehlt, sofern das mal ein String 
werden wollte, kann man das auch als 'char *h_str = "HALLO";' schreiben.

          COMPort.SendData(h_str, sizeof(h_str));

sizeof(h_str) ist in deinem Fall aber 10.

          //printf("%s",h_str);

Das wird schiefgehen, da das besagte Nullbyte fehlt.

[MiguelDERkleine (Gast)]

#include <windows.h>
#include <stdio.h>
#include <mmsystem.h>
#include <cstdlib>
#include <iostream>
#include "Serial.h" //einlesen der Headerdatei
#include "Serial.cpp" //implementieren der .cpp datei 
--> was meinst du mit nicht mit include einbinden? wie sonst?was meinst du
mit linker genau?


using namespace std;

CSerial COMPort; // für serielle übertragung auf den AVR

unsigned char out_byte;

int main(int argc, char *argv[])
{
        COMPort.Open(1,19200);
        char h_str[5];
        strcpy (&h_str[0], "HALLO");
        COMPort.SendData(h_str, sizeof(h_str));

        std::string str ("asd");
        COMPort.SendData (str.c_str(), str.length()+1);
        str = "HALLO";
       
        printf("%s",h_str);
        getchar();

        COMPort.Close();
        return EXIT_SUCCESS;

}

hoffe ich habe jetzt das mit dem nullbyte beseitigt, sonst weiß ich 
nicht genau was de meinst! das mit .cpp einbinden, hab ich eh oben im 
programm geschrieben versteh ich net ganz was du meinst!
Noch eine frage, da du dich anscheinend ganz gut auskennst!
wie kann ich das dann von nem anderen pc einlesen?

[Sven P. (Gast)]

MiguelDERkleine wrote:
>

> #include "Serial.cpp" //implementieren der .cpp datei
> --> was meinst du mit nicht mit include einbinden? wie sonst?was meinst
> du
> mit linker genau?
>

'Linker' ist eigentlich recht eindeutig, befrag mal dein Handbuch.

>         COMPort.Open(1,19200);
>         char h_str[5];
>         strcpy (&h_str[0], "HALLO");
'&h_str[0]' ist quasi gleich 'h_str'. Aber kannst du mir sagen, wo das 
Nullbyte hin soll?


>         std::string str ("asd");
Hatten wir weiter oben nicht 'using namespace std'?


> Noch eine frage, da du dich anscheinend ganz gut auskennst!
> wie kann ich das dann von nem anderen pc einlesen?
Ich kann ein bisschen C++, ein bisschen mehr C und unter Linux les ich 
ein Byte von einer Schnittstelle genauso, wie ich eines aus einer Datei 
lese.