ttyUSB0 Einstellungen

Sidebar Sidebar
Upgrade 3CX to v18 and get it hosted free!
T

tigerschaf1

Neuer User
Mitglied seit
15 Mrz 2010
Beiträge
19
Punkte für Reaktionen
0
Punkte
0
Hallo zusammen,

ich bin seit einiger Zeit drüber, meine Wechselrichter mittels Fritz-Box (freetz) über ein RS232 Converter auszulesen. Über meinen XP-Rechner klappt diese Wunderbar. Ich bekomme leider die Einstellungen der Schnittstelle unter Linux nicht zum laufen.
Nach dem Senden der ersten 10 Bytes bekomme ich eine Antwort der Wechselrichter, wobei hier das erste Byte fehlt. Anschließend kann ich über mein c-Programm keinen Bytestrom mehr senden.
Nur das Ein/Ausstecken des Adapters, bzw. ein "echo hallo > /dev/ttyUSB0"
hilft weiter.
Ich habe schon alles versucht, komme aber leider nicht dahinter, was mir fehlt.

Hier sind die Einstellungen, die unter Windows von dem Programm des Herstellers durchgeführt werden:

Code: 
IOCTL_SERIAL_SET_BAUD_RATE: Set baud rate
Baud Rate=19200
IOCTL_SERIAL_SET_BAUD_RATE: Set baud rate
IOCTL_SERIAL_SET_RTS: Set RTS
IOCTL_SERIAL_SET_RTS: Set RTS
IOCTL_SERIAL_CLR_DTR: Clear DTR
IOCTL_SERIAL_CLR_DTR: Clear DTR
IOCTL_SERIAL_SET_LINE_CONTROL: Set line control
WordLength=8
StopBits=1 stop bit
Parity=No parity
IOCTL_SERIAL_SET_LINE_CONTROL: Set line control
IOCTL_SERIAL_SET_CHARS: Set special characters
EofChar=0x1a
ErrorChar=0x0
BreakChar=0x0
EventChar=0x1a
XonChar=0x11
XoffChar=0x13
IOCTL_SERIAL_SET_CHARS: Set special characters
IOCTL_SERIAL_SET_HANDFLOW: Set handshake information
ControlHandShake=0
FlowReplace=64
XonLimit=1024
XoffLimit=1024
IOCTL_SERIAL_SET_HANDFLOW: Set handshake information
IOCTL_SERIAL_CLR_RTS: Clear RTS
IOCTL_SERIAL_CLR_RTS: Clear RTS
IOCTL_SERIAL_SET_TIMEOUTS: Set timeouts
ReadIntervalTimeout=4294967295
ReadTotalTimeoutMultiplier=4294967295
ReadTotalTimeoutConstant=4294967294
WriteTotalTimeoutMultiplier=0
WriteTotalTimeoutConstant=200
IOCTL_SERIAL_SET_TIMEOUTS: Set timeouts
IOCTL_SERIAL_SET_WAIT_MASK: Set current event mask
WaitMask=RXCHAR: Any Character received, RXFLAG: Received certain character, CTS: CTS changed state, DSR: DSR changed state, RLSD: RLSD changed state, BREAK: BREAK received, ERR: Line status error occurred, RING: Ring signal detected
IOCTL_SERIAL_SET_WAIT_MASK: Set current event mask
IOCTL_SERIAL_SET_QUEUE_SIZE: Set queue size
InSize=4096
OutSize=2048
IOCTL_SERIAL_SET_QUEUE_SIZE: Set queue size
IOCTL_SERIAL_SET_WAIT_MASK: Set current event mask
WaitMask=None
IOCTL_SERIAL_SET_WAIT_MASK: Set current event mask
IOCTL_SERIAL_CLR_DTR: Clear DTR
IOCTL_SERIAL_CLR_DTR: Clear DTR
IOCTL_SERIAL_PURGE: Purge requests
Purge mask=RXABORT: Receive buffer, RXCLEAR: Write buffer
IOCTL_SERIAL_PURGE: Purge requests
IOCTL_SERIAL_PURGE: Purge requests
Purge mask=TXABORT: Read requests, TXCLEAR: Write requests
IOCTL_SERIAL_PURGE: Purge requests

Unter Windows setze ich nur folgendes:

Code: 
mode com1 baud=19200 data=8 parity=n octs=off odsr=off xon=off dtr=on rts=off to=off

Status von Gerät COM1:
----------------------
Baudrate: 19200
Parität: None
Datenbits: 8
Stoppbits: 1
Zeitlimit: OFF
XON/XOFF: OFF
CTS-Handshaking: OFF
DSR-Handshaking: OFF
DSR-Prüfung: OFF
DTR-Signal: ON
RTS-Signal: OFF


Hier meine Einstellungen des ttyUSB0 auf Linux:

Code: 
speed 19200 baud; rows 24; columns 80;
intr = ^C; quit = ^\; erase = ^?; kill = ^U; eof = <undef>; eol = <undef>; eol2 = <undef>; swtch = <undef>;
start = ^Q; stop = ^S; susp = ^Z; rprnt = ^R; werase = ^W; lnext = ^V; flush = ^O; min = 8; time = 50;
-parenb -parodd cs8 -hupcl -cstopb cread clocal -crtscts
-ignbrk -brkint -ignpar -parmrk -inpck -istrip -inlcr -igncr -icrnl ixon -ixoff -iuclc -ixany -imaxbel
opost -olcuc -ocrnl onlcr -onocr -onlret -ofill -ofdel nl0 cr0 tab0 bs0 vt0 ff0
-isig -icanon iexten -echo -echoe echok -echonl -noflsh -xcase -tostop -echoprt echoctl echoke

Hier der Ausschnitt des C-Codes, mit dem ich das alles setze:

Code: 
inittty()
{
ffd = fopen(devicename,"r+");
if(!ffd){
printf("fil_des.c -> open_file -- open() return Wert == -1 : ABBRUCH\n");
exit(0);
}
read_fd = fileno( ffd );
setbuf ( ffd , NULL );

fcntl(read_fd, F_SETFL, FASYNC | O_NONBLOCK );

bzero(&newtio, sizeof(newtio)); /* clear struct for new port settings */
tcgetattr(read_fd,&oldtio);
newtio=oldtio;

newtio.c_cflag &= ~PARENB;
newtio.c_cflag &= ~CSTOPB;
newtio.c_cflag &= ~CSIZE;
newtio.c_cflag = BAUDRATE | CS8;
newtio.c_cflag |= CLOCAL | CREAD;

newtio.c_oflag |= OPOST;
newtio.c_oflag |= ONLCR;

newtio.c_lflag &= ~(ICANON|ECHOE| ECHO|ISIG );

newtio.c_cflag &= ~CRTSCTS;

newtio.c_iflag &= ~(INPCK | ISTRIP|PARMRK|IGNPAR);

newtio.c_cc[VSTART] = 0x11;
newtio.c_cc[VSTOP] = 0x13;
newtio.c_cc[VEOF] = 0x00;
newtio.c_cc[VMIN] = 8;
newtio.c_cc[VTIME] = 50;


tcflush(read_fd, TCIFLUSH);
tcflow(read_fd, TCOOFF);
int r= tcsetattr(read_fd,TCSAFLUSH,&newtio);

int dtr_bits = TIOCM_DTR;
int rts_bits = TIOCM_RTS;
int le_bits = TIOCM_LE;
int led_bits = N_TTY;
ioctl(read_fd,TIOCMBIS,&le_bits);
ioctl(read_fd,TIOCMBIS,&dtr_bits);
ioctl(read_fd,TIOCMBIS,&rts_bits);
ioctl(read_fd,TIOCSETD,&led_bits);
}
Kann mir hier jemand weiterhelfen, bin echt am verzweifeln.

Danke
 
Zuletzt bearbeitet:
Einige Stellen in dem Programm sind zwar seltsam, aber nicht unbedingt problematisch.

Ohne den Rest kann man auch nicht gut sagen, ob das Problem hier liegt oder anderswo.

UNd verwende CODE-Tages für solche Inhalte.
 
Hi,

hier der gesamte Code.

Code: 
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h> 
#include <fcntl.h>
#include <sys/signal.h>
#include <sys/types.h>
#include <time.h>
#include <sys/ioctl.h>

#include <string.h>
#include <sys/time.h>

#pragma hdrstop


//#define TRUE 1
//#define FALSE 0 

//definition------------------------------------------------------------------------------------------------------
int fd,  read_fd, wait_flag,rv,gelbytes;

//char devicename[80] = "/dev/null";  
char devicename[80] = "/dev/ttyUSB0";
FILE *ffd;
#define BAUDRATE B19200

USHORT	crc_hl,crc_h,crc_l;

struct s_senden	{	char address;
			char command;
			char b2;
			char b3;
			char b4;
			char b5;
			char b6;
			char b7;
			unsigned char  crc_lo;
			unsigned char  crc_hi;
	    	};
	    	
struct s_empfangen{	char transmission;
										char global;
										unsigned char b[4];
										unsigned char  crc_lo;
										unsigned char  crc_hi;
	     						};

float v_float,v_float1,v_float2;
struct s_empfangen empfangen;		 
struct s_senden senden;
struct timeval timeout;
fd_set readfds;

void signal_handler_IO (int status);   /* definition of signal handler */
int initialize_tty();
float wertelesen();
float tofloat();

time_t jetzt;
struct tm *zgr;
char zeit[80];
		

//main------------------------------------------------------------------------------------------------------

int  main(int argc, char** argv) 
{ 

			fd=initialize_tty();
			
			
			fflush(ffd);
			senden.address=0x02;
			senden.command=0x3B;
			senden.b2=0x17; //26
			senden.b3=0x00;
			senden.b4=0x00;
			senden.b5=0x00;
			senden.b6=0x00;
			senden.b7=0x00;
			senden.crc_lo=0xB5;
			senden.crc_hi=0x76;	
	
					

			write(fd, &senden, sizeof(senden));

			
			printf("%s\n","gesendet_1");
			sleep(1);
			printf("%s\n","lesen_1");

			int	n = read(fd, &empfangen, 8);
			printf("gelesen: %d\n",n);

			printf ("empfangen: %s\n",&empfangen);
			printf ("transmission: %#x\n",empfangen.transmission);
			printf ("global: %#x\n",empfangen.global);
			printf ("b1: %#x\n",empfangen.b[0]);
			printf ("b2: %#x\n",empfangen.b[1]);
			printf ("b3: %#x\n",empfangen.b[2]);
			printf ("b4: %#x\n",empfangen.b[3]);
			printf ("crc_lo: %#x\n",empfangen.crc_lo);
			printf ("crc_hi: %#x\n\n",empfangen.crc_hi);		


		
			fflush(ffd);
			fclose(ffd);	
			
}


extern int initialize_tty(){
		int val;
		struct sigaction saio;
		struct termios oldtio,newtio;
		
		wait_flag = TRUE;
		saio.sa_handler = signal_handler_IO;
		saio.sa_flags = 0;
		saio.sa_restorer = NULL;
		sigaction(SIGIO,&saio,NULL);


		ffd = fopen(devicename,"r+");
		if(!ffd){
			printf("fil_des.c -> open_file -- open() return Wert == -1 : ABBRUCH\n");
			exit(0);
		}
		read_fd = fileno( ffd );
		setbuf ( ffd , NULL );
		//setvbuf ( ffd , NULL , _IONBF , 0 );


		//fcntl(read_fd, F_SETOWN, getpid());
		fcntl(read_fd, F_SETFL, FASYNC | O_NONBLOCK );
		//fcntl(read_fd, F_SETFL, FASYNC );

		bzero(&newtio, sizeof(newtio)); /* clear struct for new port settings */	
		tcgetattr(read_fd,&oldtio); 
		newtio=oldtio;

		newtio.c_cflag &= ~PARENB;
		newtio.c_cflag &= ~CSTOPB;
		newtio.c_cflag &= ~CSIZE;
		newtio.c_cflag = BAUDRATE | CS8;
		
		newtio.c_oflag |= OPOST;
		newtio.c_oflag |= ONLCR;

		newtio.c_lflag &= ~(ICANON|ECHOE| ECHO|ISIG );
		          
		newtio.c_cflag |= CLOCAL | CREAD;
		
		newtio.c_cflag &= ~CRTSCTS;
		 								
		newtio.c_iflag &= ~(INPCK | ISTRIP|PARMRK|IGNPAR);
		
		newtio.c_iflag &= ~(INLCR | IGNCR | ICRNL | IUCLC);
		
		newtio.c_cc[VSTART] = 0x11;    
		newtio.c_cc[VSTOP]  = 0x13;  
		newtio.c_cc[VEOF]   = 0x00;							
		newtio.c_cc[VMIN] 	= 8;
		newtio.c_cc[VTIME] 	= 50;

		tcflush(read_fd, TCIFLUSH);
		tcflow(read_fd, TCOOFF);
		//int r= tcsetattr(read_fd,TCSANOW,&newtio);
		int r= tcsetattr(read_fd,TCSAFLUSH,&newtio);
		
		int dtr_bits = TIOCM_DTR;
		int rts_bits = TIOCM_RTS;
		int le_bits = TIOCM_LE;
		int led_bits = N_TTY;
		ioctl(read_fd,TIOCMBIS,&le_bits);
		ioctl(read_fd,TIOCMBIS,&dtr_bits);
		ioctl(read_fd,TIOCMBIS,&rts_bits);
		ioctl(read_fd,TIOCSETD,&led_bits);
		
		
		return read_fd;
								
}


 void signal_handler_IO (int status)
      {
        printf("received SIGIO signal.\n");
        wait_flag = FALSE;
      }

Danke
 
Da ist das Ganze doch mal im Zusammenhang.

Und was passiert jetzt, was soll passieren? Hast Du einen Rechner, mit dem Du testen kannst, ob das Senden schon mal richtig funktioniert?
 
Hi,

wenn ich das ganze auf Windows laufen lasse (allerdings ohne die ganzen termios sondern nur die Einstellungen mit mod) funktioniert es einwandfrei.
Ich kann senden so oft ich will, und krieg immer die korrekte Antwort.

Sobald ich das ganze auf der Fritz-Box(mit freetz) ausführe (diesmal mit den termios), kann ich nur einmal senden, bekomme auch auf das erste mal eine Antwort. Allerdings fehlt ab und das erste Byte der Antwort.
Wenn ich das 2te mal senden will, geht nichts raus. Das habe ich schon mal mit nem Sniffer mitgeloggt.
Wie gesagt, nur ausstecken bzw. ein echo helfen was.
 
Schau mal, ich habe nicht Deinen Wechselrichter und weiß nicht, was der erwartet und was der normalerweise von sich gibt.
Ich hatte die Fragen oben gestellt, weil sie möglicherweise dazu beitragen können, herauszufinden, was bei Dir passiert. Wenn Du nicht genau beschreiben willst, was da passiert, dann eben nicht.
 
Was soll ich denn genau beschreiben?
Der Code spiegelt das doch genau wieder!

Wenn ich den Code in Windows ausführe, geht es.
Wenn ich den Code in Linux ausführe geht es nicht.

Anscheinend liegt es an den Einstellung der Schnittstelle.

Deine Fragen hab ich beantwortet, oder?
 
Und was passiert jetzt, was soll passieren?
--> eine Antwort soll kommen

Hast Du einen Rechner, mit dem Du testen kannst, ob das Senden schon mal richtig funktioniert?
--> ja, hab ich auch schon in der Eröffnung geschrieben, das es unter Windows funktioniert.
 
Der Code soll anscheinend 10 Bytes senden und 8 Bytes empfangen. Es geht darauf weder hervor, ob uns was er tatsächlich etwas sendet, noch, ob und was er empfängt.

Du hast schon geschrieben, daß es unter Windows funktioniert, das hilft aber nicht weiter, das Programm auf der Box zum Laufen zu bringen. Du hast in #5 etwas von einem Sniffer geschrieben. Kannst Du genau feststellen, was auf der Leitung in beide Richtungen geht?
Darauf zielte meine Frage nach einem anderen Rechner ab, daß Du die Box mit einem Rechner verbindest, und anschaust, ob die Box tatsächlich die Daten sendet. Und ob sie durcheinander kommt, wenn dieser Rechner genau die gleiche Antwort sendet, die auch Dein Wechselrichter senden soll.
Wenn Du aber eine Möglichkeit hast, direkt auf der Leitung aufzuzeichnen, was zwischen Box und Wechselrichter gesendet wird, dann umso besser.

Wie hast Du es übrigens geschafft, das Programm oben überhaupt auf Linux zu übersetzen mit dem USHORT?
 
Hast du auch einen Linux-Rechner, auf dem du das probieren kannst?
 
Wie hast Du es übrigens geschafft, das Programm oben überhaupt auf Linux zu übersetzen mit dem USHORT?
--> ich hab ne virtual-box mit xubuntu 9.1 laufen. Der Cross-Compiler kommt damit zurecht.

Hast du auch einen Linux-Rechner, auf dem du das probieren kannst?
--> Hab nur die Virtual box laufen. Ich weis allerdings hier nicht, wie ich die Schnittstellen ansprechen soll/kann.
 
Hi,

das gleiche Problem wie auf der Box habe ich anfangs auch unter Windows gehabt, bis ich festgestellt habe, das ich DTR auf on setzten muss.
Ich denke, das nur die Einstellung der Schnittstelle nicht passen. Leider hab ich noch nicht rausgefunden, welch Konfiguration die richtige ist.
 
In Virtualbox müsste es sogar eine Funktion zum USB-"durchreichen" geben, womit du dann in deiner VM auf USB zugreifen kannst.
 
Für so etwas würde ich eher auf eine Linux Live-CD wie z.B. Knoppix zurückgreifen. Man weiß sonst nicht, ob Probleme durch die VM entstehen oder durch den Rest.

Weißt Du inzwischen, was dir Box auf der seriellen Schnittstelle tatsächlich sendet?
 
Aber wenn es in der VM problemlos ginge, wüsste er, dass sein Programm in Ordnung ist.
Umgekehrt dagegen nicht.
 
Ich hab ein ähnliches Problem wie tigerschaf1, über die interne Serille (ttyS0) funktioniert mein Code, über den usb-seriell Adapter (ttyUSB0) bekomm ich eine Verbindung, aber das Einlesen funktioniert nicht...
Bin auch schon am verzweifeln, hat jemand eine Idee was die Ursache sein könnte?

tigerschaf1 kannst du vielleicht direkt über eine "original" Serielle testen?
 
Je nachdem, was genau benötigt wird, könnte es am USB-Adapter liegen. Es gibt Unterschiede, speziell beim Timing, zwischen normaler seriellen Schnittstelle und einem USB-Adapter dafür, oder auch zwischen verschiedenen Modellen von Adaptern.
 
Ich sende einige command-Bytes hinaus und warte auf eine Antwort von der Gegenstelle (2 bytes), alles ohne cf , lf, eof, also raw. Da es über ttyS0 funktioniert sollten meine Einstellungen ja stimmen.
Wie kann man denn das Timing des Usb-Adapters tunen (hab zwei Adapter getestet mit pl2303 bzw. ch341 chipset)?
c_cc[VTIME] vom termios hab ich schon verändert, aber das hat nichts gebracht...
 
Probiere mal das:
Code: 
#include <stdio.h>
#include <termios.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/signal.h>
#include <sys/types.h>
#include <time.h>
#include <sys/ioctl.h>

#include <string.h>
#include <sys/time.h>

#pragma hdrstop


//#define TRUE 1
//#define FALSE 0

//definition------------------------------------------------------------------------------------------------------
int fd,  wait_flag,rv,gelbytes;

//char devicename[80] = "/dev/null";
char devicename[80] = "/dev/ttyUSB0";
#define BAUDRATE B19200

USHORT	crc_hl,crc_h,crc_l;

struct s_senden	{	char address;
  char command;
  char b2;
  char b3;
  char b4;
  char b5;
  char b6;
  char b7;
  unsigned char  crc_lo;
  unsigned char  crc_hi;
};

struct s_empfangen{	char transmission;
  char global;
  unsigned char b[4];
  unsigned char  crc_lo;
  unsigned char  crc_hi;
};

float v_float,v_float1,v_float2;
struct s_empfangen empfangen;
struct s_senden senden;
struct timeval timeout;
fd_set readfds;
struct termios oldtio;

void signal_handler_IO (int status);   /* definition of signal handler */
int initialize_tty();
float wertelesen();
float tofloat();

time_t jetzt;
struct tm *zgr;
char zeit[80];


//main------------------------------------------------------------------------------------------------------

int  main(int argc, char** argv)
{

  fd=initialize_tty();


  senden.address=0x02;
  senden.command=0x3B;
  senden.b2=0x17; //26
  senden.b3=0x00;
  senden.b4=0x00;
  senden.b5=0x00;
  senden.b6=0x00;
  senden.b7=0x00;
  senden.crc_lo=0xB5;
  senden.crc_hi=0x76;



  write(fd, &senden, sizeof(senden));


  printf("%s\n","gesendet_1");
  sleep(1);
  printf("%s\n","lesen_1");

  int	n = read(fd, &empfangen, 8);
  printf("gelesen: %d\n",n);

  printf ("empfangen: %s\n",&empfangen);
  printf ("transmission: %#x\n",empfangen.transmission);
  printf ("global: %#x\n",empfangen.global);
  printf ("b1: %#x\n",empfangen.b[0]);
  printf ("b2: %#x\n",empfangen.b[1]);
  printf ("b3: %#x\n",empfangen.b[2]);
  printf ("b4: %#x\n",empfangen.b[3]);
  printf ("crc_lo: %#x\n",empfangen.crc_lo);
  printf ("crc_hi: %#x\n\n",empfangen.crc_hi);

  tcsetattr(fd,TCSAFLUSH,&oldtio);
  close(fd);
}


extern int initialize_tty()
{
  int fd;
  int val;
  struct sigaction saio;
  struct termios newtio;

  fd = open(devicename, O_RDWR);
  if(fd < 0){
    printf("fil_des.c -> open_file -- open() return Wert == -1 : ABBRUCH\n");
    exit(0);
  }
  //fcntl(fd, F_SETOWN, getpid());
  fcntl(fd, F_SETFL, FASYNC | O_NONBLOCK );
  //fcntl(fd, F_SETFL, FASYNC );

  tcgetattr(fd,&oldtio);
  newtio=oldtio;

  cfmakeraw (&newtio);
  cfsetspeed (&newtio, BAUDRATE);

  //int r= tcsetattr(fd,TCSANOW,&newtio);
  int r= tcsetattr(fd,TCSAFLUSH,&newtio);

  int dtr_bits = TIOCM_DTR;
  int rts_bits = TIOCM_RTS;
  int le_bits = TIOCM_LE;
  ioctl(fd,TIOCMBIS,&le_bits);
  ioctl(fd,TIOCMBIS,&dtr_bits);
  ioctl(fd,TIOCMBIS,&rts_bits);
  return fd;

}


void signal_handler_IO (int status)
{
  printf("received SIGIO signal.\n");
  wait_flag = FALSE;
}
 
Hi,

bei mir funktioniert es jezt. Habe zwischen senden und empfangen einen usleep(90000) eingebaut, und noch einige Parameter verändert.

Hier der Code für die Schnittstelle:

Code: 
extern int initialize_tty()
{
		struct termios oldtio,newtio;

		ffd = fopen(devicename,"r+");
		if(!ffd){
			printf("fil_des.c -> open_file -- open() return Wert == -1 : ABBRUCH\n");
			exit(1);
		}
		int read_fd = fileno( ffd );
		
	  fcntl(read_fd, F_SETFL, FASYNC );

		bzero(&newtio, sizeof(newtio)); /* clear struct for new port settings */	
		tcgetattr(read_fd,&oldtio); 
		newtio=oldtio;

		newtio.c_cflag &= ~PARENB;
		newtio.c_cflag &= ~CSTOPB;
		newtio.c_cflag &= ~CSIZE;
		newtio.c_cflag = BAUDRATE | CS8;
		
		// Setting to raw Output 
		newtio.c_oflag |= OPOST;
		newtio.c_oflag |= ONLCR;

		// Setting to raw Input 
		newtio.c_lflag &= ~(ICANON|ECHOE| ECHO|ISIG );
		          
		// Enable Receiver and Local line 
		newtio.c_cflag |= CLOCAL | CREAD;
		
		// Hardware Flow Control
		newtio.c_cflag &= ~CRTSCTS;
		 								
		// Ignore Parity Errors 
		newtio.c_iflag &= ~(INPCK | ISTRIP|PARMRK|IGNPAR);
		
		// Do not translate CR to NL, do not translate NL to CR, do not ignore CR on input, do not LOWC to UPC 
		newtio.c_iflag &= ~(INLCR | IGNCR | ICRNL | IUCLC);
		newtio.c_iflag &= ~( IXON|IXOFF|IXANY);
		
		newtio.c_cc[VSTART] = 0x11;    
		newtio.c_cc[VSTOP]  = 0x13;  
		newtio.c_cc[VEOF]   = 0x00;							
		newtio.c_cc[VMIN] 	= 0;
		newtio.c_cc[VTIME] 	= 0;
		
		//tcflush(read_fd, TCIFLUSH);
		//tcflow(read_fd, TCOOFF);
		tcsetattr(read_fd,TCSAFLUSH,&newtio);
		
		int dsr_bits = TIOCM_DSR;
		int dtr_bits = TIOCM_DTR;
		//ioctl(read_fd,TIOCMBIS,&dtr_bits);
		//ioctl(read_fd,TIOCMBIS,&dsr_bits);

		
		return read_fd;		
}

Ausserdem verträgt meine Konfiguration keinerlei flush der Schnittstelle.

Also Hände weg von fflush(fd), und schon klappt es.

danke
 
Um antworten zu können musst du eingeloggt sein.

Zurzeit aktive Besucher

Gesamt: 734 (Mitglieder: 43, Gäste: 691)

Neueste Beiträge

Statistik des Forums

Themen
246,298
Beiträge
2,249,704
Mitglieder
373,902
Neuestes Mitglied
disconizer
Holen Sie sich 3CX - völlig kostenlos!
Verbinden Sie Ihr Team und Ihre Kunden Telefonie Livechat Videokonferenzen

Gehostet oder selbst-verwaltet. Für bis zu 10 Nutzer dauerhaft kostenlos. Keine Kreditkartendetails erforderlich. Ohne Risiko testen.

3CX
Für diese E-Mail-Adresse besteht bereits ein 3CX-Konto. Sie werden zum Kundenportal weitergeleitet, wo Sie sich anmelden oder Ihr Passwort zurücksetzen können, falls Sie dieses vergessen haben.
Ihr E-Mail-Adresse verifizieren

Ihr E-Mail-Adresse verifizieren

Wir haben Ihnen eine E-Mail geschickt. Klicken Sie auf die Schaltfläche im E-Mail-Text, um Ihre E-Mail-Adresse zu verifizieren – (Können Sie diese nicht finden können, dann überprüfen Sie Ihren Spam-Ordner).

IPPF im Überblick

Neueste Beiträge

Direktlinks Telefonanlage

Website-Sponsoren

3CX sponsor
KONTAKTIEREN SIE UNS BEI INTERESSE
| Style by ThemeHouse
XenPorta 2 PRO © Jason Axelrod of 8WAYRUN
Oben Unten
Zurück