mirror of
https://github.com/ultimatepp/ultimatepp.git
synced 2026-05-16 06:05:58 -06:00
575 lines
11 KiB
C++
575 lines
11 KiB
C++
#include "Serial.h"
|
|
|
|
#ifdef PLATFORM_OSX11
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
#include <fcntl.h>
|
|
#include <sys/ioctl.h>
|
|
#include <errno.h>
|
|
#include <paths.h>
|
|
#include <termios.h>
|
|
#include <sysexits.h>
|
|
#include <sys/param.h>
|
|
#include <sys/select.h>
|
|
#include <sys/time.h>
|
|
#include <time.h>
|
|
#include <CoreFoundation/CoreFoundation.h>
|
|
#include <IOKit/IOKitLib.h>
|
|
#include <IOKit/serial/IOSerialKeys.h>
|
|
#include <IOKit/IOBSD.h>
|
|
|
|
namespace Upp
|
|
{
|
|
|
|
static bool __IsSymLink(const char *path)
|
|
{
|
|
struct stat stf;
|
|
lstat(path, &stf);
|
|
return S_ISLNK(stf.st_mode);
|
|
}
|
|
|
|
dword Serial::stdBauds[] =
|
|
{
|
|
0, 50, 75, 110, 134, 150,
|
|
200, 300, 600, 1200, 1800,
|
|
2400, 4800, 9600, 19200,
|
|
38400, 57600, 115200, 230400, 345600, 460800
|
|
};
|
|
|
|
int Serial::stdBaudsCount = sizeof(Serial::stdBauds) / sizeof(dword);
|
|
|
|
// constructor
|
|
Serial::Serial()
|
|
{
|
|
isError = false;
|
|
errCode = Ok;
|
|
fd = -1;
|
|
}
|
|
|
|
Serial::Serial(String const &port, dword speed, byte parity, byte bits, byte stopBits)
|
|
{
|
|
isError = false;
|
|
errCode = Ok;
|
|
fd = -1;
|
|
Open(port, speed, parity, bits, stopBits);
|
|
}
|
|
|
|
// destructor
|
|
Serial::~Serial()
|
|
{
|
|
Close();
|
|
}
|
|
|
|
// open the port
|
|
bool Serial::Open(String const &port, dword lSpeed, byte parity, byte bits, byte stopBits)
|
|
{
|
|
static int stdBaudCodes[] =
|
|
{
|
|
B0, B50, B75, B110, B134, B150,
|
|
B200, B300, B600, B1200, B1800,
|
|
B2400, B4800, B9600, B19200,
|
|
B38400, B57600, B115200, B230400
|
|
};
|
|
|
|
fd = open(port, O_RDWR | O_NOCTTY | O_NONBLOCK);
|
|
if (fd < 0)
|
|
{
|
|
fd = -1;
|
|
isError = true;
|
|
errCode = DeviceError;
|
|
return false;
|
|
}
|
|
if (ioctl(fd, TIOCEXCL) == -1)
|
|
{
|
|
// unable to get exclusive access to port
|
|
close(fd);
|
|
fd = -1;
|
|
isError = true;
|
|
errCode = DeviceError;
|
|
return false;
|
|
}
|
|
|
|
unsigned int ctl;
|
|
if (ioctl(fd, TIOCMGET, &ctl) < 0)
|
|
{
|
|
// unable to query serial ports signals
|
|
close(fd);
|
|
fd = -1;
|
|
isError = true;
|
|
errCode = DeviceError;
|
|
return false;
|
|
}
|
|
ctl &= ~(TIOCM_DTR | TIOCM_RTS);
|
|
if (ioctl(fd, TIOCMSET, &ctl) < 0)
|
|
{
|
|
// unable to control serial ports signals
|
|
close(fd);
|
|
fd = -1;
|
|
isError = true;
|
|
errCode = DeviceError;
|
|
return false;
|
|
}
|
|
|
|
// sets interface parameters
|
|
struct termios tty;
|
|
memset(&tty, 0, sizeof tty);
|
|
if (tcgetattr(fd, &tty) != 0)
|
|
{
|
|
Close();
|
|
isError = true;
|
|
errCode = DeviceError;
|
|
return false;
|
|
}
|
|
|
|
//// CFLAG /////
|
|
|
|
int idx = GetStandardBaudRates().Find(lSpeed);
|
|
dword speed;
|
|
if (idx < 0)
|
|
{
|
|
// custom speed
|
|
// @@ maybe add support later
|
|
Close();
|
|
isError = true;
|
|
errCode = InvalidSpeed;
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
// standard speed
|
|
speed = stdBaudCodes[idx];
|
|
cfsetospeed(&tty, speed);
|
|
cfsetispeed(&tty, speed);
|
|
}
|
|
|
|
// parity
|
|
tty.c_cflag &= ~(PARENB | PARODD);
|
|
switch (parity)
|
|
{
|
|
case ParityNone:
|
|
break;
|
|
case ParityEven:
|
|
tty.c_cflag |= PARENB;
|
|
break;
|
|
case ParityOdd:
|
|
tty.c_cflag |= PARENB | PARODD;
|
|
break;
|
|
default:
|
|
Close();
|
|
isError = true;
|
|
errCode = InvalidParity;
|
|
return false;
|
|
}
|
|
|
|
// set data size
|
|
switch (bits)
|
|
{
|
|
case 5:
|
|
tty.c_cflag = (tty.c_cflag & ~CSIZE) | CS5;
|
|
break;
|
|
case 6:
|
|
tty.c_cflag = (tty.c_cflag & ~CSIZE) | CS6;
|
|
break;
|
|
case 7:
|
|
tty.c_cflag = (tty.c_cflag & ~CSIZE) | CS7;
|
|
break;
|
|
case 8:
|
|
tty.c_cflag = (tty.c_cflag & ~CSIZE) | CS8;
|
|
break;
|
|
default:
|
|
Close();
|
|
isError = true;
|
|
errCode = InvalidSize;
|
|
return false;
|
|
}
|
|
|
|
// stop bits
|
|
if (stopBits == 1)
|
|
tty.c_cflag &= ~CSTOPB;
|
|
else if (stopBits == 2)
|
|
tty.c_cflag |= CSTOPB;
|
|
else
|
|
{
|
|
Close();
|
|
isError = true;
|
|
errCode = InvalidStopBits;
|
|
return false;
|
|
}
|
|
|
|
// ignore modem controls, enable reading
|
|
tty.c_cflag |= (CLOCAL | CREAD);
|
|
|
|
// no rts/cts
|
|
tty.c_cflag &= ~CRTSCTS;
|
|
|
|
//// LFLAG /////
|
|
|
|
// no signaling chars, no echo, no canonical mode
|
|
tty.c_lflag = 0;
|
|
// tty.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);
|
|
|
|
//// IFLAG /////
|
|
|
|
// disable IGNBRK for mismatched speed tests; otherwise receive break as \000 chars
|
|
// disable break processing
|
|
tty.c_iflag &= ~IGNBRK;
|
|
// tty.c_iflag |= IGNBRK;
|
|
|
|
// DO NOT ignore carriage returns
|
|
tty.c_iflag &= ~IGNCR;
|
|
|
|
// DO NOT translate cr/lf
|
|
tty.c_iflag &= ~ICRNL;
|
|
|
|
// DO NOT translate cr
|
|
tty.c_iflag &= ~INLCR;
|
|
|
|
// shut off xon/xoff ctrl
|
|
tty.c_iflag &= ~(IXON | IXOFF | IXANY);
|
|
|
|
//// OFLAG /////
|
|
|
|
// no remapping, no delays
|
|
tty.c_oflag = 0;
|
|
|
|
//// CONTROL CHARACTERS /////
|
|
|
|
// read doesn't block
|
|
tty.c_cc[VMIN] = 0;
|
|
|
|
// 0.5 seconds read timeout
|
|
tty.c_cc[VTIME] = 0;
|
|
|
|
/*
|
|
RLOG("CFLAGS : " << tty.c_cflag);
|
|
RLOG("LFLAGS : " << tty.c_lflag);
|
|
RLOG("IFLAGS : " << tty.c_iflag);
|
|
RLOG("OFLAGS : " << tty.c_oflag);
|
|
*/
|
|
|
|
if (tcsetattr(fd, TCSANOW, &tty) != 0)
|
|
{
|
|
Close();
|
|
isError = true;
|
|
errCode = DeviceError;
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// close the port
|
|
void Serial::Close(void)
|
|
{
|
|
if (fd != -1)
|
|
close(fd);
|
|
fd = -1;
|
|
isError = false;
|
|
errCode = Ok;
|
|
}
|
|
|
|
// control DTR and RTS lines
|
|
bool Serial::SetDTR(bool on)
|
|
{
|
|
unsigned int ctl;
|
|
int r;
|
|
|
|
r = ioctl(fd, TIOCMGET, &ctl);
|
|
if (r < 0)
|
|
return false;
|
|
|
|
if (on)
|
|
ctl |= TIOCM_DTR;
|
|
else
|
|
ctl &= ~TIOCM_DTR;
|
|
|
|
r = ioctl(fd, TIOCMSET, &ctl);
|
|
if (r < 0)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool Serial::SetRTS(bool on)
|
|
{
|
|
unsigned int ctl;
|
|
int r;
|
|
|
|
r = ioctl(fd, TIOCMGET, &ctl);
|
|
if (r < 0)
|
|
return false;
|
|
|
|
if (on)
|
|
ctl |= TIOCM_RTS;
|
|
else
|
|
ctl &= ~TIOCM_RTS;
|
|
|
|
r = ioctl(fd, TIOCMSET, &ctl);
|
|
if (r < 0)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
// flush data
|
|
bool Serial::FlushInput(void)
|
|
{
|
|
if (fd == -1)
|
|
return false;
|
|
return !tcflush(fd, TCIFLUSH);
|
|
}
|
|
|
|
bool Serial::FlushOutput(void)
|
|
{
|
|
if (fd == -1)
|
|
return false;
|
|
return !tcflush(fd, TCOFLUSH);
|
|
}
|
|
|
|
bool Serial::FlushAll(void)
|
|
{
|
|
if (fd == -1)
|
|
return false;
|
|
return !tcflush(fd, TCIOFLUSH);
|
|
}
|
|
|
|
// check if data is available on serial port
|
|
int Serial::Avail(void)
|
|
{
|
|
if (fd == -1)
|
|
return false;
|
|
int bytes = 0;
|
|
ioctl(fd, FIONREAD, &bytes);
|
|
return bytes;
|
|
}
|
|
|
|
// read a single byte, block 'timeout' milliseconds
|
|
bool Serial::Read(byte &c, uint32_t timeout)
|
|
{
|
|
char buf[1];
|
|
|
|
uint32_t tim = msecs() + timeout;
|
|
for (;;)
|
|
{
|
|
if (!read(fd, buf, 1))
|
|
{
|
|
if ((uint32_t)msecs() > tim)
|
|
return false;
|
|
continue;
|
|
}
|
|
c = (byte)buf[0];
|
|
return true;
|
|
}
|
|
}
|
|
|
|
bool Serial::Read(char &c, uint32_t timeout)
|
|
{
|
|
char buf[1];
|
|
|
|
uint32_t tim = msecs() + timeout;
|
|
for (;;)
|
|
{
|
|
if (!read(fd, buf, 1))
|
|
{
|
|
if ((uint32_t)msecs() > tim)
|
|
return false;
|
|
continue;
|
|
}
|
|
c = buf[0];
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// read data, requested amount, blocks 'timeout' milliseconds
|
|
// return number of bytes got
|
|
uint32_t Serial::Read(uint8_t *buf, uint32_t reqSize, uint32_t timeout)
|
|
{
|
|
if (!reqSize || !buf)
|
|
return 0;
|
|
|
|
uint32_t n;
|
|
uint32_t tim = msecs() + timeout;
|
|
uint32_t req = reqSize;
|
|
while (req)
|
|
{
|
|
n = read(fd, buf, req);
|
|
req -= n;
|
|
buf += n;
|
|
if (!req || msecs() > (int)tim)
|
|
break;
|
|
}
|
|
return reqSize - req;
|
|
}
|
|
|
|
// read data, requested amount, blocks 'timeout' milliseconds
|
|
// if reqSize == 0 just read all available data, waiting for 'timeout' if != 0
|
|
String Serial::Read(uint32_t reqSize, uint32_t timeout)
|
|
{
|
|
char buf[1001];
|
|
buf[1000] = 0;
|
|
String data;
|
|
|
|
size_t n;
|
|
uint32_t tim = msecs() + timeout;
|
|
if (reqSize)
|
|
{
|
|
n = min(reqSize, (uint32_t)1000);
|
|
while (reqSize)
|
|
{
|
|
n = read(fd, buf, n);
|
|
if (!n)
|
|
{
|
|
if ((uint32_t)msecs() > tim)
|
|
break;
|
|
n = min(reqSize, (uint32_t)1000);
|
|
continue;
|
|
}
|
|
tim = msecs() + timeout;
|
|
if (n)
|
|
{
|
|
reqSize -= n;
|
|
data.Cat(buf, n);
|
|
}
|
|
n = min(reqSize, (uint32_t)1000);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (;;)
|
|
{
|
|
n = read(fd, buf, 1000);
|
|
if (!n)
|
|
{
|
|
if ((uint32_t)msecs() > tim)
|
|
break;
|
|
continue;
|
|
}
|
|
tim = msecs() + timeout;
|
|
if (n)
|
|
data.Cat(buf, n);
|
|
}
|
|
}
|
|
return data;
|
|
}
|
|
|
|
// write a single byte
|
|
bool Serial::Write(char c, uint32_t timeout)
|
|
{
|
|
if (!timeout)
|
|
return write(fd, &c, 1);
|
|
|
|
uint32_t tim = msecs() + timeout;
|
|
for (;;)
|
|
{
|
|
if (write(fd, &c, 1) == 1)
|
|
return true;
|
|
if ((uint32_t)msecs() > tim)
|
|
break;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// write buffer
|
|
bool Serial::Write(uint8_t const *buf, uint32_t len, uint32_t timeout)
|
|
{
|
|
if (!timeout)
|
|
return (write(fd, buf, len) == len);
|
|
|
|
uint32_t tim = msecs() + timeout;
|
|
const uint8_t *dPos = buf;
|
|
for (;;)
|
|
{
|
|
int written = write(fd, dPos, len);
|
|
if (written == len)
|
|
return true;
|
|
if (written >= 0)
|
|
{
|
|
dPos += written;
|
|
len -= written;
|
|
continue;
|
|
}
|
|
if ((uint32_t)msecs() >= tim)
|
|
break;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// writes string
|
|
bool Serial::Write(String const &data, uint32_t timeout)
|
|
{
|
|
return Write((const uint8_t *)~data, data.GetCount(), timeout);
|
|
}
|
|
|
|
// check if opened
|
|
bool Serial::IsOpened(void) const
|
|
{
|
|
return fd != -1;
|
|
}
|
|
|
|
static void macos_ports(io_iterator_t *PortIterator, ArrayMap<String, String> &list)
|
|
{
|
|
io_object_t modemService;
|
|
CFTypeRef nameCFstring;
|
|
char s[MAXPATHLEN];
|
|
|
|
while ((modemService = IOIteratorNext(*PortIterator)))
|
|
{
|
|
nameCFstring = IORegistryEntryCreateCFProperty(modemService, CFSTR(kIOCalloutDeviceKey), kCFAllocatorDefault, 0);
|
|
if (nameCFstring)
|
|
{
|
|
if (CFStringGetCString((const __CFString *)nameCFstring, s, sizeof(s), kCFStringEncodingASCII))
|
|
list.Add(s, "");
|
|
|
|
CFRelease(nameCFstring);
|
|
}
|
|
IOObjectRelease(modemService);
|
|
}
|
|
}
|
|
|
|
// get a list of connected serial ports
|
|
// for old-style serials, check if something is connected
|
|
// for usb ones, return also a description
|
|
ArrayMap<String, String> Serial::GetSerialPorts(void)
|
|
{
|
|
ArrayMap<String, String> res;
|
|
|
|
mach_port_t masterPort;
|
|
CFMutableDictionaryRef classesToMatch;
|
|
io_iterator_t serialPortIterator;
|
|
|
|
if (IOMasterPort(0, &masterPort) != KERN_SUCCESS)
|
|
return res;
|
|
|
|
// a usb-serial adaptor is usually considered a "modem",
|
|
// especially when it implements the CDC class spec
|
|
classesToMatch = IOServiceMatching(kIOSerialBSDServiceValue);
|
|
if (!classesToMatch)
|
|
return res;
|
|
|
|
CFDictionarySetValue(classesToMatch, CFSTR(kIOSerialBSDTypeKey), CFSTR(kIOSerialBSDModemType));
|
|
if (IOServiceGetMatchingServices(masterPort, classesToMatch, &serialPortIterator) != KERN_SUCCESS)
|
|
return res;
|
|
|
|
macos_ports(&serialPortIterator, res);
|
|
IOObjectRelease(serialPortIterator);
|
|
|
|
// but it might be considered a "rs232 port", so repeat this search for rs232 ports
|
|
classesToMatch = IOServiceMatching(kIOSerialBSDServiceValue);
|
|
if (!classesToMatch)
|
|
return res;
|
|
|
|
CFDictionarySetValue(classesToMatch, CFSTR(kIOSerialBSDTypeKey), CFSTR(kIOSerialBSDRS232Type));
|
|
if (IOServiceGetMatchingServices(masterPort, classesToMatch, &serialPortIterator) != KERN_SUCCESS)
|
|
return res;
|
|
macos_ports(&serialPortIterator, res);
|
|
IOObjectRelease(serialPortIterator);
|
|
|
|
return res;
|
|
}
|
|
|
|
} // END_UPP_NAMESPACE
|
|
|
|
#endif
|