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

                                             "a|autoload",

    75

                                             NULL };

    76

    77

/*! Help string. */

    78

const char k_usageText[] =

    79

    "\nOptions:\n\

    80

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

    81

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

    82

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

    83

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

    84

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

    85

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

    86

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

    87

  -a/--autoload                Autoload.\n\

    88

\n\

    89

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

    90

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

    91

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

    92

\n";

    93

    94

    95

/*!

    96

 * @brief Class that encapsulates the beremizRuntime tool.

    97

 *

    98

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

    99

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

   100

 * exception could be thrown.

   101

 */

   102

class beremizRuntimeCLI

   103

{

   104

protected:

   105

    enum class verbose_type_t

   106

    {

   107

        kWarning,

   108

        kInfo,

   109

        kDebug,

   110

        kExtraDebug

   111

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

   112

   113

    enum class transports_t

   114

    {

   115

        kNoneTransport,

   116

        kTcpTransport,

   117

        kSerialTransport

   118

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

   119

   120

    typedef vector<string> string_vector_t;

   121

   122

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

   123

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

   124

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

   125

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

   126

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

   127

    string_vector_t m_positionalArgs;

   128

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

   129

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

   130

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

   131

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

   132

    bool m_autoload = false;          /*!< Autoload flag. */

   133

   134

public:

   135

    /*!

   136

     * @brief Constructor.

   137

     *

   138

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

   139

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

   140

     *

   141

     * Creates the singleton logger instance.

   142

     */

   143

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

   144

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

   145

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

   146

    m_host(NULL)

   147

    {

   148

        // create logger instance

   149

        m_logger = new StdoutLogger();

   150

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

   151

        Log::setLogger(m_logger);

   152

    }

   153

   154

    /*!

   155

     * @brief Destructor.

   156

     */

   157

    ~beremizRuntimeCLI() {}

   158

   159

    /*!

   160

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

   161

     *

   162

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

   163

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

   164

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

   165

     * all options were processed successfully.

   166

     *

   167

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

   168

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

   169

     * descriptive help for each option.

   170

     *

   171

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

   172

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

   173

     *      returned from the tool as it exits immediately.

   174

     */

   175

    int processOptions()

   176

    {

   177

        Options options(*m_argv, k_optionsDefinition);

   178

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

   179

   180

        // process command line options

   181

        int optchar;

   182

        const char *optarg;

   183

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

   184

        {

   185

            switch (optchar)

   186

            {

   187

                case '?':

   188

                {

   189

                    printUsage(options);

   190

                    return 0;

   191

                }

   192

   193

                case 'V':

   194

                {

   195

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

   196

                    return 0;

   197

                }

   198

   199

                case 'v':

   200

                {

   201

                    if (m_verboseType != verbose_type_t::kExtraDebug)

   202

                    {

   203

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

   204

                    }

   205

                    break;

   206

                }

   207

   208

                case 't':

   209

                {

   210

                    string transport = optarg;

   211

                    if (transport == "tcp")

   212

                    {

   213

                        m_transport = transports_t::kTcpTransport;

   214

                    }

   215

                    else if (transport == "serial")

   216

                    {

   217

                        m_transport = transports_t::kSerialTransport;

   218

                    }

   219

                    else

   220

                    {

   221

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

   222

                        return 1;

   223

                    }

   224

                    break;

   225

                }

   226

   227

                case 'b':

   228

                {

   229

                    m_baudrate = strtoul(optarg, NULL, 10);

   230

                    break;

   231

                }

   232

   233

                case 'p':

   234

                {

   235

                    m_port = optarg;

   236

                    break;

   237

                }

   238

   239

                case 'h':

   240

                {

   241

                    m_host = optarg;

   242

                    break;

   243

                }

   244

   245

                case 'a':

   246

                {

   247

                    m_autoload = true;

   248

                    break;

   249

                }

   250

   251

                default:

   252

                {

   253

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

   254

                    printUsage(options);

   255

                    return 0;

   256

                }

   257

            }

   258

        }

   259

   260

        // handle positional args

   261

        if (iter.index() < m_argc)

   262

        {

   263

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

   264

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

   265

                printUsage(options);

   266

                return 0;

   267

            }

   268

            int i;

   269

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

   270

            {

   271

                m_positionalArgs.push_back(m_argv[i]);

   272

            }

   273

        }

   274

   275

        // all is well

   276

        return -1;

   277

    }

   278

   279

    /*!

   280

     * @brief Prints help for the tool.

   281

     *

   282

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

   283

     */

   284

    void printUsage(Options &options)

   285

    {

   286

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

   287

        printf(k_usageText);

   288

    }

   289

   290

    /*!

   291

     * @brief Core of the tool.

   292

     *

   293

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

   294

     * real work the tool does.

   295

     *

   296

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

   297

     * @retval 0 The function was processed successfully.

   298

     *

   299

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

   300

     *              processed successfully.

   301

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

   302

     */

   303

    int run()

   304

    {

   305

        try

   306

        {

   307

            // read command line options

   308

            int result;

   309

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

   310

            {

   311

                return result;

   312

            }

   313

   314

            // set verbose logging

   315

            setVerboseLogging();

   316

   317

            if (!m_positionalArgs.size())

   318

            {

   319

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

   320

            } else {

   321

                m_workingDir = m_positionalArgs[0].c_str();

   322

                std::filesystem::current_path(m_workingDir);

   323

            }

   324

   325

            // remove temporary directory if it already exists

   326

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

   327

            {

   328

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

   329

            }

   330

   331

            // Create temporary directory in working directory

   332

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

   333

   334

            Transport *_transport;

   335

            switch (m_transport)

   336

            {

   337

                case transports_t::kTcpTransport:

   338

                {

   339

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

   340

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

   341

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

   342

                    {

   343

                        return err;

   344

                    }

   345

                    _transport = tcpTransport;

   346

                    break;

   347

                }

   348

   349

                case transports_t::kSerialTransport:

   350

                {

   351

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

   352

   353

                    uint8_t vtime = 0;

   354

                    uint8_t vmin = 1;

   355

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

   356

                        ;

   357

   358

                    _transport = serialTransport;

   359

                    break;

   360

                }

   361

   362

                default:

   363

                {

   364

                    break;

   365

                }

   366

            }

   367

   368

            Crc16 crc;

   369

            _transport->setCrc16(&crc);

   370

   371

            MyMessageBufferFactory _msgFactory;

   372

            BasicCodecFactory _basicCodecFactory;

   373

            SimpleServer _server;

   374

   375

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

   376

   377

            _server.setMessageBufferFactory(&_msgFactory);

   378

            _server.setTransport(_transport);

   379

            _server.setCodecFactory(&_basicCodecFactory);

   380

   381

            PLCObject plc_object = PLCObject();

   382

            BeremizPLCObjectService_service svc = BeremizPLCObjectService_service(&plc_object);

   383

   384

            _server.addService(&svc);

   385

   386

            if(m_autoload)

   387

            {

   388

                plc_object.AutoLoad();

   389

            }

   390

   391

            _server.run();

   392

   393

            return 0;

   394

        }

   395

        catch (exception &e)

   396

        {

   397

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

   398

            return 1;

   399

        }

   400

        catch (...)

   401

        {

   402

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

   403

            return 1;

   404

        }

   405

   406

        return 0;

   407

    }

   408

   409

    /*!

   410

     * @brief Turns on verbose logging.

   411

     */

   412

    void setVerboseLogging()

   413

    {

   414

        // verbose only affects the INFO and DEBUG filter levels

   415

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

   416

        switch (m_verboseType)

   417

        {

   418

            case verbose_type_t::kWarning:

   419

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

   420

                break;

   421

            case verbose_type_t::kInfo:

   422

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

   423

                break;

   424

            case verbose_type_t::kDebug:

   425

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

   426

                break;

   427

            case verbose_type_t::kExtraDebug:

   428

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

   429

                break;

   430

        }

   431

    }

   432

};

   433

   434

} // namespace beremizRuntime

   435

   436

/*!

   437

 * @brief Main application entry point.

   438

 *

   439

 * Creates a tool instance and lets it take over.

   440

 */

   441

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

   442

{

   443

    (void)envp;

   444

    try

   445

    {

   446

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

   447

    }

   448

    catch (...)

   449

    {

   450

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

   451

        return 1;

   452

    }

   453

   454

    return 0;

   455

}