1

/*

     2

 * Beremiz C++ runtime

     3

 *

     4

 * This file implements Beremiz C++ runtime Command Line Interface for POSIX

     5

 *

     6

 * Based on erpcsniffer.cpp, BSD-3-Clause, Copyright 2017 NXP

     7

 *

     8

 * Copyright 2024 Beremiz SAS

     9

 * 

    10

 * See COPYING for licensing details

    11

 */

    12

    13

#include <stdlib.h>

    14

#include <vector>

    15

#include <filesystem>

    16

    17

#include "erpc_basic_codec.hpp"

    18

#include "erpc_serial_transport.hpp"

    19

#include "erpc_tcp_transport.hpp"

    20

#include "erpc_simple_server.hpp"

    21

    22

#include "erpc_PLCObject_server.hpp"

    23

#include "Logging.hpp"

    24

#include "options.hpp"

    25

    26

#include "PLCObject.hpp"

    27

    28

using namespace erpc;

    29

using namespace std;

    30

    31

class MyMessageBufferFactory : public MessageBufferFactory

    32

{

    33

public:

    34

    virtual MessageBuffer create()

    35

    {

    36

        uint8_t *buf = new uint8_t[1024];

    37

        return MessageBuffer(buf, 1024);

    38

    }

    39

    40

    virtual void dispose(MessageBuffer *buf)

    41

    {

    42

        erpc_assert(buf);

    43

        if (*buf)

    44

        {

    45

            delete[] buf->get();

    46

        }

    47

    }

    48

};

    49

    50

    51

namespace beremizRuntime {

    52

    53

/*! The tool's name. */

    54

const char k_toolName[] = "beremizRuntime";

    55

    56

/*! Current version number for the tool. */

    57

const char k_version[] = __STRING(BEREMIZ_VERSION);

    58

    59

/*! Copyright string. */

    60

const char k_copyright[] = "Copyright 2024 Beremiz SAS. All rights reserved.";

    61

    62

static const char *k_optionsDefinition[] = { "?|help",

    63

                                             "V|version",

    64

                                             "v|verbose",

    65

                                             "t:transport <transport>",

    66

                                             "b:baudrate <baudrate>",

    67

                                             "p:port <port>",

    68

                                             "h:host <host>",

    69

                                             NULL };

    70

    71

/*! Help string. */

    72

const char k_usageText[] =

    73

    "\nOptions:\n\

    74

  -?/--help                    Show this help\n\

    75

  -V/--version                 Display tool version\n\

    76

  -v/--verbose                 Print extra detailed log information\n\

    77

  -t/--transport <transport>   Type of transport.\n\

    78

  -b/--baudrate <baudrate>     Baud rate.\n\

    79

  -p/--port <port>             Port name or port number.\n\

    80

  -h/--host <host>             Host definition.\n\

    81

\n\

    82

Available transports (use with -t option):\n\

    83

  tcp      Tcp transport type (host, port number).\n\

    84

  serial   Serial transport type (port name, baud rate).\n\

    85

\n";

    86

    87

    88

/*!

    89

 * @brief Class that encapsulates the beremizRuntime tool.

    90

 *

    91

 * A single global logger instance is created during object construction. It is

    92

 * never freed because we need it up to the last possible minute, when an

    93

 * exception could be thrown.

    94

 */

    95

class beremizRuntimeCLI

    96

{

    97

protected:

    98

    enum class verbose_type_t

    99

    {

   100

        kWarning,

   101

        kInfo,

   102

        kDebug,

   103

        kExtraDebug

   104

    }; /*!< Types of verbose outputs from beremizRuntime application. */

   105

   106

    enum class transports_t

   107

    {

   108

        kNoneTransport,

   109

        kTcpTransport,

   110

        kSerialTransport

   111

    }; /*!< Type of transport to use. */

   112

   113

    typedef vector<string> string_vector_t;

   114

   115

    int m_argc;                   /*!< Number of command line arguments. */

   116

    char **m_argv;                /*!< String value for each command line argument. */

   117

    StdoutLogger *m_logger;       /*!< Singleton logger instance. */

   118

    verbose_type_t m_verboseType; /*!< Which type of log is need to set (warning, info, debug). */

   119

    const char *m_workingDir;     /*!< working directory. */

   120

    string_vector_t m_positionalArgs;

   121

    transports_t m_transport; /*!< Transport used for receiving messages. */

   122

    uint32_t m_baudrate;      /*!< Baudrate rate speed. */

   123

    const char *m_port;       /*!< Name or number of port. Based on used transport. */

   124

    const char *m_host;       /*!< Host name */

   125

   126

public:

   127

    /*!

   128

     * @brief Constructor.

   129

     *

   130

     * @param[in] argc Count of arguments in argv variable.

   131

     * @param[in] argv Pointer to array of arguments.

   132

     *

   133

     * Creates the singleton logger instance.

   134

     */

   135

    beremizRuntimeCLI(int argc, char *argv[]) :

   136

    m_argc(argc), m_argv(argv), m_logger(0), m_verboseType(verbose_type_t::kWarning),

   137

    m_workingDir(NULL), m_transport(transports_t::kNoneTransport), m_baudrate(115200), m_port(NULL),

   138

    m_host(NULL)

   139

    {

   140

        // create logger instance

   141

        m_logger = new StdoutLogger();

   142

        m_logger->setFilterLevel(Logger::log_level_t::kWarning);

   143

        Log::setLogger(m_logger);

   144

    }

   145

   146

    /*!

   147

     * @brief Destructor.

   148

     */

   149

    ~beremizRuntimeCLI() {}

   150

   151

    /*!

   152

     * @brief Reads the command line options passed into the constructor.

   153

     *

   154

     * This method can return a return code to its caller, which will cause the

   155

     * tool to exit immediately with that return code value. Normally, though, it

   156

     * will return -1 to signal that the tool should continue to execute and

   157

     * all options were processed successfully.

   158

     *

   159

     * The Options class is used to parse command line options. See

   160

     * #k_optionsDefinition for the list of options and #k_usageText for the

   161

     * descriptive help for each option.

   162

     *

   163

     * @retval -1 The options were processed successfully. Let the tool run normally.

   164

     * @return A zero or positive result is a return code value that should be

   165

     *      returned from the tool as it exits immediately.

   166

     */

   167

    int processOptions()

   168

    {

   169

        Options options(*m_argv, k_optionsDefinition);

   170

        OptArgvIter iter(--m_argc, ++m_argv);

   171

   172

        // process command line options

   173

        int optchar;

   174

        const char *optarg;

   175

        while ((optchar = options(iter, optarg)))

   176

        {

   177

            switch (optchar)

   178

            {

   179

                case '?':

   180

                {

   181

                    printUsage(options);

   182

                    return 0;

   183

                }

   184

   185

                case 'V':

   186

                {

   187

                    printf("%s %s\n%s\n", k_toolName, k_version, k_copyright);

   188

                    return 0;

   189

                }

   190

   191

                case 'v':

   192

                {

   193

                    if (m_verboseType != verbose_type_t::kExtraDebug)

   194

                    {

   195

                        m_verboseType = (verbose_type_t)(((int)m_verboseType) + 1);

   196

                    }

   197

                    break;

   198

                }

   199

   200

                case 't':

   201

                {

   202

                    string transport = optarg;

   203

                    if (transport == "tcp")

   204

                    {

   205

                        m_transport = transports_t::kTcpTransport;

   206

                    }

   207

                    else if (transport == "serial")

   208

                    {

   209

                        m_transport = transports_t::kSerialTransport;

   210

                    }

   211

                    else

   212

                    {

   213

                        Log::error("error: unknown transport type %s", transport.c_str());

   214

                        return 1;

   215

                    }

   216

                    break;

   217

                }

   218

   219

                case 'b':

   220

                {

   221

                    m_baudrate = strtoul(optarg, NULL, 10);

   222

                    break;

   223

                }

   224

   225

                case 'p':

   226

                {

   227

                    m_port = optarg;

   228

                    break;

   229

                }

   230

   231

                case 'h':

   232

                {

   233

                    m_host = optarg;

   234

                    break;

   235

                }

   236

   237

                default:

   238

                {

   239

                    Log::error("error: unrecognized option\n\n");

   240

                    printUsage(options);

   241

                    return 0;

   242

                }

   243

            }

   244

        }

   245

   246

        // handle positional args

   247

        if (iter.index() < m_argc)

   248

        {

   249

            if (m_argc - iter.index() > 1){

   250

                Log::error("error: too many arguments\n\n");

   251

                printUsage(options);

   252

                return 0;

   253

            }

   254

            int i;

   255

            for (i = iter.index(); i < m_argc; ++i)

   256

            {

   257

                m_positionalArgs.push_back(m_argv[i]);

   258

            }

   259

        }

   260

   261

        // all is well

   262

        return -1;

   263

    }

   264

   265

    /*!

   266

     * @brief Prints help for the tool.

   267

     *

   268

     * @param[in] options Options, which can be used.

   269

     */

   270

    void printUsage(Options &options)

   271

    {

   272

        options.usage(cout, "[path]");

   273

        printf(k_usageText);

   274

    }

   275

   276

    /*!

   277

     * @brief Core of the tool.

   278

     *

   279

     * Calls processOptions() to handle command line options before performing the

   280

     * real work the tool does.

   281

     *

   282

     * @retval 1 The functions wasn't processed successfully.

   283

     * @retval 0 The function was processed successfully.

   284

     *

   285

     * @exception Log::error This function is called, when function wasn't

   286

     *              processed successfully.

   287

     * @exception runtime_error Thrown, when positional args is empty.

   288

     */

   289

    int run()

   290

    {

   291

        try

   292

        {

   293

            // read command line options

   294

            int result;

   295

            if ((result = processOptions()) != -1)

   296

            {

   297

                return result;

   298

            }

   299

   300

            // set verbose logging

   301

            setVerboseLogging();

   302

   303

            if (!m_positionalArgs.size())

   304

            {

   305

                m_workingDir = std::filesystem::current_path().c_str();

   306

            } else {

   307

                m_workingDir = m_positionalArgs[0].c_str();

   308

                std::filesystem::current_path(m_workingDir);

   309

            }

   310

   311

            // remove temporary directory if it already exists

   312

            if (std::filesystem::exists("tmp"))

   313

            {

   314

                std::filesystem::remove_all("tmp");

   315

            }

   316

   317

            // Create temporary directory in working directory

   318

            std::filesystem::create_directory("tmp");

   319

   320

            Transport *_transport;

   321

            switch (m_transport)

   322

            {

   323

                case transports_t::kTcpTransport:

   324

                {

   325

                    uint16_t portNumber = strtoul(m_port, NULL, 10);

   326

                    TCPTransport *tcpTransport = new TCPTransport(m_host, portNumber, true);

   327

                    if (erpc_status_t err = tcpTransport->open())

   328

                    {

   329

                        return err;

   330

                    }

   331

                    _transport = tcpTransport;

   332

                    break;

   333

                }

   334

   335

                case transports_t::kSerialTransport:

   336

                {

   337

                    SerialTransport *serialTransport = new SerialTransport(m_port, m_baudrate);

   338

   339

                    uint8_t vtime = 0;

   340

                    uint8_t vmin = 1;

   341

                    while (kErpcStatus_Success != serialTransport->init(vtime, vmin))

   342

                        ;

   343

   344

                    _transport = serialTransport;

   345

                    break;

   346

                }

   347

   348

                default:

   349

                {

   350

                    break;

   351

                }

   352

            }

   353

   354

            MyMessageBufferFactory _msgFactory;

   355

            BasicCodecFactory _basicCodecFactory;

   356

            SimpleServer _server;

   357

   358

            BeremizPLCObjectService_service *svc;

   359

   360

            Log::info("Starting ERPC server...\n");

   361

   362

            _server.setMessageBufferFactory(&_msgFactory);

   363

            _server.setTransport(_transport);

   364

            _server.setCodecFactory(&_basicCodecFactory);

   365

   366

            svc = new BeremizPLCObjectService_service(new PLCObject());

   367

   368

            _server.addService(svc);

   369

   370

            _server.run();

   371

   372

            return 0;

   373

        }

   374

        catch (exception &e)

   375

        {

   376

            Log::error("error: %s\n", e.what());

   377

            return 1;

   378

        }

   379

        catch (...)

   380

        {

   381

            Log::error("error: unexpected exception\n");

   382

            return 1;

   383

        }

   384

   385

        return 0;

   386

    }

   387

   388

    /*!

   389

     * @brief Turns on verbose logging.

   390

     */

   391

    void setVerboseLogging()

   392

    {

   393

        // verbose only affects the INFO and DEBUG filter levels

   394

        // if the user has selected quiet mode, it overrides verbose

   395

        switch (m_verboseType)

   396

        {

   397

            case verbose_type_t::kWarning:

   398

                Log::getLogger()->setFilterLevel(Logger::log_level_t::kWarning);

   399

                break;

   400

            case verbose_type_t::kInfo:

   401

                Log::getLogger()->setFilterLevel(Logger::log_level_t::kInfo);

   402

                break;

   403

            case verbose_type_t::kDebug:

   404

                Log::getLogger()->setFilterLevel(Logger::log_level_t::kDebug);

   405

                break;

   406

            case verbose_type_t::kExtraDebug:

   407

                Log::getLogger()->setFilterLevel(Logger::log_level_t::kDebug2);

   408

                break;

   409

        }

   410

    }

   411

};

   412

   413

} // namespace beremizRuntime

   414

   415

/*!

   416

 * @brief Main application entry point.

   417

 *

   418

 * Creates a tool instance and lets it take over.

   419

 */

   420

int main(int argc, char *argv[], char *envp[])

   421

{

   422

    (void)envp;

   423

    try

   424

    {

   425

        return beremizRuntime::beremizRuntimeCLI(argc, argv).run();

   426

    }

   427

    catch (...)

   428

    {

   429

        Log::error("error: unexpected exception\n");

   430

        return 1;

   431

    }

   432

   433

    return 0;

   434

}