GrblDeviceBase.cpp

/*
** Copyright (C) 2020 Sylvain Fargier
**
** 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-02-13T22:52:09+01:00
**     Author: Sylvain Fargier <fargie_s> <sylvain.fargier@cern.ch>
**
*/
 
#include "GrblDeviceBase.hpp"
 
#include <ccut/Regex.hpp>
#include <ccut/utils.hpp>
#include <logger/Logger.hpp>
 
#include "GrblParser.hpp"
 
using namespace grbl;
using namespace std::chrono;
using namespace logger;
 
static const std::string s_loggerCat{"smc:grbldevice"};
static const std::string s_crnl("\r\n");
 
const milliseconds GrblDeviceBase::defaultSendTimeout(1000);
 
void GrblDeviceBase::fetch(const std::chrono::milliseconds &timeout)
{
    if (wait(timeout))
    {
        read();
        std::string line;
        while (takeLine(line))
        {
            debug(s_loggerCat) << "<~- " << line;
            dataSignal(line);
        }
    }
}
 
grbl::ErrorCode GrblDeviceBase::send(const std::string &cmd,
                                     std::function<bool(const std::string &)> msg,
                                     const std::chrono::milliseconds &timeout)
{
    const steady_clock::time_point deadline = steady_clock::now() + timeout;
 
    debug(s_loggerCat) << "--> " << cmd;
    if (cmd.length() > 0)
    {
        write(cmd);
        write(s_crnl);
    }
    bool msgConfirmed = false;
    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();
 
        wait(remaining);
        read();
        std::string line;
        while (this->takeLine(line))
        {
            debug(s_loggerCat) << "<-- " << line;
            switch (GrblParser::getLineType(line))
            {
            case GrblParser::LineType::OkReply:
            {
                if (msg && !msgConfirmed)
                    return grbl::CustomErrorCode::NoPayload;
                return 0;
            }
            case GrblParser::LineType::ErrorReply:
            {
                ErrorCode errorCode;
                if (GrblParser::parseErrorReply(line, errorCode))
                    return errorCode;
                error(s_loggerCat) << "Cannot parse error code: " << line;
                return grbl::CustomErrorCode::InternalError;
            }
            default:
                try
                {
                    if (bool(msg) && msg(line))
                        msgConfirmed = true;
                    else
                        dataSignal(line);
                }
                catch (const grbl::ErrorCode &rc)
                {
                    return rc;
                }
                catch (std::exception &ex)
                {
                    error(s_loggerCat)
                        << "exception in client callback: " << ex.what();
                }
                break;
            }
        }
    }
    return grbl::CustomErrorCode::Timeout;
}
 
grbl::ErrorCode GrblDeviceBase::sendRealtime(
    const std::string &cmd,
    std::function<bool(const std::string &)> msg,
    const std::chrono::milliseconds &timeout)
{
    const steady_clock::time_point deadline = steady_clock::now() + timeout;
 
    debug(s_loggerCat) << "->> " << cmd;
    if (cmd.length() > 0)
        write(cmd);
    if (!msg)
        return grbl::ErrorCode{0};
 
    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();
 
        wait(remaining);
        read();
        std::string line;
        while (this->takeLine(line))
        {
            debug(s_loggerCat) << "<<- " << line;
            try
            {
                if (!msg(line))
                    dataSignal(line);
            }
            catch (const grbl::ErrorCode &rc)
            {
                return rc;
            }
            catch (std::exception &ex)
            {
                error(s_loggerCat)
                    << "exception in client callback: " << ex.what();
            }
        }
    }
    return grbl::CustomErrorCode::Timeout;
}
 
bool GrblDeviceBase::takeLine(std::string &line)
{
    return m_buffer.takeLine(line);
}