/**
* Open the specified serial port.
*
* @param serial Previously initialized serial port structure.
* @param flags Flags to use when opening the serial port. Possible flags
* include SERIAL_RDWR, SERIAL_RDONLY, SERIAL_NONBLOCK.
*
* If the serial structure contains a serialcomm string, it will be
* passed to serial_set_paramstr() after the port is opened.
*
* @return SR_OK on success, SR_ERR on failure.
*/
SR_PRIV int serial_open(struct sr_serial_dev_inst *serial, int flags)
{
int ret;
char *error;
int sp_flags = 0;
if (!serial) {
sr_dbg("Invalid serial port.");
return SR_ERR;
}
sr_spew("Opening serial port '%s' (flags %d).", serial->port, flags);
sp_get_port_by_name(serial->port, &serial->data);
if (flags & SERIAL_RDWR)
sp_flags = (SP_MODE_READ | SP_MODE_WRITE);
else if (flags & SERIAL_RDONLY)
sp_flags = SP_MODE_READ;
serial->nonblocking = (flags & SERIAL_NONBLOCK) ? 1 : 0;
ret = sp_open(serial->data, sp_flags);
switch (ret) {
case SP_ERR_ARG:
sr_err("Attempt to open serial port with invalid parameters.");
return SR_ERR_ARG;
case SP_ERR_FAIL:
error = sp_last_error_message();
sr_err("Error opening port: %s.", error);
sp_free_error_message(error);
return SR_ERR;
}
#ifndef _WIN32
sp_get_port_handle(serial->data, &serial->fd);
#endif
if (serial->serialcomm)
return serial_set_paramstr(serial, serial->serialcomm);
else
return SR_OK;
}
static void EventLoop()
{
sigset_t oldMask;
sigset_t newMask;
sigemptyset(&newMask);
sigaddset(&newMask, SIGTERM);
sigaddset(&newMask, SIGINT);
if(sigprocmask(SIG_BLOCK, &newMask, &oldMask) < 0)
FatalError("sigprocmask");
int serialPortFD = -1;
HandleSerialPortError(sp_get_port_handle(SerialPort, &serialPortFD));
enum ConversionMode incomingConversion;
enum ConversionMode outgoingConversion;
if(ConvertCrLf)
{
incomingConversion = CONVERSION_CRLF_TO_LF;
outgoingConversion = CONVERSION_LF_TO_CRLF;
}
else
{
incomingConversion = CONVERSION_NONE;
outgoingConversion = CONVERSION_NONE;
}
while(!StopEventLoop)
{
fd_set fdReadSet;
FD_ZERO(&fdReadSet);
FD_SET(STDIN_FILENO, &fdReadSet);
FD_SET(serialPortFD, &fdReadSet);
const int maxFD = serialPortFD;
const int ready = pselect(maxFD+1, &fdReadSet, NULL, NULL, NULL, &oldMask);
if(ready < 0 && errno != EINTR)
{
FatalError("select");
}
else if(StopEventLoop)
{
puts("exit");
break;
}
else if(ready == 0)
{
puts("not ready");
continue;
}
else
{
if(FD_ISSET(STDIN_FILENO, &fdReadSet))
{
Pump(STDIN_FILENO, serialPortFD, outgoingConversion);
}
if(FD_ISSET(serialPortFD, &fdReadSet))
{
Pump(serialPortFD, STDOUT_FILENO, incomingConversion);
}
}
}
}
int serial_send(struct sp_port *my_port, const void *command, size_t write_bytes_count, void *response) {
int ret, read_count=6;
if (DO_BLOCKING_READ_WRITE) {
unsigned int timeout = READ_WRITE_TIMEOUT_SEC*1000;
ret = sp_blocking_write(my_port, command, write_bytes_count, timeout);
if (ret <= 0) {
printf("Failed to write serial bytes.\n");
return 0;
}
ret = sp_blocking_read(my_port, response, (size_t)read_count, timeout);
} else {
int fd;
ret = sp_get_port_handle(my_port,&fd);
if (ret != SP_OK) {
printf("Failed to get port handle for nonblocking read/write.\n");
}
fd_set fds;
FD_ZERO(&fds);
FD_SET(fd,&fds);
struct timespec ts;
ts.tv_sec = READ_WRITE_TIMEOUT_SEC;
ret = pselect(fd+1, NULL, &fds, NULL, &ts, NULL);
if (ret < 0 && errno != EINTR) {
printf("Error in pselect for write.\n");
return 0;
} else if (ret == 0) {
printf("Timeout while waiting to write.\n");
return 0;
}
ret = sp_nonblocking_write(my_port, command, write_bytes_count);
FD_ZERO(&fds);
FD_SET(fd,&fds);
ts.tv_sec = READ_WRITE_TIMEOUT_SEC;
ret = pselect(fd+1, &fds, NULL, NULL, &ts, NULL);
if (ret < 0 && errno != EINTR) {
printf("Error in pselect for write.\n");
return 0;
} else if (ret == 0) {
printf("Timeout while waiting to write.\n");
return 0;
}
ret = sp_nonblocking_read(my_port, response, (size_t)read_count);
}
if (ret < read_count) {
printf("Successful write to serial, but failed on serial read.\n");
return 0;
} else {
return ret;
}
}
