Problem Datenleitungen RTS/DTR

Weiß jemand ungefähr wo der Fehler liegen kann?

Das sind einfach zuwenige Infos, um deine Frage zu beantworten. Du 
müsstest zumindest noch folgende Infos liefern:

1) was ist angeschlossen und wie
2) werden rts und cts vom angeschlossenen Gerät überhaupt benutzt?
3) ein vollstänsiges Programm (oben fehlt quasi alles, was das Empfangen 
etc. erledigt...
4) hast du mal die Pins 2 und 3 am 9poligen seriellen Steckvverbinder 
gebrückt und dann was gesendet? Kommt dann was an?

MRK schrieb:

> Kann vielleicht jemand mir
> Tipps geben .

Wenn das Gepostete der ganze Code sein soll, dann ist er kompletter 
Mist.

Du holst die Liste der verfügbaren Ports und fummelst dann sofort an den 
Portpins rum. Irgendwie fehlen dazwischen zwei Schritte, nämlich das 
Auswählen des gewünschen Ports und vor allem auch das Öffnen dieses 
Ports.

Mit einem nicht geöffneten SerialPort kann man nix machen, auch nicht an 
den Pins rumfummeln.

Nikolaus schrieb:
> Weiß jemand ungefähr wo der Fehler liegen kann?

Ungefähr in der Mitte. Oder am Ende. Oder überhaupt.
Wo ist das richtige Programm?

Hallo MRK,

wenn du nicht sicher bist, ob deine Gegenstelle die Steuerleitungen 
benutzt dann lasse sie so wie sie sind und probiere es aus. Sofern die 
Gegenstelle Steuerleitungen braucht muß du die Entsprechenden freigeben 
mit "serialPort1.xxxEnable = true". Dann müssen diese Leitungen aber 
auch im Kabel vorhanden sein und es muß der richtige Kabeltyp 
(Verbindungskabel(1:1) oder NullModemkabel(gekreuzt)) verwendet sein.

Hier ein kleines VC# Beispiel, mit dem alle empfangenen Zeichen aus dem 
Empfangspuffer in einen String gelesen werden:

----------------------------------------------------------
using System.IO;

      serialPort1.PortName = "COM1";

// Zugriffe auf die Schnittstelle ermöglichen
  serialPort1.Open();

// Für empfangene Zeichen
  String sIn;

// Falls etwas empfangen
  if(serialPort1.BytesToRead)
// Alle Zeichen in einen String lesen
  { sIn = serialPort1.ReadExisting();

// mache irgend etwas mit den empfangenen Zeichen

// Am Ende den Port schließen
     serialPort1.Close();
----------------------------------------------------------

Verwendet wird eine Drei-Draht-Verbindung (TXD,RXD,GND) ohne 
Steuerleitungen und da zwei DEE's(DatenEndEinrichtung) verbunden sind, 
ist das Kabel gekreutzt.

Gruß. Tom

Felix Adam schrieb:
> Das sind einfach zuwenige Infos, um deine Frage zu beantworten. Du
> müsstest zumindest noch folgende Infos liefern:

> 2) werden rts und cts vom angeschlossenen Gerät überhaupt benutzt?

Ja diese Dtaenleitungen werden benutzt


> 4) hast du mal die Pins 2 und 3 am 9poligen seriellen Steckvverbinder
> gebrückt und dann was gesendet? Kommt dann was an?

ja die Pins, 2 und 3 habe ich miteinande verbunden und auch Daten 
empfangen.


public partial class Form1 : Form
    {
        // Globale Variablen
        //SerialPort serialPort1 = new SerialPort("COM6", 1200, 
Parity.None, 8, StopBits.One);     //Initialisierung



        byte[] SendData  = new byte[256];
        byte[] EmpfData  = new byte[256];



        //====================================================================== 
================


        void SendDataAdd(byte[] SendData, byte wert) {
            SendData[SendData[0]+1]= wert;
            SendData[0]++;

         serialPort1.RtsEnable = true;      //????????????????????
            serialPort1.RtsEnable = false; //?????????????????????
            serialPort1.DtrEnable = true;  //?????????????????????
            serialPort1.DtrEnable = true;  //?????????????????????
        }

        //====================================================================== 
=============

..................................................

        //====================================================================== 
================


        public Form1()
        {
            InitializeComponent();
            getAvailablePorts();
        }

        void getAvailablePorts()
        {

            String[] ports = SerialPort.GetPortNames();
            cbCOM.Items.AddRange(ports);


        }


     //====================================================================== 
================


        private void Form1_Load(object sender, EventArgs e)
        {



            if (!serialPort1.IsOpen)
            {
                serialPort1.Open();

                txtBox.Text = "wird open";
            }
            else
            {
                txtBox.Text = "Open";

            }
            serialPort1.ReceivedBytesThreshold = 1;



        }



        //====================================================================== 
================


        private void cbCOM_SelectedIndexChanged(object sender, EventArgs 
e)
        {
            SendData[0] = 0;
         }

        //====================================================================== 
================


        private void btAbfrage_Click(object sender, EventArgs e)
        {
            int Kopflaenge = 10;
            SendData[0] = 0;                        // Löschen (anz=0)



            for (int i = 0; i < Kopflaenge; i++)
            {
                SendDataAdd(SendData, 0xFF);        //
            }

            .......................


            EmpfData[0] = 0;
            timer1.Interval = 1000;
            timer1.Enabled= true;


        }

        //====================================================================== 
================


        //Daten empfangen
        private void serialPort1_DataReceived(object sender, 
System.IO.Ports.SerialDataReceivedEventArgs e)
        {



            int count = serialPort1.BytesToRead;
                byte[] ByteArray = new byte[count];

                serialPort1.Read(ByteArray, 0, count);

                int anz;

                for (int i = 0; i < count; i++)

                {
                    anz = EmpfData[0];
                    EmpfData[EmpfData[0] + 1] = ByteArray[i];
                    EmpfData[0]++;
                }
        }



        //====================================================================== 
================


        private void timer1_Tick(object sender, EventArgs e)
        {
            int anz;


            anz = EmpfData[0];
        }



        //====================================================================== 
================


        private void btEnde_Click(object sender, EventArgs e)
        {

            serialPort1.Close();
            this.Close();
        }

        private void label1_Click(object sender, EventArgs e)
        {

        }



    }
}


Lg

ich bin für jede Antwort dankbar...

Hallo,

ich glaube mein Problem liegt im Verständnis. Ich weiss nicht genau wann 
ich RTSenable bzw DTRenable auf false oder auf true setzen soll und was 
da genau geschieht?

Nikolaus schrieb:

> ich glaube mein Problem liegt im Verständnis. Ich weiss nicht genau wann
> ich RTSenable bzw DTRenable auf false oder auf true setzen soll und was
> da genau geschieht?

Tja, das hängt genau nur davon ab, wie die Übertragung von der 
"gegnerischen" Seite behandelt wird, ist also ein einfaches Problem der 
Vereinbarung zwischen den Kommunikationspartnern.

Es gibt da die HW-Handshake-Varianten "7wire", dann spielt sowohl RTS 
als auch DTR eine Rolle und "5wire", dann spielt nur RTS eine Rolle. 
Allerdings ist es in beiden Fällen nicht nötig (oder sogar: möglich), 
mit eigener Software was sinnvolles beizutragen, weil das Windows-API 
das alles viel effizienter (und sehr viel weniger Timing-kritisch) 
bereits auf Treiber-Ebene abhandeln kann. Man muss dazu einfach nur die 
Schnittstelle passend initialisieren.

Und ja: auch die unsäglich miese Implementierung namens SerialPort, die 
MS da die Frechheit hatte mit .Net2 zu veröffentlichen (und bis heute 
nicht wirklich gefixt hat), kann das. Irgendwie... Notdürftig...

Man muss den völlig kranken Scheiss einfach nur richtig benutzen, dann 
wird es im Normalfall auch meistens funktionieren (nur das war wohl auch 
das Designziel der komplett unfähigen Programmierer, die es verbrochen 
haben). Diese idiotische .Net-Implementierung fasst jedenfalls erstmal 
die zwei denkbaren Varianten des Hardware-Handshake zu einer zusammen 
(Handshake.Hardware). Das meint eigentlich 7wire. Also ist, bei Absenz 
der gegnerischen Ansteuerung von DTR, das lokale DSR physisch, durch 
entsprechendes Kabel, mit dem lokalen DTR zu verbinden und das lokale 
DTR auf "true" zu setzen, womit effektiv nur noch die Flußsteuerung über 
CTS/RTS aktiv ist, also die 5wire-Variante.

Die wird dann (zumindest meistens) korrekt über das tatsächlich 
fehlerfrei funktionierende Win32-API umgesetzt. Tatsächlich hat aber die 
Implementierung von SerialPort derart viele Macken, dass man eigentlich 
nur davon abraten kann, diesen perversen Scheiss überhaupt zu benutzen, 
sobald es um mehr geht, als nur ab und an ein paar Bytes über die 
RX-TX-Verbindung zu nudeln...

Hallo,

also hierbei sollen Daten von modem an dem PC und umgekehrt gesendet und 
empfangen werden. Dabei ist das Modem über die serielle Schnittstelle an 
dem PC angeschlossen. Es wird jeweils ene Datenleitung (RXD/TXD) dür das 
Empfangen bzw Senden verwendet. Wenn ich jetzt RTSenable 
(Sendebereitschaft) auf true setze, wer sendet und wer empfängt Daten? 
Waspassiert beim false?

Karl H. schrieb:

> Heutzutage wird DTR meistens ignoriert.

heißt das, dass ich diesen Teil aus meinem Programm weg machen soll

 serialPort1.DtrEnable = true;  //?????????????????????
 serialPort1.DtrEnable = true;  //?????????????????????

VG

Nikolaus schrieb:
>> Heutzutage wird DTR meistens ignoriert.
>
> heißt das, dass ich diesen Teil aus meinem Programm weg machen soll
>
>  serialPort1.DtrEnable = true;  //?????????????????????
>  serialPort1.DtrEnable = true;  //?????????????????????

Muss nicht sein. Wenn es benutzt wird, brauchst du das, wenn es 
ignoriert wird schadet es nicht.

Wenn du dann mal auf eine Gegenstelle striffst, die die Statussignale 
auswertet, musst du erst den Fehler suchen und dann die richtige 
Verwendung wieder reinbasteln.

Georg