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

// eRPC includes

    18

#include "erpc_basic_codec.hpp"

    19

#include "erpc_serial_transport.hpp"

    20

#include "erpc_tcp_transport.hpp"

    21

#include "erpc_simple_server.hpp"

    22

    23

// eRPC generated includes

    24

#include "erpc_PLCObject_server.hpp"

    25

    26

// erpcgen includes (re-uses erpcgen's logging system and options parser)

    27

#include "Logging.hpp"

    28

#include "options.hpp"

    29

    30

#include "PLCObject.hpp"

    31

    32

using namespace erpc;

    33

using namespace std;

    34

    35

#define MSG_SIZE 1024*6

    36

class MyMessageBufferFactory : public MessageBufferFactory

    37

{

    38

public:

    39

    virtual MessageBuffer create()

    40

    {

    41

        uint8_t *buf = new uint8_t[MSG_SIZE];

    42

        return MessageBuffer(buf, MSG_SIZE);

    43

    }

    44

    45

    virtual void dispose(MessageBuffer *buf)

    46

    {

    47

        erpc_assert(buf);

    48

        if (*buf)

    49

        {

    50

            delete[] buf->get();

    51

        }

    52

    }

    53

};

    54

    55

    56

namespace beremizRuntime {

    57

    58

/*! The tool's name. */

    59

const char k_toolName[] = "beremizRuntime";

    60

    61

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

    62

const char k_version[] = __STRING(BEREMIZ_VERSION);

    63

    64

/*! Copyright string. */

    65

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

    66

    67

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

    68

                                             "V|version",

    69

                                             "v|verbose",

    70

                                             "t:transport <transport>",

    71

                                             "b:baudrate <baudrate>",

    72

                                             "p:port <port>",

    73

                                             "h:host <host>",

    74

                                             NULL };

    75

    76

/*! Help string. */

    77

const char k_usageText[] =

    78

    "\nOptions:\n\

    79

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

    80

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

    81

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

    82

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

    83

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

    84

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

    85

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

    86

\n\

    87

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

    88

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

    89

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

    90

\n";

    91

    92

    93

/*!

    94

 * @brief Class that encapsulates the beremizRuntime tool.

    95

 *

    96

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

    97

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

    98

 * exception could be thrown.

    99

 */

   100

class beremizRuntimeCLI

   101

{

   102

protected:

   103

    enum class verbose_type_t

   104

    {

   105

        kWarning,

   106

        kInfo,

   107

        kDebug,

   108

        kExtraDebug

   109

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

   110

   111

    enum class transports_t

   112

    {

   113

        kNoneTransport,

   114

        kTcpTransport,

   115

        kSerialTransport

   116

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

   117

   118

    typedef vector<string> string_vector_t;

   119

   120

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

   121

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

   122

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

   123

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

   124

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

   125

    string_vector_t m_positionalArgs;

   126

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

   127

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

   128

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

   129

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

   130

   131

public:

   132

    /*!

   133

     * @brief Constructor.

   134

     *

   135

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

   136

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

   137

     *

   138

     * Creates the singleton logger instance.

   139

     */

   140

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

   141

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

   142

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

   143

    m_host(NULL)

   144

    {

   145

        // create logger instance

   146

        m_logger = new StdoutLogger();

   147

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

   148

        Log::setLogger(m_logger);

   149

    }

   150

   151

    /*!

   152

     * @brief Destructor.

   153

     */

   154

    ~beremizRuntimeCLI() {}

   155

   156

    /*!

   157

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

   158

     *

   159

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

   160

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

   161

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

   162

     * all options were processed successfully.

   163

     *

   164

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

   165

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

   166

     * descriptive help for each option.

   167

     *

   168

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

   169

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

   170

     *      returned from the tool as it exits immediately.

   171

     */

   172

    int processOptions()

   173

    {

   174

        Options options(*m_argv, k_optionsDefinition);

   175

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

   176

   177

        // process command line options

   178

        int optchar;

   179

        const char *optarg;

   180

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

   181

        {

   182

            switch (optchar)

   183

            {

   184

                case '?':

   185

                {

   186

                    printUsage(options);

   187

                    return 0;

   188

                }

   189

   190

                case 'V':

   191

                {

   192

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

   193

                    return 0;

   194

                }

   195

   196

                case 'v':

   197

                {

   198

                    if (m_verboseType != verbose_type_t::kExtraDebug)

   199

                    {

   200

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

   201

                    }

   202

                    break;

   203

                }

   204

   205

                case 't':

   206

                {

   207

                    string transport = optarg;

   208

                    if (transport == "tcp")

   209

                    {

   210

                        m_transport = transports_t::kTcpTransport;

   211

                    }

   212

                    else if (transport == "serial")

   213

                    {

   214

                        m_transport = transports_t::kSerialTransport;

   215

                    }

   216

                    else

   217

                    {

   218

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

   219

                        return 1;

   220

                    }

   221

                    break;

   222

                }

   223

   224

                case 'b':

   225

                {

   226

                    m_baudrate = strtoul(optarg, NULL, 10);

   227

                    break;

   228

                }

   229

   230

                case 'p':

   231

                {

   232

                    m_port = optarg;

   233

                    break;

   234

                }

   235

   236

                case 'h':

   237

                {

   238

                    m_host = optarg;

   239

                    break;

   240

                }

   241

   242

                default:

   243

                {

   244

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

   245

                    printUsage(options);

   246

                    return 0;

   247

                }

   248

            }

   249

        }

   250

   251

        // handle positional args

   252

        if (iter.index() < m_argc)

   253

        {

   254

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

   255

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

   256

                printUsage(options);

   257

                return 0;

   258

            }

   259

            int i;

   260

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

   261

            {

   262

                m_positionalArgs.push_back(m_argv[i]);

   263

            }

   264

        }

   265

   266

        // all is well

   267

        return -1;

   268

    }

   269

   270

    /*!

   271

     * @brief Prints help for the tool.

   272

     *

   273

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

   274

     */

   275

    void printUsage(Options &options)

   276

    {

   277

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

   278

        printf(k_usageText);

   279

    }

   280

   281

    /*!

   282

     * @brief Core of the tool.

   283

     *

   284

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

   285

     * real work the tool does.

   286

     *

   287

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

   288

     * @retval 0 The function was processed successfully.

   289

     *

   290

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

   291

     *              processed successfully.

   292

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

   293

     */

   294

    int run()

   295

    {

   296

        try

   297

        {

   298

            // read command line options

   299

            int result;

   300

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

   301

            {

   302

                return result;

   303

            }

   304

   305

            // set verbose logging

   306

            setVerboseLogging();

   307

   308

            if (!m_positionalArgs.size())

   309

            {

   310

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

   311

            } else {

   312

                m_workingDir = m_positionalArgs[0].c_str();

   313

                std::filesystem::current_path(m_workingDir);

   314

            }

   315

   316

            // remove temporary directory if it already exists

   317

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

   318

            {

   319

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

   320

            }

   321

   322

            // Create temporary directory in working directory

   323

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

   324

   325

            Transport *_transport;

   326

            switch (m_transport)

   327

            {

   328

                case transports_t::kTcpTransport:

   329

                {

   330

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

   331

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

   332

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

   333

                    {

   334

                        return err;

   335

                    }

   336

                    _transport = tcpTransport;

   337

                    break;

   338

                }

   339

   340

                case transports_t::kSerialTransport:

   341

                {

   342

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

   343

   344

                    uint8_t vtime = 0;

   345

                    uint8_t vmin = 1;

   346

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

   347

                        ;

   348

   349

                    _transport = serialTransport;

   350

                    break;

   351

                }

   352

   353

                default:

   354

                {

   355

                    break;

   356

                }

   357

            }

   358

   359

            Crc16 crc;

   360

            _transport->setCrc16(&crc);

   361

   362

            MyMessageBufferFactory _msgFactory;

   363

            BasicCodecFactory _basicCodecFactory;

   364

            SimpleServer _server;

   365

   366

            BeremizPLCObjectService_service *svc;

   367

   368

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

   369

   370

            _server.setMessageBufferFactory(&_msgFactory);

   371

            _server.setTransport(_transport);

   372

            _server.setCodecFactory(&_basicCodecFactory);

   373

   374

            svc = new BeremizPLCObjectService_service(new PLCObject());

   375

   376

            _server.addService(svc);

   377

   378

            _server.run();

   379

   380

            return 0;

   381

        }

   382

        catch (exception &e)

   383

        {

   384

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

   385

            return 1;

   386

        }

   387

        catch (...)

   388

        {

   389

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

   390

            return 1;

   391

        }

   392

   393

        return 0;

   394

    }

   395

   396

    /*!

   397

     * @brief Turns on verbose logging.

   398

     */

   399

    void setVerboseLogging()

   400

    {

   401

        // verbose only affects the INFO and DEBUG filter levels

   402

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

   403

        switch (m_verboseType)

   404

        {

   405

            case verbose_type_t::kWarning:

   406

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

   407

                break;

   408

            case verbose_type_t::kInfo:

   409

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

   410

                break;

   411

            case verbose_type_t::kDebug:

   412

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

   413

                break;

   414

            case verbose_type_t::kExtraDebug:

   415

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

   416

                break;

   417

        }

   418

    }

   419

};

   420

   421

} // namespace beremizRuntime

   422

   423

/*!

   424

 * @brief Main application entry point.

   425

 *

   426

 * Creates a tool instance and lets it take over.

   427

 */

   428

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

   429

{

   430

    (void)envp;

   431

    try

   432

    {

   433

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

   434

    }

   435

    catch (...)

   436

    {

   437

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

   438

        return 1;

   439

    }

   440

   441

    return 0;

   442

}