serial.cpp

#include "serial.h"

Serial::Serial(const string& portname, unsigned int baud_rate) : serial(io) {
    open(portname, baud_rate);
}

Serial::~Serial() {
    close();
}

bool Serial::open(const string& portname, unsigned int baud_rate) {
    close(); // Close the port if it's already open
    try {
        serial.open(portname);
        serial.set_option(asio::serial_port_base::baud_rate(baud_rate));
    } catch (const std::exception& ex) {
        //cerr << "Error opening serial port: " << ex.what() << endl;
        return false;
    } catch (...) {
        //cerr << "Unknown error opening serial port" << endl;
        return false;
    }
    return true;
}

void Serial::close() {
    if (serial.is_open()) {
        serial.close();
    }
}

bool Serial::isOpen() {
    return serial.is_open();
}

// Does not include the delimiter in the returned string
string Serial::readUntilDelimiter(char delimiter) {
    string response;
    system::error_code ec;

    // Read one byte at a time until the delimiter is received.
    while (true) {
        char byte = readByte(ec);
        if (ec) {
            cerr << "Error reading from serial port: " << ec.message() << endl;
            return response; // Return what has been read so far on error
        }
        if (byte == delimiter) break;
        response += byte;
    }

    return response;
}

char Serial::readByte(system::error_code &ec) {
    char byte = '\0';
    asio::read(serial, asio::buffer(&byte, 1), ec);
    return byte;
}

char Serial::readByte(bool *errorOccurred) {
    system::error_code ec;
    char byte = readByte(ec);
    if (ec) {
        if (errorOccurred) *errorOccurred = true;
        return '\0';
    }
    if (errorOccurred) *errorOccurred = false;
    return byte;
}

char Serial::readByte() {
    system::error_code ec;
    char byte = readByte(ec);
    if (ec) return '\0';
    return byte;
}

size_t Serial::read(char* buffer, size_t length) {
    system::error_code ec;

    // Read data from the serial port
    size_t bytesRead = asio::read(serial, asio::buffer(buffer, length), ec);
    if (ec) {
        cerr << "Error reading from serial port: " << ec.message() << endl;
        return 0; // Return 0 on error
    }
    return bytesRead;
}

void Serial::write(const char* buffer, size_t length) {
    system::error_code ec;

    // Write data to the serial port
    asio::write(serial, asio::buffer(buffer, length), ec);
    if (ec) cerr << "Error writing to serial port: " << ec.message() << endl;
}

int Serial::pendingBytes() {
    if (!serial.is_open()) return 0;

    // Use ioctl to get the number of bytes available for reading
    int bytesAvailable = 0;
    if (ioctl(serial.native_handle(), FIONREAD, &bytesAvailable) == -1) {
        cerr << "Serial::pendingBytes: Error getting pending bytes: " << strerror(errno) << endl;
        serial.close();
        return -1;
    }
    return bytesAvailable;
}