Tcgetattr input output error mac

Thread: [AVRDude Error] /dev/ttyS0: tcgetattr: Input/output error

Thread Tools

Display

[AVRDude Error] /dev/ttyS0: tcgetattr: Input/output error

hi guys,
i build a new avr programmer(ponyser) and connected to my serial port
when i run this ‘avrdude -c ponyser -p m8 -V -U flash:w:led.hex’
i get the following

type=SERBB
/dev/ttyS0: tcgetattr: Input/output error

avrdude done. Thank you.

HELP ME!
the hardware is fine and i checked the electrical conn
also ‘setserial -a /dev/ttyS0’ yields

/dev/ttyS0, Line 0, UART: unknown, Port: 0x03f8, IRQ: 4
Baud_base: 115200, close_delay: 50, divisor: 0
closing_wait: 3000
Flags: spd_normal

Re: [AVRDude Error] /dev/ttyS0: tcgetattr: Input/output error

soryy guys
i figured it out myself
i got the problem solved

demesg | grep ttyS0

[ 16.340066] serial8250: ttyS0 at I/O 0x3f8 (irq = 4) is a 16550A
[ 16.341020] 00:07: ttyS0 at I/O 0x3f8 (irq = 4) is a 16550A

setserial -a /dev/ttyS0
/dev/ttyS0, Line 0, unknown : , Port: 0x03f8, IRQ: 4
Baud_base: 115200, close_delay: 50, divisor: 0
closing_wait: 3000
Flags: spd_normal

see unkown in the o/p of setserial and from dmesg i got uart type is 16550A

so use this command and everything goes alright

setserial /dev/ttyS0 uart 16550A

Re: [AVRDude Error] /dev/ttyS0: tcgetattr: Input/output error

soryy guys
i figured it out myself
i got the problem solved

demesg | grep ttyS0

[ 16.340066] serial8250: ttyS0 at I/O 0x3f8 (irq = 4) is a 16550A
[ 16.341020] 00:07: ttyS0 at I/O 0x3f8 (irq = 4) is a 16550A

setserial -a /dev/ttyS0
/dev/ttyS0, Line 0, unknown : , Port: 0x03f8, IRQ: 4
Baud_base: 115200, close_delay: 50, divisor: 0
closing_wait: 3000
Flags: spd_normal

see unkown in the o/p of setserial and from dmesg i got uart type is 16550A

so use this command and everything goes alright

setserial /dev/ttyS0 uart 16550A

Plz help me also. i m also getting same following error
/dev/ttyS0: tcgetattr: input/output error
i d tried ur method
setserial /dev/ttyS0 uart 16550A
but it is giving error as
operation not permitted
so what should i do now please guide in details

Last edited by gap113; June 17th, 2011 at 05:29 AM .

Источник

Perl’s backticks/system giving «tcsetattr: Input/output error»

I’m writing a perl script that kicks off a script on several different servers using ssh. The remote script needs to run as long as this script is running:

When I run this script, I get the following output:

./brokenscript.pl
Running script on server01
$ tcsetattr: Input/output error
Connection to server01 closed.

The same result occurs when running with system (and backticks are preferred anyways since I want the output of the script). When I run the exact command between the backticks on the command line, it works exactly as expected. What is causing this?

2 Answers 2

The tcsetattr: Input/output error message comes from ssh when it tries to put the local terminal into “raw” mode (which involves a call to tcsetattr; see enter_raw_mode in sshtty.c , called from client_loop in clientloop.c ).

From IEEE Std 1003.1, 2004 (Posix) Section 11.1.4: Terminal Access Control, tcsetattr may return -1 with errno == EIO (i.e. “Input/output error”) if the calling process is in an orphaned (or background?) process group.

Effectively ssh is trying to change the setting of the local terminal even though it is not in the foreground process group (due of your fork and, the local script exiting (as evidenced by the apparent shell prompt that comes immediately before the error message in your quoted output)).

If you just want to avoid the error message, you can use ssh -ntt (redirect stdin from /dev/null, but ask the remote side to allocate a tty anyway) instead of ssh -t (add your -l and any other options you need back in too, of course).

More likely, you are interesting in keeping the local script running as long as some of the remote processes are still running. For that, you need to use the wait function (or one of its “relatives”) to wait for each forked process to exit before you exit the program that forked them (this will keep them in the foreground process group as long as the program that started them is in it). You may still want to use -n though, since it would be confusing if the multiple instances of ssh that you forked all tried to use (read from, or change the settings of) the local terminal at the same time.

As a simple demonstration, you could have the local script do sleep 30 after forking off all the children so that the ssh command(s) have time to start up while they are part of the foreground process group. This should suppress the error message, but it will not address your stated goal. You need wait for that (If I am interpreting your goal correctly).

Источник

Thread: ‘Input/output error’ on serial port

Thread Tools

Display

‘Input/output error’ on serial port

The objective is to calibrate my monitor (connected via VGA) with the colorimeter X-Rite Colormunki Display connected via usb.
The device is recognized :

my environment:
Sony Vaio SVE14A2C5E
Ubuntu 12.04 (precise) 64-bit
Kernel Linux 3.5.0-44-generic
GNOME 3.4.2

Some weeks ago, I had windows 8 on this laptop without problem with the calibrator and Argyll.
I spent my last days reading the numerous topics about it without success.

I show you the outputs of some command lines:

The problem seems to come from the UART: unknown. So I tried to do:

After a reboot UART is unknown again.

and the device is still not working.

The command below changes apparently nothing.

In the Serial port setup menu I get:
| A — Serial Device : /dev/tty8
| B — Lockfile Location : /var/lock
| C — Callin Program :
| D — Callout Program :
| E — Bps/Par/Bits : 115200 8N1
| F — Hardware Flow Control : Yes
| G — Software Flow Control : No

I changed tty8 by ttyS0 but it changes nothing
In some discussions the users where modifying some files system, but as I do not understand well what they are doing and if it is appropriate to my case, I prefer to stop here and wait for your advises.

Thank you very much for you help.

Last edited by hadrien15; December 29th, 2013 at 09:23 PM .

Re: ‘Input/output error’ on serial port

I don’t have any experience with these devices but the most likely issue would seem to be that it’s not actually connecting on /dev/ttyS0 surely?

AFAIK real-time udev messages go to /var/log/syslog rather than /var/log/dmesg, so I’d suggest running

in a terminal and then plugging the device in — you should see exactly what tty file it is attaching to — if it’s connecting via /dev/ttyUSBn for example but the software insists on using /dev/ttySn then it may be a question of providing a udev rule to create the desired symlink

Last edited by steeldriver; December 29th, 2013 at 10:08 PM .

Источник

Entering raw mode

Let’s try and read keypresses from the user. (The lines you need to add are highlighted and marked with arrows.)

read() and STDIN_FILENO come from . We are asking read() to read 1 byte from the standard input into the variable c , and to keep doing it until there are no more bytes to read. read() returns the number of bytes that it read, and will return 0 when it reaches the end of a file.

When you run ./kilo , your terminal gets hooked up to the standard input, and so your keyboard input gets read into the c variable. However, by default your terminal starts in canonical mode, also called cooked mode. In this mode, keyboard input is only sent to your program when the user presses Enter . This is useful for many programs: it lets the user type in a line of text, use Backspace to fix errors until they get their input exactly the way they want it, and finally press Enter to send it to the program. But it does not work well for programs with more complex user interfaces, like text editors. We want to process each keypress as it comes in, so we can respond to it immediately.

What we want is raw mode. Unfortunately, there is no simple switch you can flip to set the terminal to raw mode. Raw mode is achieved by turning off a great many flags in the terminal, which we will do gradually over the course of this chapter.

To exit the above program, press Ctrl-D to tell read() that it’s reached the end of file. Or you can always press Ctrl-C to signal the process to terminate immediately.

Press q to quit?

To demonstrate how canonical mode works, we’ll have the program exit when it reads a q keypress from the user. (Lines you need to change are highlighted and marked the same way as lines you need to add.)

To quit this program, you will have to type a line of text that includes a q in it, and then press enter. The program will quickly read the line of text one character at a time until it reads the q , at which point the while loop will stop and the program will exit. Any characters after the q will be left unread on the input queue, and you may see that input being fed into your shell after your program exits.

Turn off echoing

We can set a terminal’s attributes by (1) using tcgetattr() to read the current attributes into a struct, (2) modifying the struct by hand, and (3) passing the modified struct to tcsetattr() to write the new terminal attributes back out. Let’s try turning off the ECHO feature this way.

struct termios , tcgetattr() , tcsetattr() , ECHO , and TCSAFLUSH all come from .

The ECHO feature causes each key you type to be printed to the terminal, so you can see what you’re typing. This is useful in canonical mode, but really gets in the way when we are trying to carefully render a user interface in raw mode. So we turn it off. This program does the same thing as the one in the previous step, it just doesn’t print what you are typing. You may be familiar with this mode if you’ve ever had to type a password at the terminal, when using sudo for example.

After the program quits, depending on your shell, you may find your terminal is still not echoing what you type. Don’t worry, it will still listen to what you type. Just press Ctrl-C to start a fresh line of input to your shell, and type in reset and press Enter . This resets your terminal back to normal in most cases. Failing that, you can always restart your terminal emulator. We’ll fix this whole problem in the next step.

Terminal attributes can be read into a termios struct by tcgetattr() . After modifying them, you can then apply them to the terminal using tcsetattr() . The TCSAFLUSH argument specifies when to apply the change: in this case, it waits for all pending output to be written to the terminal, and also discards any input that hasn’t been read.

The c_lflag field is for “local flags”. A comment in macOS’s describes it as a “dumping ground for other state”. So perhaps it should be thought of as “miscellaneous flags”. The other flag fields are c_iflag (input flags), c_oflag (output flags), and c_cflag (control flags), all of which we will have to modify to enable raw mode.

ECHO is a bitflag, defined as 00000000000000000000000000001000 in binary. We use the bitwise-NOT operator (

) on this value to get 11111111111111111111111111110111 . We then bitwise-AND this value with the flags field, which forces the fourth bit in the flags field to become 0 , and causes every other bit to retain its current value. Flipping bits like this is common in C.

Disable raw mode at exit

Let’s be nice to the user and restore their terminal’s original attributes when our program exits. We’ll save a copy of the termios struct in its original state, and use tcsetattr() to apply it to the terminal when the program exits.

atexit() comes from . We use it to register our disableRawMode() function to be called automatically when the program exits, whether it exits by returning from main() , or by calling the exit() function. This way we can ensure we’ll leave the terminal attributes the way we found them when our program exits.

We store the original terminal attributes in a global variable, orig_termios . We assign the orig_termios struct to the raw struct in order to make a copy of it before we start making our changes.

You may notice that leftover input is no longer fed into your shell after the program quits. This is because of the TCSAFLUSH option being passed to tcsetattr() when the program exits. As described earlier, it discards any unread input before applying the changes to the terminal. (Note: This doesn’t happen in Cygwin for some reason, but it won’t matter once we are reading input one byte at a time.)

Turn off canonical mode

There is an ICANON flag that allows us to turn off canonical mode. This means we will finally be reading input byte-by-byte, instead of line-by-line.

ICANON comes from . Input flags (the ones in the c_iflag field) generally start with I like ICANON does. However, ICANON is not an input flag, it’s a “local” flag in the c_lflag field. So that’s confusing.

Now the program will quit as soon as you press q .

Display keypresses

To get a better idea of how input in raw mode works, let’s print out each byte that we read() . We’ll print each character’s numeric ASCII value, as well as the character it represents if it is a printable character.

iscntrl() comes from , and printf() comes from .

iscntrl() tests whether a character is a control character. Control characters are nonprintable characters that we don’t want to print to the screen. ASCII codes 0–31 are all control characters, and 127 is also a control character. ASCII codes 32–126 are all printable. (Check out the ASCII table to see all of the characters.)

printf() can print multiple representations of a byte. %d tells it to format the byte as a decimal number (its ASCII code), and %c tells it to write out the byte directly, as a character.

This is a very useful program. It shows us how various keypresses translate into the bytes we read. Most ordinary keys translate directly into the characters they represent. But try seeing what happens when you press the arrow keys, or Escape , or Page Up , or Page Down , or Home , or End , or Backspace , or Delete , or Enter . Try key combinations with Ctrl , like Ctrl-A , Ctrl-B , etc.

You’ll notice a few interesting things:

• Arrow keys, Page Up , Page Down , Home , and End all input 3 or 4 bytes to the terminal: 27 , ‘[‘ , and then one or two other characters. This is known as an escape sequence. All escape sequences start with a 27 byte. Pressing Escape sends a single 27 byte as input.
• Backspace is byte 127 . Delete is a 4-byte escape sequence.
• Enter is byte 10 , which is a newline character, also known as ‘n’ .
• Ctrl-A is 1 , Ctrl-B is 2 , Ctrl-C is… oh, that terminates the program, right. But the Ctrl key combinations that do work seem to map the letters A–Z to the codes 1–26.

By the way, if you happen to press Ctrl-S , you may find your program seems to be frozen. What you’ve done is you’ve asked your program to stop sending you output. Press Ctrl-Q to tell it to resume sending you output.

Also, if you press Ctrl-Z (or maybe Ctrl-Y ), your program will be suspended to the background. Run the fg command to bring it back to the foreground. (It may quit immediately after you do that, as a result of read() returning -1 to indicate that an error occurred. This happens on macOS, while Linux seems to be able to resume the read() call properly.)

Turn off Ctrl-C and Ctrl-Z signals

By default, Ctrl-C sends a SIGINT signal to the current process which causes it to terminate, and Ctrl-Z sends a SIGTSTP signal to the current process which causes it to suspend. Let’s turn off the sending of both of these signals.

Источник