MGrblDeviceBase.hxx

/*
** 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-09-22T16:00:46
** Author: Sylvain Fargier <sylvain.fargier@cern.ch>
*/
 
#ifndef MGRBLDEVICEBASE_CPP__
#define MGRBLDEVICEBASE_CPP__
 
#include <chrono>
 
#include <logger/Logger.hpp>
 
#include "GrblParser.hpp"
#include "MGrblDeviceBase.hpp"
 
namespace grbl {
 
template<typename DeviceBase>
grbl::ErrorCode MGrblDeviceBase<DeviceBase>::send(
    const std::string &cmd,
    std::function<bool(const std::string &)> msg,
    const std::chrono::milliseconds &timeout)
{
    static const std::string s_loggerCat{"smc:mgrbldevice"};
 
    const std::chrono::steady_clock::time_point deadline =
        std::chrono::steady_clock::now() + timeout;
    logger::debug(s_loggerCat) << "--> " << cmd;
    if (cmd.empty())
        return 3;
 
    this->write(cmd + "\r\n");
    const char sender = cmd[0];
 
    bool msgConfirmed = false;
    do
    {
        std::chrono::steady_clock::time_point now =
            std::chrono::steady_clock::now();
        const std::chrono::milliseconds remaining = (now < deadline) ?
            std::chrono::duration_cast<std::chrono::milliseconds>(deadline -
                                                                  now) :
            std::chrono::milliseconds::zero();
 
        this->wait(remaining);
        this->read();
        std::string line;
        while (this->takeLine(line))
        {
            logger::debug(s_loggerCat) << "<-- " << line;
            if (line[0] == sender)
            {
                if (line.compare(1, 2, "ok") == 0)
                {
                    if (msg && !msgConfirmed)
                        return grbl::CustomErrorCode::NoPayload;
                    return 0;
                }
                else if (line.compare(1, 6, "error:") == 0)
                {
                    grbl::ErrorCode errorCode;
                    if (GrblParser::parseErrorReply(line.substr(1), errorCode))
                        return errorCode;
                    logger::error(s_loggerCat)
                        << "Cannot parse error code: " << line;
                    return grbl::CustomErrorCode::InternalError;
                }
            }
            try
            {
                if (bool(msg) && msg(line))
                    msgConfirmed = true;
                else
                    this->dataSignal(line);
            }
            catch (grbl::ErrorCode &rc)
            {
                return rc;
            }
            catch (std::exception &ex)
            {
                logger::error(s_loggerCat)
                    << "exception in client callback: " << ex.what();
            }
        }
    } while (std::chrono::steady_clock::now() <= deadline);
    return grbl::CustomErrorCode::Timeout;
}
 
} // namespace grbl
 
#endif