GrblTester.cpp

/*
 * Copyright (C) 2022 CERN
 *
 * This software is provided 'as-is', without any express or implied
 * warranty.  In no event will the authors be held liable for any damages
 * arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *
 * 1. The origin of this software must not be misrepresented; you must not
 *    claim that you wrote the original software. If you use this software
 *    in a product, an acknowledgment in the product documentation would be
 *    appreciated but is not required.
 * 2. Altered source versions must be plainly marked as such, and must not be
 *    misrepresented as being the original software.
 * 3. This notice may not be removed or altered from any source distribution.
 *
 * Created on: 2022-05-06
 *     Author: Michal Mysior <mmysior> <michal.mysior@cern.ch>
 *
 */
 
#include "GrblTester.hpp"
 
#include <logger/Logger.hpp>
 
#include "Exception.hpp"
 
static const std::string s_loggerCat{"smc:edgegrbltester:sim"};
static const std::string s_crnl("\r\n");
 
using namespace logger;
using namespace std::chrono;
 
namespace grbl {
 
const milliseconds GrblTester::defaultExpectTimeout{500};
 
GrblTester::GrblTester(std::unique_ptr<GrblDeviceBase> grblDevice) :
    m_grblDevice{std::move(grblDevice)}
{}
 
bool GrblTester::expect(const std::string &regex,
                        std::chrono::milliseconds timeout)
{
    const ccut::Regex re(regex);
    return expect(re, timeout);
}
 
bool GrblTester::expect(const ccut::Regex &regex,
                        std::chrono::milliseconds timeout)
{
    const steady_clock::time_point deadline = steady_clock::now() + timeout;
 
    while (steady_clock::now() <= deadline)
    {
        steady_clock::time_point now = steady_clock::now();
        const milliseconds remaining = (now < deadline) ?
            duration_cast<milliseconds>(deadline - now) :
            milliseconds::zero();
 
        try
        {
            m_grblDevice->wait(remaining);
        }
        catch (smc::Exception &ex)
        {
            error(s_loggerCat) << ex.what();
            return false;
        }
        m_grblDevice->read();
        std::string line;
        while (m_grblDevice->takeLine(line))
        {
            if (regex.search(line))
            {
                debug(s_loggerCat) << "<-- " << line;
                return true;
            }
            else
            {
                debug(s_loggerCat) << "x<- " << line;
            }
        }
    }
    return false;
}
 
void GrblTester::sendCmd(const std::string &command)
{
    debug(s_loggerCat) << "--> " << command;
    m_grblDevice->write(command);
    m_grblDevice->write(s_crnl);
}
 
} // namespace grbl