eddy/snippets_library
1
0
Fork 0
mirror of https://github.com/eddyem/snippets_library.git synced 2026-03-20 00:30:56 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
3903250fbef4d43ba0a26dd3d4c12c6ef9175934
snippets_library/term2.c

302 lines
8.8 KiB
C
Raw Blame History

/*
* This file is part of the Snippets project.
* Copyright 2024 Edward V. Emelianov <edward.emelianoff@gmail.com>.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <unistd.h> // tcsetattr, close, read, write
#include <fcntl.h> // read
#include <stdio.h> // printf, getchar, fopen, perror
#include <stdlib.h> // exit, realloc
#include <string.h> // memcpy
#include <sys/ioctl.h> // ioctl
#include <sys/stat.h> // read
#include <sys/time.h> // gettimeofday
#include <time.h> // time
#include <unistd.h> // usleep, tcsetattr, close, read, write
#include "usefull_macros.h"
#define LOGBUFSZ (1024)
// return FALSE if failed
static int parse_format(const char *iformat, tcflag_t *flags){
tcflag_t f = 0;
if(!iformat){ // default
if(flags) *flags = CS8;
return TRUE;
}
if(strlen(iformat) != 3) goto someerr;
switch(iformat[0]){
case '5':
f |= CS5;
break;
case '6':
f |= CS6;
break;
case '7':
f |= CS7;
break;
case '8':
f |= CS8;
break;
default:
goto someerr;
}
switch(iformat[1]){
case '0': // always 0
f |= PARENB | CMSPAR;
break;
case '1': // always 1
f |= PARENB | CMSPAR | PARODD;
break;
case 'E': // even
f |= PARENB;
break;
case 'N': // none
break;
case 'O': // odd
f |= PARENB | PARODD;
break;
default:
goto someerr;
}
switch(iformat[2]){
case '1':
break;
case '2':
f |= CSTOPB;
break;
default:
goto someerr;
}
if(flags) *flags = f;
return TRUE;
someerr:
WARNX(_("Wrong USART format \"%s\"; use NPS, where N: 5..8; P: N/E/O/1/0, S: 1/2"), iformat);
return FALSE;
}
/**
* @brief sl_tty_fdescr - open terminal device and give it's file descriptor
* @param comdev - path to device
* @param speed - baudrate
* @param exclusive - ==1 for exclusive open
* @return fd or -1 in case of error
*/
int sl_tty_fdescr(const char *comdev, const char *format, int speed, int exclusive){
if(!comdev || speed < 1) return -1;
tcflag_t flags;
if(!parse_format(format, &flags)) return -1;
DBG("open");
int comfd = open(comdev, O_RDWR|O_NOCTTY);
if(comfd < 0){
WARN(_("Can't use port %s"), comdev);
return -1;
}
DBG("fd=%d", comfd);
struct termios2 newtty;
if(ioctl(comfd, TCGETS2, &newtty)){ // Get settings
WARN(_("Can't get old TTY settings"));
return -1;
}
DBG("change termios flags");
newtty.c_lflag = 0; // ~(ICANON | ECHO | ECHOE | ISIG)
newtty.c_iflag = 0; // don't do any changes in input stream
newtty.c_oflag = 0; // don't do any changes in output stream
newtty.c_cflag = BOTHER | flags | CREAD | CLOCAL; // other speed, user format, RW, ignore line ctrl
newtty.c_ispeed = speed;
newtty.c_ospeed = speed;
newtty.c_cc[VMIN] = 0; // non-canonical mode
newtty.c_cc[VTIME] = 1;
if(ioctl(comfd, TCSETS2, &newtty)){
WARN(_("Can't apply new TTY settings"));
close(comfd);
return -1;
}
DBG("OK, check");
if(ioctl(comfd, TCGETS2, &newtty)){ // Get settings
WARN(_("Can't get old TTY settings"));
return -1;
}
if(exclusive){
DBG("make exclusive");
if(ioctl(comfd, TIOCEXCL)){
WARN(_("Can't do exclusive open"));
close(comfd);
return -1;
}
}
DBG("device %s opened", comdev);
return comfd;
}
/**
* @brief restore_tty - restore opened TTY to previous state and close it
*/
void sl_tty_close(sl_tty_t **descr){
if(descr == NULL || *descr == NULL) return;
sl_tty_t *d = *descr;
if(d->comfd > -1){
DBG("close");
close(d->comfd);
}
DBG("Free mem");
FREE(d->portname);
FREE(d->buf);
FREE(d->format);
FREE(*descr);
DBG("tty closed");
}
/**
* @brief sl_tty_new - create new TTY structure with partially filled fields
* @param comdev - TTY device filename
* @param speed - speed (number)
* @param bufsz - size of buffer for input data (or 0 if opened only to write)
* @return pointer to TTY structure if all OK
*/
sl_tty_t *sl_tty_new(char *comdev, int speed, size_t bufsz){
sl_tty_t *descr = MALLOC(sl_tty_t, 1);
descr->portname = strdup(comdev);
descr->speed = speed;
if(!descr->portname){
WARNX(_("Port name is missing"));
}else{
if(bufsz){
descr->buf = MALLOC(char, bufsz+1);
descr->bufsz = bufsz;
descr->comfd = -1;
DBG("sl_tty_t created");
return descr;
}else WARNX(_("Need non-zero buffer for TTY device"));
}
FREE(descr->portname);
FREE(descr);
return NULL;
}
/**
* @brief sl_tty_setformat - set format for just created tty object
* @param d - descriptor created with sl_tty_new
* @param format - string like "7O2" (maybe NULL for default, 8N1)
* @return FALSE if format is wrong
*/
int sl_tty_setformat(sl_tty_t *d, const char *format){
if(!d) return FALSE;
if(!format) return TRUE; // default format
if(!parse_format(format, NULL)) return FALSE;
d->format = strdup(format);
return TRUE;
}
/**
* @brief sl_tty_open - init & open tty device
* @param d - already filled structure (with new_tty or by hands)
* @param exclusive - == 1 to make exclusive open
* @return pointer to TTY structure if all OK
*/
sl_tty_t *sl_tty_open(sl_tty_t *d, int exclusive){
if(!d || !d->portname) return NULL;
if(exclusive) d->exclusive = TRUE;
else d->exclusive = FALSE;
DBG("ex: %d", exclusive);
int comfd = sl_tty_fdescr(d->portname, d->format, d->speed, d->exclusive);
if(comfd < 0) return NULL;
struct termios2 tty;
if(ioctl(comfd, TCGETS2, &tty)){ // Get settings
WARN(_("Can't get current TTY settings"));
}else{
if(d->speed != (int)tty.c_ispeed || d->speed != (int)tty.c_ospeed){
WARNX(_("Can't set exact speed %d"), d->speed);
d->speed = (int)tty.c_ispeed;
}
}
d->comfd = comfd;
DBG("sl_tty_t ready");
return d;
}
static struct timeval tvdefault = {.tv_sec = 0, .tv_usec = 5000};
/**
* @brief sl_tty_tmout - set timeout for select() on reading
* // WARNING! This function changes timeout for ALL opened ports!
* @param usec - microseconds of timeout
* @return -1 if usec < 0, 0 if all OK
*/
int sl_tty_tmout(double usec){
if(usec < 0.) return -1;
tvdefault.tv_sec = 0;
if(usec > 999999){
tvdefault.tv_sec = (__time_t)(usec / 1e6);
usec -= tvdefault.tv_sec * 1e6;
}
tvdefault.tv_usec = (__suseconds_t) usec;
return 0;
}
/**
* @brief sl_tty_read - read data from TTY with 10ms timeout
* @param buff (o) - buffer for data read
* @param length - buffer len
* @return amount of bytes read or -1 if disconnected
*/
int sl_tty_read(sl_tty_t *d){
if(!d || d->comfd < 0) return 0;
size_t L = 0;
ssize_t l;
size_t length = d->bufsz;
char *ptr = d->buf;
fd_set rfds;
struct timeval tv;
int retval;
do{
l = 0;
FD_ZERO(&rfds);
FD_SET(d->comfd, &rfds);
//memcpy(&tv, &tvdefault, sizeof(struct timeval));
tv = tvdefault;
retval = select(d->comfd + 1, &rfds, NULL, NULL, &tv);
if(!retval) break;
if(retval < 0){
if(errno == EINTR) continue;
return -1;
}
if(FD_ISSET(d->comfd, &rfds)){
l = read(d->comfd, ptr, length);
if(l < 1) return -1; // disconnected
ptr += l; L += l;
length -= l;
}
}while(l && length);
d->buflen = L;
d->buf[L] = 0;
return (size_t)L;
}
/**
* @brief sl_tty_write - write data to serial port
* @param buff (i) - data to write
* @param length - its length
* @return 0 if all OK
*/
int sl_tty_write(int comfd, const char *buff, size_t length){
ssize_t L = write(comfd, buff, length);
if((size_t)L != length){
WARN("Write error");
return 1;
}
return 0;
}
Reference in New Issue View Git Blame Copy Permalink