static void display_speed(struct termios *mode, int fancy) { if (cfgetispeed(mode) == 0 || cfgetispeed(mode) == cfgetospeed(mode)) wrapf(fancy ? "speed %lu baud;" : "%lu\n", baud_to_value(cfgetospeed(mode))); else wrapf(fancy ? "ispeed %lu baud; ospeed %lu baud;" : "%lu %lu\n", baud_to_value(cfgetispeed(mode)), baud_to_value(cfgetospeed(mode))); if (!fancy) current_col = 0; }
static void test_termios_cfsetspeed(void) { int i; int status; speed_t speed; struct termios term; tcflag_t bad; bad = CBAUD << 1; memset( &term, '\0', sizeof(term) ); puts( "cfsetspeed(BAD BAUD) - EINVAL" ); status = cfsetspeed( &term, bad ); rtems_test_assert( status == -1 ); rtems_test_assert( errno == EINVAL ); for (i=0 ; baud_table[i].constant != INVALID_CONSTANT ; i++ ) { memset( &term, '\0', sizeof(term) ); printf( "cfsetspeed(B%" PRIdrtems_termios_baud_t ") - OK\n", baud_table[i].baud ); status = cfsetspeed( &term, baud_table[i].constant ); rtems_test_assert( !status ); printf( "cfgetspeed(B%" PRIdrtems_termios_baud_t ") - checking both inspeed and outspeed - OK\n", baud_table[i].baud ); speed = cfgetispeed( &term ); rtems_test_assert( speed == baud_table[i].constant ); speed = cfgetospeed( &term ); rtems_test_assert( speed == baud_table[i].constant ); } }
/** * Get the baud rate of the serial device. * * @exception std::logic_error This exception should never occur. It is thrown * when the device somehow entered a mode that is * not valid according to the <termios.h> * * @return baud rate */ unsigned int Serial::Baud() const { switch(cfgetispeed(&mode)) { case B50: return 50; case B75: return 75;; case B110: return 110; case B134: return 134; case B150: return 150; case B200: return 200; case B300: return 300; case B600: return 600; case B1200: return 1200; case B1800: return 1800; case B2400: return 2400; case B4800: return 4800; case B9600: return 9600; case B19200: return 19200; case B38400: return 38400; case B57600: return 57600; case B115200: return 115200; case B230400: return 230400; }; // should be impossible (can happen if there are errors in termios code) throw std::logic_error("Device mode corrupt"); }
static void test_termios_cfinspeed(void) { int i; int sc; speed_t speed; struct termios term; speed_t bad; bad = B921600 << 1; memset( &term, '\0', sizeof(term) ); puts( "cfsetispeed(BAD BAUD) - EINVAL" ); sc = cfsetispeed( &term, bad ); rtems_test_assert( sc == -1 ); rtems_test_assert( errno == EINVAL ); for (i=0 ; baud_table[i].constant != INVALID_CONSTANT ; i++ ) { memset( &term, '\0', sizeof(term) ); printf( "cfsetispeed(B%" PRIdrtems_termios_baud_t ") - OK\n", baud_table[i].baud ); sc = cfsetispeed( &term, baud_table[i].constant ); rtems_test_assert( !sc ); printf( "cfgetispeed(B%" PRIdrtems_termios_baud_t ") - OK\n", baud_table[i].baud ); speed = cfgetispeed( &term ); rtems_test_assert( speed == baud_table[i].constant ); } }
size_t gc_free_termios (SCM x) { struct termios *gp; scm_assert_smob_type (termios_tag, x); gp = (struct termios *) SCM_SMOB_DATA (x); assert (gp != NULL); if (0) { fprintf (stderr, "Freeing termios at %p\n", gp); fprintf (stderr, "Flags: I %u O %u C %u L %u\n", gp->c_iflag, gp->c_oflag, gp->c_cflag, gp->c_lflag); fprintf (stderr, "Speed: O %u I %u\n", cfgetospeed(gp), cfgetispeed(gp)); fflush (stderr); sleep (1); } scm_gc_free (gp, sizeof (struct termios), "termios"); SCM_SET_SMOB_DATA (x, NULL); return 0; }
void TerminalSpeeds(long *ispeed, long *ospeed) { #ifdef __WIN32__ *ispeed = B9600; *ospeed = B9600; #else register struct termspeeds *tp; register long in, out; out = cfgetospeed(&old_tc); in = cfgetispeed(&old_tc); if (in == 0) in = out; tp = termspeeds; while ((tp->speed != -1) && (tp->value < in)) tp++; *ispeed = tp->speed; tp = termspeeds; while ((tp->speed != -1) && (tp->value < out)) tp++; *ospeed = tp->speed; #endif }
int getbaud(int fd) { struct termios termAttr; int inputSpeed = -1; speed_t baudRate; tcgetattr(fd, &termAttr); /* Get the input speed. */ baudRate = cfgetispeed(&termAttr); switch (baudRate) { case B0: inputSpeed = 0; break; case B50: inputSpeed = 50; break; case B110: inputSpeed = 110; break; case B134: inputSpeed = 134; break; case B150: inputSpeed = 150; break; case B200: inputSpeed = 200; break; case B300: inputSpeed = 300; break; case B600: inputSpeed = 600; break; case B1200: inputSpeed = 1200; break; case B1800: inputSpeed = 1800; break; case B2400: inputSpeed = 2400; break; case B4800: inputSpeed = 4800; break; case B9600: inputSpeed = 9600; break; case B19200: inputSpeed = 19200; break; case B38400: inputSpeed = 38400; break; case B115200: inputSpeed = 115200; break; } return inputSpeed; }
void TtyElmoConnection::_setBaud(speed_t baudValue) { if (baudValue != B9600 && baudValue != B19200 && baudValue != B38400 && baudValue != B57600) { ELOG << __PRETTY_FUNCTION__ << ": bad baud value 0" << std::oct << baudValue << std::dec << " (octal), using B9600"; baudValue = B9600; } // Get current settings, change the port speed, and send the new settings. struct termios ios; if (tcgetattr(_fd, &ios) == -1) { ELOG << __PRETTY_FUNCTION__ << ": error getting " << _ttyDev << " attributes: " << strerror(errno); exit(1); } // Change speed if the current speed is not the same as the requested one if (cfgetispeed(&ios) == baudValue && cfgetospeed(&ios) == baudValue) { DLOG << __PRETTY_FUNCTION__ << ": requested baud rate matches current"; } else { ILOG << "Changing speed on " << _ttyDev << " to " << _BaudToText(baudValue); cfsetspeed(&ios, baudValue); // Send new I/O settings if (tcsetattr(_fd, TCSAFLUSH, &ios) == -1) { ELOG << __PRETTY_FUNCTION__ << ": error setting " << _ttyDev << " attributes: " << strerror(errno); exit(1); } } }
inline SerialPort::BaudRate SerialPort::SerialPortImpl::GetBaudRate() const throw( SerialPort::NotOpen, std::runtime_error ) { // // Make sure that the serial port is open. // if ( ! this->IsOpen() ) { throw SerialPort::NotOpen( ERR_MSG_PORT_NOT_OPEN ) ; } // // Read the current serial port settings. // termios port_settings ; if ( tcgetattr( mFileDescriptor, &port_settings ) < 0 ) { throw std::runtime_error( strerror(errno) ) ; } // // Obtain the input baud rate from the current settings. // return SerialPort::BaudRate(cfgetispeed( &port_settings )) ; }
/* * uarthandler_getBaud(): Function to get the Baud rate */ int uarthandler_getBaud(int fd) { struct termios termAttr; int inRate = -1; speed_t baudRate; tcgetattr(fd, &termAttr); baudRate = cfgetispeed(&termAttr); //get the input speed switch (baudRate) { case B0: inRate = 0; break; case B50: inRate = 50; break; case B110: inRate = 110; break; case B134: inRate = 134; break; case B150: inRate = 150; break; case B200: inRate = 200; break; case B300: inRate = 300; break; case B600: inRate = 600; break; case B1200: inRate = 1200; break; case B1800: inRate = 1800; break; case B2400: inRate = 2400; break; case B4800: inRate = 4800; break; case B9600: inRate = 9600; break; case B19200: inRate = 19200; break; case B38400: inRate = 38400; break; case B115200: inRate = 115200; break; } return inRate; }
Val _lib7_P_TTY_tcgetattr (Task* task, Val arg) { //===================== // // Mythryl type: Int -> (Unt, Unt, Unt, Unt, String, Unt, Unt) // // Get parameters associated with tty. // // NOTE: the calls to cfget[io] speed by making the code more OS-dependent // and using the package of struct termios. // // This fn gets bound as tcgetattr in: // // src/lib/std/src/psx/posix-tty.pkg ENTER_MYTHRYL_CALLABLE_C_FN(__func__); int fd = TAGGED_INT_TO_C_INT( arg ); struct termios data; RELEASE_MYTHRYL_HEAP( task->hostthread, __func__, NULL); // int status = tcgetattr( fd, &data ); // RECOVER_MYTHRYL_HEAP( task->hostthread, __func__ ); if (status < 0) return RAISE_SYSERR__MAY_HEAPCLEAN(task, status, NULL); Val iflag = make_one_word_unt(task, data.c_iflag ); Roots roots1 = { &iflag, NULL }; Val oflag = make_one_word_unt(task, data.c_oflag ); Roots roots2 = { &oflag, &roots1 }; Val cflag = make_one_word_unt(task, data.c_cflag ); Roots roots3 = { &cflag, &roots2 }; Val lflag = make_one_word_unt(task, data.c_lflag ); Roots roots4 = { &lflag, &roots3 }; Val ispeed = make_one_word_unt(task, cfgetispeed (&data) ); Roots roots5 = { &ispeed, &roots4 }; Val ospeed = make_one_word_unt(task, cfgetospeed (&data) ); Roots roots6 = { &ospeed, &roots5 }; Val cc = allocate_nonempty_ascii_string__may_heapclean (task, NCCS, &roots6 ); memcpy( GET_VECTOR_DATACHUNK_AS( void*, cc ), data.c_cc, NCCS ); // Construct the result vector: // set_slot_in_nascent_heapchunk (task, 0, MAKE_TAGWORD(PAIRS_AND_RECORDS_BTAG, 7)); set_slot_in_nascent_heapchunk (task, 1, iflag); set_slot_in_nascent_heapchunk (task, 2, oflag); set_slot_in_nascent_heapchunk (task, 3, cflag); set_slot_in_nascent_heapchunk (task, 4, lflag); set_slot_in_nascent_heapchunk (task, 5, cc); set_slot_in_nascent_heapchunk (task, 6, ispeed); set_slot_in_nascent_heapchunk (task, 7, ospeed); Val result = commit_nascent_heapchunk (task, 7); EXIT_MYTHRYL_CALLABLE_C_FN(__func__); return result; }
STATIC mp_obj_t mod_termios_tcgetattr(mp_obj_t fd_in) { struct termios term; int fd = mp_obj_get_int(fd_in); int res = tcgetattr(fd, &term); RAISE_ERRNO(res, errno); mp_obj_list_t *r = MP_OBJ_TO_PTR(mp_obj_new_list(7, NULL)); r->items[0] = MP_OBJ_NEW_SMALL_INT(term.c_iflag); r->items[1] = MP_OBJ_NEW_SMALL_INT(term.c_oflag); r->items[2] = MP_OBJ_NEW_SMALL_INT(term.c_cflag); r->items[3] = MP_OBJ_NEW_SMALL_INT(term.c_lflag); r->items[4] = MP_OBJ_NEW_SMALL_INT(cfgetispeed(&term)); r->items[5] = MP_OBJ_NEW_SMALL_INT(cfgetospeed(&term)); mp_obj_list_t *cc = MP_OBJ_TO_PTR(mp_obj_new_list(NCCS, NULL)); r->items[6] = MP_OBJ_FROM_PTR(cc); for (int i = 0; i < NCCS; i++) { if (i == VMIN || i == VTIME) { cc->items[i] = MP_OBJ_NEW_SMALL_INT(term.c_cc[i]); } else { // https://docs.python.org/3/library/termios.html says value is *string*, // but no way unicode chars could be there, if c_cc is defined to be a // a "char". But it's type is actually cc_t, which can be anything. // TODO: For now, we still deal with it like that. cc->items[i] = mp_obj_new_bytes((byte*)&term.c_cc[i], 1); } } return MP_OBJ_FROM_PTR(r); }
static BOOL _get_baud_rate(WINPR_COMM *pComm, SERIAL_BAUD_RATE *pBaudRate) { int i; speed_t currentSpeed; struct termios currentState; ZeroMemory(¤tState, sizeof(struct termios)); if (tcgetattr(pComm->fd, ¤tState) < 0) { SetLastError(ERROR_IO_DEVICE); return FALSE; } currentSpeed = cfgetispeed(¤tState); for (i=0; _BAUD_TABLE[i][0]<_BAUD_TABLE_END; i++) { if (_BAUD_TABLE[i][0] == currentSpeed) { pBaudRate->BaudRate = _BAUD_TABLE[i][1]; return TRUE; } } CommLog_Print(WLOG_WARN, "could not find a matching baud rate for the speed 0x%x", currentSpeed); SetLastError(ERROR_INVALID_DATA); return FALSE; }
void TerminalSpeeds (long *ispeed, long *ospeed) { #ifdef DECODE_BAUD struct termspeeds *tp; #endif /* DECODE_BAUD */ long in, out; out = cfgetospeed (&old_tc); in = cfgetispeed (&old_tc); if (in == 0) in = out; #ifdef DECODE_BAUD tp = termspeeds; while ((tp->speed != -1) && (tp->value < in)) tp++; *ispeed = tp->speed; tp = termspeeds; while ((tp->speed != -1) && (tp->value < out)) tp++; *ospeed = tp->speed; #else /* DECODE_BAUD */ *ispeed = in; *ospeed = out; #endif /* DECODE_BAUD */ }
/* * PXFCFGETISPEED -- get input baud rate * PXFCFSETISPEED -- set input baud rate * PXFCFGETOSPEED -- get output baud rate * PXFCFSETOSPEED -- set output baud rate * (section 7.1.3 of Posix 1003.9-1992) * * Synopsis: * * SUBROUTINE PXFCFGETISPEED(jtermios, iospeed, ierror) * INTEGER jtermios, iospeed, ierror * * SUBROUTINE PXFCFSETISPEED(jtermios, ispeed, ierror) * INTEGER jtermios, ispeed, ierror * * SUBROUTINE PXFCFGETOSPEED(jtermios, iospeed, ierror) * INTEGER jtermios, iospeed, ierror * * SUBROUTINE PXFCFSETOSPEED(jtermios, ispeed, ierror) * INTEGER jtermios, ispeed, ierror * * Description: * * The PXFCF...SPEED routines use the c functions to get or set the * baud rates in the termios structure. Symbolic names for the baud * rates can be obtained through calls to PXFCONST. * * The arguments are: * * jtermios - default integer input variable containing a handle * created by PXFSTRUCTCREATE('termios',...). * ispeed - default input integer variable for a baud rate. * iospeed - default output integer variable specifying a baud * rate. * ierror - default integer output variable that contains zero * if the operation was successful or nonzero if the * operation was not successful. * * PXFCF...SPEED routines may return one of the following error values: * No errors are returned for bad baud rates. The PXFCFSETISPEED and * PXFCFSETOSPEED return 0 if successful; otherwise, they return -1. * * EBADHANDLE The jtermios argument is invalid. * * EINVAL Problems occurred with the baud rate. * */ #include <fortran.h> #include <liberrno.h> #include <string.h> #include <sys/termios.h> #include <termios.h> #include "pxfstruct.h" #include "table.h" #ifdef _UNICOS void PXFCFGETISPEED( #else /* _UNICOS */ void pxfcfgetispeed_( #endif /* _UNICOS */ _f_int *jtermios, _f_int *iospeed, _f_int *ierror) { speed_t stat; struct pxfhandle pxfhand; struct termios *trmios; *ierror = 0; *iospeed = 0; pxfhand = _pxfhandle_table_lookup(&_pxfhandle_table, *jtermios); if (pxfhand.pxfstructptr == NULL || pxfhand.pxftype != PXF_TERMIOS) { *ierror = EBADHANDLE; return; } trmios = pxfhand.pxfstructptr; if (stat = cfgetispeed(trmios) == -1) *ierror = EINVAL; else *iospeed = stat; return; }
void auxShiftBaud(char* cmd) { int newBaud = parseBaudRates(cmd); /* Save the current serial port settings */ struct termios newtio; tcgetattr(serialfd, &newtio); /* Set the input/output baud rates for this device */ cfsetispeed(&newtio, newBaud); cfsetospeed(&newtio, newBaud); /* Clean the modem line and activate new port settings */ tcflush(serialfd, TCIOFLUSH); tcsetattr(serialfd, TCSANOW, &newtio); if (tcgetattr(serialfd, &newtio) != 0) { printf("ERROR: Bad termoios; Rate change may have failed?\n"); return; } if (OUTDEBUG) { printf("DEBUG: changed to %s\n",see_speed(cfgetispeed(&newtio))); } }
int main(int argc,char** argv) { struct termios ts; tcgetattr(0,&ts); printf("input speed %d \n",cfgetispeed(&ts)); printf("ouput speed %d \n",cfgetospeed(&ts)); return 0; }
static void cfgetispeed_intrin (struct termios *t) { unsigned int speed, bspeed; bspeed = cfgetispeed (t); if (0 == map_bspeed_to_speed (bspeed, &speed)) (void) SLang_push_uint (speed); }
/* * Encodes terminal modes for the terminal referenced by fd * or tiop in a portable manner, and appends the modes to a packet * being constructed. */ void ssh_tty_make_modes(struct ssh *ssh, int fd, struct termios *tiop) { struct termios tio; struct sshbuf *buf; int r, ibaud, obaud; if ((buf = sshbuf_new()) == NULL) fatal("%s: sshbuf_new failed", __func__); if (tiop == NULL) { if (fd == -1) { debug("%s: no fd or tio", __func__); goto end; } if (tcgetattr(fd, &tio) == -1) { logit("tcgetattr: %.100s", strerror(errno)); goto end; } } else tio = *tiop; /* Store input and output baud rates. */ obaud = speed_to_baud(cfgetospeed(&tio)); ibaud = speed_to_baud(cfgetispeed(&tio)); if ((r = sshbuf_put_u8(buf, TTY_OP_OSPEED)) != 0 || (r = sshbuf_put_u32(buf, obaud)) != 0 || (r = sshbuf_put_u8(buf, TTY_OP_ISPEED)) != 0 || (r = sshbuf_put_u32(buf, ibaud)) != 0) fatal("%s: buffer error: %s", __func__, ssh_err(r)); /* Store values of mode flags. */ #define TTYCHAR(NAME, OP) \ if ((r = sshbuf_put_u8(buf, OP)) != 0 || \ (r = sshbuf_put_u32(buf, tio.c_cc[NAME])) != 0) \ fatal("%s: buffer error: %s", __func__, ssh_err(r)); \ #define SSH_TTYMODE_IUTF8 42 /* for SSH_BUG_UTF8TTYMODE */ #define TTYMODE(NAME, FIELD, OP) \ if (OP == SSH_TTYMODE_IUTF8 && (datafellows & SSH_BUG_UTF8TTYMODE)) { \ debug3("%s: SSH_BUG_UTF8TTYMODE", __func__); \ } else if ((r = sshbuf_put_u8(buf, OP)) != 0 || \ (r = sshbuf_put_u32(buf, ((tio.FIELD & NAME) != 0))) != 0) \ fatal("%s: buffer error: %s", __func__, ssh_err(r)); \ #include "ttymodes.h" #undef TTYCHAR #undef TTYMODE end: /* Mark end of mode data. */ if ((r = sshbuf_put_u8(buf, TTY_OP_END)) != 0 || (r = sshpkt_put_stringb(ssh, buf)) != 0) fatal("%s: packet error: %s", __func__, ssh_err(r)); sshbuf_free(buf); }
unsigned TTYPort::GetBaudrate() const { struct termios attr; if (tcgetattr(fd, &attr) < 0) return 0; return speed_t_to_baud_rate(cfgetispeed(&attr)); }
speed_t getBaudRate(int fd){ struct termios options; if(tcgetattr(fd, &options)<0){ do_log("getBaudRate","Couldn't load Options",LOG_LEVEL_ERROR,LOG_TYPE_SIGNAL); return -1; } return cfgetispeed(&options); }
/** * Compare termios structures in a structure-correct and portable way. This * function tries to be portable and thus may not compare all structure fields. * * @param term1 first termios structure * @param term2 second termios structure * * @return True if term1 is equal to term2, false otherwise */ bool Serial::TermiosCompare(const struct termios &term1, const struct termios &term2) const { // compare input, output, control and local mode flags if (term1.c_iflag != term2.c_iflag || term1.c_oflag != term2.c_oflag || term1.c_cflag != term2.c_cflag || term1.c_lflag != term2.c_lflag) return false; // compare input and output speeds if (cfgetispeed(&term1) != cfgetispeed(&term2) || cfgetospeed(&term1) != cfgetospeed(&term2)) return false; // compare control characters for (int i=0; i<NCCS; i++) if (term1.c_cc[i] != term2.c_cc[i]) return false; return true; }
void encode_terminal_status(struct termios *terminal_status, value *dst) { long *pc; int i; for (pc = terminal_io_descr; *pc != End; dst++) { switch (*pc++) { case Bool: { tcflag_t *src = choose_field(terminal_status, *pc++); tcflag_t msk = *pc++; *dst = Val_bool(*src & msk); break; } case Enum: { tcflag_t *src = choose_field(terminal_status, *pc++); int ofs = *pc++; int num = *pc++; tcflag_t msk = *pc++; for (i = 0; i < num; i++) { if ((*src & msk) == pc[i]) { *dst = Val_int(i + ofs); break; } } pc += num; break; } case Speed: { int which = *pc++; speed_t speed = 0; *dst = Val_int(9600); /* in case no speed in speedtable matches */ switch (which) { case Output: speed = cfgetospeed(terminal_status); break; case Input: speed = cfgetispeed(terminal_status); break; } for (i = 0; i < NSPEEDS; i++) { if (speed == speedtable[i].speed) { *dst = Val_int(speedtable[i].baud); break; } } break; } case Char: { int which = *pc++; *dst = Val_int(terminal_status->c_cc[which]); break; } } } }
/******************************************************************************* ** ** Function userial_vendor_get_baud ** ** Description Get current baud rate ** ** Returns int ** *******************************************************************************/ int userial_vendor_get_baud(void) { if (vnd_userial.fd == -1) { ALOGE( "%s: uart port(%s) has not been opened", __FUNCTION__, BT_HS_UART_DEVICE ); return -1; } return userial_tcio_baud_to_int(cfgetispeed(&vnd_userial.termios)); }
void gpsd_close(struct gps_device_t *session) { if (!BAD_SOCKET(session->gpsdata.gps_fd)) { (void)ioctl(session->gpsdata.gps_fd, (unsigned long)TIOCNXCL); (void)tcdrain(session->gpsdata.gps_fd); if (isatty(session->gpsdata.gps_fd) != 0) { /* force hangup on close on systems that don't do HUPCL properly */ /*@ ignore @*/ (void)cfsetispeed(&session->ttyset, (speed_t) B0); (void)cfsetospeed(&session->ttyset, (speed_t) B0); /*@ end @*/ (void)tcsetattr(session->gpsdata.gps_fd, TCSANOW, &session->ttyset); } /* this is the clean way to do it */ session->ttyset_old.c_cflag |= HUPCL; /* * Don't revert the serial parameters if we didn't have to mess with * them the first time. Economical, and avoids tripping over an * obscure Linux 2.6 kernel bug that disables threaded * ioctl(TIOCMWAIT) on a device after tcsetattr() is called. */ if (cfgetispeed(&session->ttyset_old) != cfgetispeed(&session->ttyset) || (session->ttyset_old.c_cflag & CSTOPB) != (session->ttyset.c_cflag & CSTOPB)) { /* * If we revert, keep the most recent baud rate. * Cuts down on autobaud overhead the next time. */ /*@ ignore @*/ (void)cfsetispeed(&session->ttyset_old, (speed_t) session->gpsdata.dev.baudrate); (void)cfsetospeed(&session->ttyset_old, (speed_t) session->gpsdata.dev.baudrate); /*@ end @*/ (void)tcsetattr(session->gpsdata.gps_fd, TCSANOW, &session->ttyset_old); } gpsd_report(session->context->debug, LOG_SPIN, "close(%d) in gpsd_close(%s)\n", session->gpsdata.gps_fd, session->gpsdata.dev.path); (void)close(session->gpsdata.gps_fd); session->gpsdata.gps_fd = -1; } }
unsigned TTYPort::GetBaudrate() const { assert(tty.IsDefined()); struct termios attr; if (!tty.GetAttr(attr)) return 0; return speed_t_to_baud_rate(cfgetispeed(&attr)); }
void gprint(struct termios *tp) { const struct cchar *cp; (void)printf("gfmt1:cflag=%x:iflag=%x:lflag=%x:oflag=%x:", tp->c_cflag, tp->c_iflag, tp->c_lflag, tp->c_oflag); for (cp = cchars1; cp->name; ++cp) (void)printf("%s=%x:", cp->name, tp->c_cc[cp->sub]); (void)printf("ispeed=%d:ospeed=%d\n", cfgetispeed(tp), cfgetospeed(tp)); }
void gpsd_assert_sync(struct gps_device_t *session) /* to be called when we want to register that we've synced with a device */ { /* * We've achieved first sync with the device. Remember the * baudrate so we can try it first next time this device * is opened. */ if (session->saved_baud == -1) session->saved_baud = (int)cfgetispeed(&session->ttyset); }
static ptr_t Termiorep(struct termios* termios) { val_t fields[6]; fields[0] = (val_t) termios->c_iflag; fields[1] = (val_t) termios->c_oflag; fields[2] = (val_t) termios->c_cflag; fields[3] = (val_t) termios->c_lflag; fields[4] = (val_t) cfgetispeed(termios); fields[5] = (val_t) cfgetospeed(termios); return alloc_record(fields, arraysize(fields)); }
/* * jx100_hispeed * switch into a higher baud rate. Unfortunately, the scanner only * supports 9600, 19200, 57600, 115200, and 172800 baud. On most Unix * systems this means that the best we can use is 19200. Linux provides * means to access the UART at a lower level and enable the wierder * rates. */ int jx100_hispeed ( int flag ) { if ( scanlines ) return -1; if ( flag && cfgetispeed ( &tt ) == B9600 ) { #ifdef linux /* set meaning of 38400 to be 115200 */ if ( ioctl ( scanfd, TIOCGSERIAL, &serial ) < 0 ) return -1; serial.flags &= ~ASYNC_SPD_MASK; serial.flags |= ASYNC_SPD_VHI; if ( ioctl ( scanfd, TIOCSSERIAL, &serial ) < 0 ) return -1; if ( send_acked ( "I1" "115200,N,8,1" ) < 0 ) return -1; cfsetispeed ( &tt, B38400 ); cfsetospeed ( &tt, B38400 ); #else if ( send_acked ( "I1" "19200,N,8,1" ) < 0 ) return -1; cfsetispeed ( &tt, B19200 ); cfsetospeed ( &tt, B19200 ); #endif if ( tcsetattr ( scanfd, TCSANOW, &tt ) < 0 ) return -1; } else if ( !flag && cfgetispeed ( &tt ) != B9600 ) { if ( send_acked ( "I1" "9600,N,8,1" ) < 0 ) return -1; cfsetispeed ( &tt, B9600 ); cfsetospeed ( &tt, B9600 ); if ( tcsetattr ( scanfd, TCSANOW, &tt ) < 0 ) return -1; #ifdef linux /* reset meaning of 38400 -- since we have set, assume can reset */ (void) ioctl ( scanfd, TIOCGSERIAL, &serial ); serial.flags &= ~ASYNC_SPD_MASK; (void) ioctl ( scanfd, TIOCSSERIAL, &serial ); #endif } return 0; }