main.cpp

#include <boost/asio.hpp>
#include <atomic>
#include <chrono>
#include <iostream>
#include <string>
#include <thread>

using namespace boost::asio;
using namespace std::chrono_literals;

class BleuIOScanner {
public:
    BleuIOScanner(const std::string& port_name, unsigned int baud_rate = 57600)
        : io_(),
          serial_(io_),
          running_(false) {
        serial_.open(port_name);
        serial_.set_option(serial_port_base::baud_rate(baud_rate));
        serial_.set_option(serial_port_base::character_size(8));
        serial_.set_option(serial_port_base::parity(serial_port_base::parity::none));
        serial_.set_option(serial_port_base::stop_bits(serial_port_base::stop_bits::one));
        serial_.set_option(serial_port_base::flow_control(serial_port_base::flow_control::none));
    }

    ~BleuIOScanner() {
        stopReader();
        if (serial_.is_open()) {
            boost::system::error_code ec;
            serial_.close(ec);
        }
    }

    void startReader() {
        if (running_) return;
        running_ = true;
        doRead();
        io_thread_ = std::thread([this]() {
            io_.run();
        });
    }

    void stopReader() {
        if (!running_) return;

        running_ = false;

        boost::system::error_code ec;
        serial_.cancel(ec);
        io_.stop();

        if (io_thread_.joinable()) {
            io_thread_.join();
        }
    }

    void sendCommand(const std::string& cmd) {
        std::string full = cmd + "\r\n";
        write(serial_, buffer(full));
    }

private:
    void doRead() {
        serial_.async_read_some(
            buffer(read_buf_, sizeof(read_buf_)),
            [this](const boost::system::error_code& ec, std::size_t bytes_transferred) {
                if (!ec) {
                    std::string data(read_buf_, bytes_transferred);
                    std::cout << data << std::flush;

                    if (running_) {
                        doRead();
                    }
                } else {
                    if (running_ && ec != boost::asio::error::operation_aborted) {
                        std::cerr << "\nRead error: " << ec.message() << std::endl;
                    }
                }
            });
    }

private:
    io_context io_;
    serial_port serial_;
    std::thread io_thread_;
    std::atomic<bool> running_;
    char read_buf_[1024];
};

int main() {
    try {
        std::string port_name;
        int seconds = 3;
        port_name ="/dev/cu.usbmodem4048FDE52CF21";
        /* std::cout << "Enter BleuIO serial port (example: /dev/cu.usbmodemXXXX): ";
        std::getline(std::cin, port_name); */

        std::cout << "Enter scan duration in seconds: ";
        std::cin >> seconds;

        if (seconds <= 0) {
            std::cerr << "Scan duration must be greater than 0." << std::endl;
            return 1;
        }

        BleuIOScanner bleuio(port_name);

        std::cout << "\nConnected to " << port_name << std::endl;
        std::cout << "\nStarting reader...\n" << std::endl;

        bleuio.startReader();

        // Small delay so reader is ready
        std::this_thread::sleep_for(300ms);

        

        std::cout << "\nPutting BleuIO in Central role...\n" << std::endl;
        bleuio.sendCommand("AT+CENTRAL");
        std::this_thread::sleep_for(1s);

        std::cout << "\nScanning for " << seconds << " second(s)...\n" << std::endl;
        bleuio.sendCommand("AT+GAPSCAN=" + std::to_string(seconds));

        // Wait slightly longer than scan duration so output can complete
        std::this_thread::sleep_for(std::chrono::seconds(seconds) + 2s);

        std::cout << "\nScan finished.\n" << std::endl;

        bleuio.stopReader();
    }
    catch (const std::exception& ex) {
        std::cerr << "Error: " << ex.what() << std::endl;
        return 1;
    }

    return 0;
}