Verbindung über RS232

[Robert m. (robertsl)]

Hallo,

ich soll Daten über RS232 senden dafür muss ich die UART-Konfiguration 
in C schreiben.
weiss jemand wie das geht wäre ich dankbar

danke Robert

[Frank M. (ukw) (Moderator)]

Robert meiss schrieb:

> ich soll Daten über RS232 senden dafür muss ich die UART-Konfiguration
> in C schreiben.

http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Der_UART

[Rudi D. (rulixa)]

In der unentbehrlichen Dok von Atmel steht dies für tiny2313 auf Seite 
121 und 122.

[Martin (Gast)]

Rudi D. schrieb:
> In der unentbehrlichen Dok von Atmel steht dies für tiny2313 auf Seite
> 121 und 122.

Es geht aber nicht um einen Atmel ;)

Robert meiss schrieb:
> weiss jemand wie das geht

Ja.

[heinzhorst (Gast)]

Etwas mehr Info bitte. Welcher Controller? Taktfrequenz? Baudrate?

[robertsl (Gast)]

ja hast du recht es geht´s nur um ein programm zu schreiben damit 
Character über RS232 zu senden

[robertsl (Gast)]

Baudrate 9600

[robertsl (Gast) (Gast)]

Ach ja, und das Program ist natürlich nicht für einen uC, sondern für 
einen Dell Inspirion Notebook mit Linux drauf. (Ich dachte das sei klar)

[robertsl (Gast)]

nein hat damit nicht zu tun

[Rufus Τ. F. (rufus)]

robertsl (Gast) schrieb:
> (Ich dachte das sei klar)

Und woher bitte soll das klar sein? Du überschätzt unsere Glaskugeln.

[michl (Gast)]

42

[Sebbel (Gast)]

Dann stell doch bitte deine Frage ins richtige Forum z.B. 
PC-Programmierung und nicht µC und Elektronik.

Zu deiner Frage: Schau mal bei V-Studio nach. Da gibt es bereits fertige 
Bib. elemente für die serielle Übertragung.

Gruß

[serial programmer (Gast)]

na dann arbeite mal dies hier durch (falls du in C schreiben möchtest, 
meine Glaskugel versinkt auch im Nebel...):

http://tldp.org/HOWTO/Serial-Programming-HOWTO/

[Rufus Τ. F. (rufus)]

Sebbel schrieb:
> Dann stell doch bitte deine Frage ins richtige Forum z.B.
> PC-Programmierung und nicht µC und Elektronik.

Was meinst Du, warum und wohin ich das hier verschoben habe?

[Robert m. (robertsl)]

Hallo,

danke für die Hilfe ich habe das Probleme gelöst mein Programm sieht so 
aus

#include <conio.h>
#include <stdio.h>
#include "ComTools.h"


#define   COM8    7

#define   ESC      27



int main(int argc, char* argv[])

{

int send;
int empf;
char chara[65];

  ComInit();

  ComOpen(COM8,9600,P_NONE,S_1BIT,D_8BIT);
    

  printf("\Die beide rechner sind jetzt Verbunden");
  printf("\nAbbruch mit ESC. \n\n");

for(;;) 
  {
    if(kbhit())    // Wurde eine Taste gedrückt
     {
      send=getch();
      if(send==ESC)break;   // Drücken Sie die Taste ESC zum Abbruch
      ComWrite(COM8,send);
      }        
    
  empf=ComRead(COM8,chara,64);  //  Empfangene Character  auf      
                                             Konsole einlesen
  chara[empf]=0;
  printf("%s",chara);
       
  Sleep(50);   // Wenn keine Zeichen im Buffer sind dann warten
      
    }    
  
  ComClose(COM8);
  ComExit();
  
return 0;
getch ();
}

dazu muss ComTools.cpp vor definiert das Code sieht so aus

#include  <windows.h>
#include  <memory.h>
#include  "ComTools.h"

#define   MAX_COM_PORTS  8

#ifdef    UNICODE
#define   Z(a)    L##a
#else
#define   Z(a)    a
#endif


static HANDLE  hComFile[MAX_COM_PORTS];
static BOOL    bIsOpen  [MAX_COM_PORTS];

//*****************************************************************************
//*
//*    ComInit
//*
//*****************************************************************************
int ComInit()
{
return 1;
}

//*****************************************************************************
//*
//*    ComExit
//*
//*****************************************************************************
int ComExit()
{
int  i;

  for(i=0;i<MAX_COM_PORTS;i++)
    {
    if(!bIsOpen[i])continue;
    ComClose(i);
    }

return 1;
}

//*****************************************************************************
//*
//*    ComOpen
//*
//*****************************************************************************
//  Öffnet eine serielle Verbindung
//  Nr      : Ist die Nummer des Com-Ports (0=COM1 1=COM2 ...)
//  Baud    : Ist die Bautrate
//  Parity    : 0 = kein Parity Bit
//          1 = gerade
//          2 = ungerade
//          3  = immer 0
//          4 = immer 1
//  Stopbits  : 0 = Ein Stopbit
//          1 = Ein/einhalb Stopbits
//          2 = Zwei Stopbits
//  Bits    : 0 = 7 Datenbits
//          1 = 8 Datenbits
//          7 = 7 Datenbits
//          8 = 8 Datenbits
//  Ergibt 1 wenn eine Schnittstelle geöffnet wurde
int ComOpen(unsigned Nr,int Baud,int Parity,int Stopbits,int Databits)
{
static const int  iPMode[]={NOPARITY,EVENPARITY,ODDPARITY,SPACEPARITY,MARKPARITY};
static const int  iSMode[]={ONESTOPBIT,ONE5STOPBITS,TWOSTOPBITS,ONESTOPBIT};
TCHAR        cName[]=Z("\\\\.\\COM1");
HANDLE        hFile;
COMMTIMEOUTS    sTo;
DCB          sDcb;



  if(Nr>=MAX_COM_PORTS)return 0;
  if(bIsOpen[Nr])return 0;


  cName[7]='1'+Nr;

     hFile= CreateFile(cName,GENERIC_READ|GENERIC_WRITE,0,0,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,0);
  if(hFile==INVALID_HANDLE_VALUE)
    {
    hFile=0;
    return 0;
    }

  if(Databits==7)Databits=0;


  memset(&sDcb,0,sizeof(sDcb));
  sDcb.DCBlength=sizeof(sDcb);
  sDcb.BaudRate       = Baud;
  sDcb.fParity        = (Parity!=0)? TRUE:FALSE;
  sDcb.fBinary        = TRUE;
  sDcb.Parity         = iPMode[Parity];
  sDcb.StopBits       = iSMode[Stopbits&3];
  sDcb.fOutxCtsFlow   = FALSE;
  sDcb.fOutxDsrFlow   = FALSE;
  sDcb.fDtrControl  = DTR_CONTROL_ENABLE;
  sDcb.fRtsControl  = RTS_CONTROL_ENABLE;
  sDcb.fDsrSensitivity= FALSE;
  sDcb.fAbortOnError  = FALSE;
  sDcb.ByteSize       = (Databits)? 8:7;

  if(!SetCommState(hFile,&sDcb))
    {
    CloseHandle(hFile);
    return 0;
    }


  sTo.ReadIntervalTimeout       = MAXDWORD;     // 0 ms Read-Tomeout
  sTo.ReadTotalTimeoutMultiplier = 0;
  sTo.ReadTotalTimeoutConstant   = 0;
  sTo.WriteTotalTimeoutMultiplier= 12000/Baud+1;  // ? ms Write timeout per byte
  sTo.WriteTotalTimeoutConstant  = sTo.WriteTotalTimeoutMultiplier+1;
  if(!SetCommTimeouts((HANDLE)hFile,&sTo))
    {
    CloseHandle(hFile);
    return 0;
    }


  hComFile[Nr]=hFile;
  bIsOpen [Nr]=TRUE;


return 1;
}



//*****************************************************************************
//*
//*    ComClose
//*
//*****************************************************************************
//  Schließt eine serielle Verbindung
//  Nr  : Ist die Nummer des Com-Ports (0=COM1 1=COM2 ...)
//  Ergibt 1 wenn eine Schnittstelle geschlossen wurde
int  ComClose(unsigned Nr)
{

  if(Nr>=MAX_COM_PORTS)return 0;
  if(!bIsOpen[Nr])return 0;

  CloseHandle(hComFile[Nr]);
  hComFile[Nr]=0;
  bIsOpen [Nr]=FALSE;


return 1;
}


//*****************************************************************************
//*
//*    ComDetectPorts
//*
//*****************************************************************************
//  Speichert in iCount die Anzahl der gefundenen COM Ports
//  In pMode werden die Portzustänte gespeichert
//    0 = Nicht vorhanden
//    1 = Vorhanden
//    2 = Vorhanden und von einem anderen Programm benutzt
//    pMode[0] für COM1
//    pMode[1] für COM2
//    ...
//  iMaxPorts ist die Anzahl der Ports die gescannt werden.
void ComDetectPorts(int &iCount,int *pMode,int iMaxPorts)
{
int    i;
TCHAR  cName[]=Z("\\\\.\\COM1");
HANDLE  hCom;



  for(i=0;i<iMaxPorts;i++)
    {
    if(i<MAX_COM_PORTS && bIsOpen[i])
      {
      pMode[i]=1;
      iCount++;
      continue;
      }

    cName[7]='1'+i;
    hCom=CreateFile(cName,GENERIC_WRITE|GENERIC_READ,0,0,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,0);
    if(hCom==INVALID_HANDLE_VALUE)
      {
      if(GetLastError()==ERROR_FILE_NOT_FOUND)
        {
        pMode[i]=0;
        continue;
        }
      else{
        pMode[i]=2;
        iCount++;
        continue;
        }
      }

    CloseHandle(hCom);
    pMode[i]=1;
    iCount++;
    }

}

//*****************************************************************************
//*
//*    ComRead
//*
//*****************************************************************************
//  Ein Zeichen lesen
//  Nr    : Ist die Nummer des Com-Ports (0=COM1 1=COM2 ...)
//  Ergibt -1 wenn nichts gelesen wurde sonst das Zeichen
int ComRead(unsigned Nr)
{
unsigned char   c;
DWORD      dwCount;


  if(Nr>=MAX_COM_PORTS)return -1;
  if(!bIsOpen[Nr])return -1;

  if(!ReadFile(hComFile[Nr],&c,1,&dwCount,0))return -1;
  if(dwCount!=1)return -1;


return c;
}

//*****************************************************************************
//*
//*    ComRead
//*
//*****************************************************************************
//  Mehrere Zeichen lesen
//  Nr    : Ist die Nummer des Com-Ports (0=COM1 1=COM2 ...)
//  Buffer  : Buffer in dem die Zeichen gespeichert werden
//  Max    : Maximale Anzahl der zu lesenden Zeichen
//  Ergibt die Anzahl der gelesenen Zeichen
int ComRead(unsigned Nr,void *Buffer,int Max)
{
DWORD  dwCount;


  if(Nr>=MAX_COM_PORTS)return 0;
  if(!bIsOpen[Nr])return 0;

  ReadFile(hComFile[Nr],Buffer,Max,&dwCount,0);

return dwCount;
}


//*****************************************************************************
//*
//*    ComWrite
//*
//*****************************************************************************
//  Ein Zeichen senden
//  Nr    : Ist die Nummer des Com-Ports (0=COM1 1=COM2 ...)
//  Zeichen  : Ist das Zeichen das gesendet werden soll.
//  Ergibt die Anzahl der gesendeten Zeichen
int ComWrite(unsigned Nr,int Zeichen)
{
DWORD      dwCount;


  if(Nr>=MAX_COM_PORTS)return 0;
  if(!bIsOpen[Nr])return 0;

  WriteFile(hComFile[Nr],&Zeichen,1,&dwCount,0);


return dwCount;
}

//*****************************************************************************
//*
//*    ComWrite
//*
//*****************************************************************************
//  Mehrere Zeichen schreiben
//  Nr    : Ist die Nummer des Com-Ports (0=COM1 1=COM2 ...)
//  Buffer  : Buffer in dem die Zeichen gespeichert werden
//  Count  : Anzahl der zu sendenden Zeichen
//  Ergibt die Anzahl der gesendeten Zeichen
int  ComWrite(unsigned Nr,void *Buffer,int Count)
{
DWORD      dwCount;


  if(Nr>=MAX_COM_PORTS)return 0;
  if(!bIsOpen[Nr])return 0;

  WriteFile(hComFile[Nr],Buffer,Count,&dwCount,0);

return dwCount;
}



//*****************************************************************************
//*
//*    ComGetReadCount
//*
//*****************************************************************************
//  Ergibt die Anzahl der Bytes die im Lesepuffer der Schnittstelle sind
//  Nr    : Ist die Nummer des Com-Ports (0=COM1 1=COM2 ...)
//  Ergibt die Anzahl der Bytes im Buffer
int ComGetReadCount(unsigned Nr)
{
COMSTAT    sComStat;
DWORD    dwErrorFlags;


  if(Nr>=MAX_COM_PORTS)return 0;
  if(!bIsOpen[Nr])return 0;

  dwErrorFlags=0;

  if(!ClearCommError(hComFile[Nr], &dwErrorFlags, &sComStat))return 0;

return sComStat.cbInQue;
}

//*****************************************************************************
//*
//*    ComGetWriteCount
//*
//*****************************************************************************
//  Ergibt die Anzahl der Bytes die im Schreibpuffer der Schnittstelle sind
//  Nr    : Ist die Nummer des Com-Ports (0=COM1 1=COM2 ...)
//  Ergibt die Anzahl der Bytes im Buffer
int ComGetWriteCount(unsigned Nr)
{
COMSTAT    sComStat;
DWORD    dwErrorFlags;


  if(Nr>=MAX_COM_PORTS)return 0;
  if(!bIsOpen[Nr])return 0;

  dwErrorFlags=0;

  if(!ClearCommError(hComFile[Nr], &dwErrorFlags, &sComStat))return 0;

return sComStat.cbOutQue;
}

Robert