1

#

     2

# Generated by erpcgen 1.11.0 on Wed Jan 17 21:59:20 2024.

     3

#

     4

# AUTOGENERATED - DO NOT EDIT

     5

#

     6

     7

import erpc

     8

from . import common, interface

     9

    10

# Client for BeremizPLCObjectService

    11

class BeremizPLCObjectServiceService(erpc.server.Service):

    12

    def __init__(self, handler):

    13

        super(BeremizPLCObjectServiceService, self).__init__(interface.IBeremizPLCObjectService.SERVICE_ID)

    14

        self._handler = handler

    15

        self._methods = {

    16

                interface.IBeremizPLCObjectService.APPENDCHUNKTOBLOB_ID: self._handle_AppendChunkToBlob,

    17

                interface.IBeremizPLCObjectService.GETLOGMESSAGE_ID: self._handle_GetLogMessage,

    18

                interface.IBeremizPLCObjectService.GETPLCID_ID: self._handle_GetPLCID,

    19

                interface.IBeremizPLCObjectService.GETPLCSTATUS_ID: self._handle_GetPLCstatus,

    20

                interface.IBeremizPLCObjectService.GETTRACEVARIABLES_ID: self._handle_GetTraceVariables,

    21

                interface.IBeremizPLCObjectService.MATCHMD5_ID: self._handle_MatchMD5,

    22

                interface.IBeremizPLCObjectService.NEWPLC_ID: self._handle_NewPLC,

    23

                interface.IBeremizPLCObjectService.PURGEBLOBS_ID: self._handle_PurgeBlobs,

    24

                interface.IBeremizPLCObjectService.REPAIRPLC_ID: self._handle_RepairPLC,

    25

                interface.IBeremizPLCObjectService.RESETLOGCOUNT_ID: self._handle_ResetLogCount,

    26

                interface.IBeremizPLCObjectService.SEEDBLOB_ID: self._handle_SeedBlob,

    27

                interface.IBeremizPLCObjectService.SETTRACEVARIABLESLIST_ID: self._handle_SetTraceVariablesList,

    28

                interface.IBeremizPLCObjectService.STARTPLC_ID: self._handle_StartPLC,

    29

                interface.IBeremizPLCObjectService.STOPPLC_ID: self._handle_StopPLC,

    30

            }

    31

    32

    def _handle_AppendChunkToBlob(self, sequence, codec):

    33

        # Create reference objects to pass into handler for out/inout parameters.

    34

        newBlobID = erpc.Reference()

    35

    36

        # Read incoming parameters.

    37

        data = codec.read_binary()

    38

        blobID = codec.read_binary()

    39

    40

        # Invoke user implementation of remote function.

    41

        _result = self._handler.AppendChunkToBlob(data, blobID, newBlobID)

    42

    43

        # Prepare codec for reply message.

    44

        codec.reset()

    45

    46

        # Construct reply message.

    47

        codec.start_write_message(erpc.codec.MessageInfo(

    48

            type=erpc.codec.MessageType.kReplyMessage,

    49

            service=interface.IBeremizPLCObjectService.SERVICE_ID,

    50

            request=interface.IBeremizPLCObjectService.APPENDCHUNKTOBLOB_ID,

    51

            sequence=sequence))

    52

        if newBlobID.value is None:

    53

            raise ValueError("newBlobID.value is None")

    54

        codec.write_binary(newBlobID.value)

    55

        codec.write_uint32(_result)

    56

    57

    def _handle_GetLogMessage(self, sequence, codec):

    58

        # Create reference objects to pass into handler for out/inout parameters.

    59

        message = erpc.Reference()

    60

    61

        # Read incoming parameters.

    62

        level = codec.read_uint8()

    63

        msgID = codec.read_uint32()

    64

    65

        # Invoke user implementation of remote function.

    66

        _result = self._handler.GetLogMessage(level, msgID, message)

    67

    68

        # Prepare codec for reply message.

    69

        codec.reset()

    70

    71

        # Construct reply message.

    72

        codec.start_write_message(erpc.codec.MessageInfo(

    73

            type=erpc.codec.MessageType.kReplyMessage,

    74

            service=interface.IBeremizPLCObjectService.SERVICE_ID,

    75

            request=interface.IBeremizPLCObjectService.GETLOGMESSAGE_ID,

    76

            sequence=sequence))

    77

        if message.value is None:

    78

            raise ValueError("message.value is None")

    79

        message.value._write(codec)

    80

        codec.write_uint32(_result)

    81

    82

    def _handle_GetPLCID(self, sequence, codec):

    83

        # Create reference objects to pass into handler for out/inout parameters.

    84

        plcID = erpc.Reference()

    85

    86

        # Read incoming parameters.

    87

    88

        # Invoke user implementation of remote function.

    89

        _result = self._handler.GetPLCID(plcID)

    90

    91

        # Prepare codec for reply message.

    92

        codec.reset()

    93

    94

        # Construct reply message.

    95

        codec.start_write_message(erpc.codec.MessageInfo(

    96

            type=erpc.codec.MessageType.kReplyMessage,

    97

            service=interface.IBeremizPLCObjectService.SERVICE_ID,

    98

            request=interface.IBeremizPLCObjectService.GETPLCID_ID,

    99

            sequence=sequence))

   100

        if plcID.value is None:

   101

            raise ValueError("plcID.value is None")

   102

        plcID.value._write(codec)

   103

        codec.write_uint32(_result)

   104

   105

    def _handle_GetPLCstatus(self, sequence, codec):

   106

        # Create reference objects to pass into handler for out/inout parameters.

   107

        status = erpc.Reference()

   108

   109

        # Read incoming parameters.

   110

   111

        # Invoke user implementation of remote function.

   112

        _result = self._handler.GetPLCstatus(status)

   113

   114

        # Prepare codec for reply message.

   115

        codec.reset()

   116

   117

        # Construct reply message.

   118

        codec.start_write_message(erpc.codec.MessageInfo(

   119

            type=erpc.codec.MessageType.kReplyMessage,

   120

            service=interface.IBeremizPLCObjectService.SERVICE_ID,

   121

            request=interface.IBeremizPLCObjectService.GETPLCSTATUS_ID,

   122

            sequence=sequence))

   123

        if status.value is None:

   124

            raise ValueError("status.value is None")

   125

        status.value._write(codec)

   126

        codec.write_uint32(_result)

   127

   128

    def _handle_GetTraceVariables(self, sequence, codec):

   129

        # Create reference objects to pass into handler for out/inout parameters.

   130

        traces = erpc.Reference()

   131

   132

        # Read incoming parameters.

   133

        debugToken = codec.read_uint32()

   134

   135

        # Invoke user implementation of remote function.

   136

        _result = self._handler.GetTraceVariables(debugToken, traces)

   137

   138

        # Prepare codec for reply message.

   139

        codec.reset()

   140

   141

        # Construct reply message.

   142

        codec.start_write_message(erpc.codec.MessageInfo(

   143

            type=erpc.codec.MessageType.kReplyMessage,

   144

            service=interface.IBeremizPLCObjectService.SERVICE_ID,

   145

            request=interface.IBeremizPLCObjectService.GETTRACEVARIABLES_ID,

   146

            sequence=sequence))

   147

        if traces.value is None:

   148

            raise ValueError("traces.value is None")

   149

        traces.value._write(codec)

   150

        codec.write_uint32(_result)

   151

   152

    def _handle_MatchMD5(self, sequence, codec):

   153

        # Create reference objects to pass into handler for out/inout parameters.

   154

        match = erpc.Reference()

   155

   156

        # Read incoming parameters.

   157

        MD5 = codec.read_string()

   158

   159

        # Invoke user implementation of remote function.

   160

        _result = self._handler.MatchMD5(MD5, match)

   161

   162

        # Prepare codec for reply message.

   163

        codec.reset()

   164

   165

        # Construct reply message.

   166

        codec.start_write_message(erpc.codec.MessageInfo(

   167

            type=erpc.codec.MessageType.kReplyMessage,

   168

            service=interface.IBeremizPLCObjectService.SERVICE_ID,

   169

            request=interface.IBeremizPLCObjectService.MATCHMD5_ID,

   170

            sequence=sequence))

   171

        if match.value is None:

   172

            raise ValueError("match.value is None")

   173

        codec.write_bool(match.value)

   174

        codec.write_uint32(_result)

   175

   176

    def _handle_NewPLC(self, sequence, codec):

   177

        # Create reference objects to pass into handler for out/inout parameters.

   178

        success = erpc.Reference()

   179

   180

        # Read incoming parameters.

   181

        md5sum = codec.read_string()

   182

        plcObjectBlobID = codec.read_binary()

   183

        _n0 = codec.start_read_list()

   184

        extrafiles = []

   185

        for _i0 in range(_n0):

   186

            _v0 = common.extra_file()._read(codec)

   187

            extrafiles.append(_v0)

   188

   189

   190

        # Invoke user implementation of remote function.

   191

        _result = self._handler.NewPLC(md5sum, plcObjectBlobID, extrafiles, success)

   192

   193

        # Prepare codec for reply message.

   194

        codec.reset()

   195

   196

        # Construct reply message.

   197

        codec.start_write_message(erpc.codec.MessageInfo(

   198

            type=erpc.codec.MessageType.kReplyMessage,

   199

            service=interface.IBeremizPLCObjectService.SERVICE_ID,

   200

            request=interface.IBeremizPLCObjectService.NEWPLC_ID,

   201

            sequence=sequence))

   202

        if success.value is None:

   203

            raise ValueError("success.value is None")

   204

        codec.write_bool(success.value)

   205

        codec.write_uint32(_result)

   206

   207

    def _handle_PurgeBlobs(self, sequence, codec):

   208

        # Read incoming parameters.

   209

   210

        # Invoke user implementation of remote function.

   211

        _result = self._handler.PurgeBlobs()

   212

   213

        # Prepare codec for reply message.

   214

        codec.reset()

   215

   216

        # Construct reply message.

   217

        codec.start_write_message(erpc.codec.MessageInfo(

   218

            type=erpc.codec.MessageType.kReplyMessage,

   219

            service=interface.IBeremizPLCObjectService.SERVICE_ID,

   220

            request=interface.IBeremizPLCObjectService.PURGEBLOBS_ID,

   221

            sequence=sequence))

   222

        codec.write_uint32(_result)

   223

   224

    def _handle_RepairPLC(self, sequence, codec):

   225

        # Read incoming parameters.

   226

   227

        # Invoke user implementation of remote function.

   228

        _result = self._handler.RepairPLC()

   229

   230

        # Prepare codec for reply message.

   231

        codec.reset()

   232

   233

        # Construct reply message.

   234

        codec.start_write_message(erpc.codec.MessageInfo(

   235

            type=erpc.codec.MessageType.kReplyMessage,

   236

            service=interface.IBeremizPLCObjectService.SERVICE_ID,

   237

            request=interface.IBeremizPLCObjectService.REPAIRPLC_ID,

   238

            sequence=sequence))

   239

        codec.write_uint32(_result)

   240

   241

    def _handle_ResetLogCount(self, sequence, codec):

   242

        # Read incoming parameters.

   243

   244

        # Invoke user implementation of remote function.

   245

        _result = self._handler.ResetLogCount()

   246

   247

        # Prepare codec for reply message.

   248

        codec.reset()

   249

   250

        # Construct reply message.

   251

        codec.start_write_message(erpc.codec.MessageInfo(

   252

            type=erpc.codec.MessageType.kReplyMessage,

   253

            service=interface.IBeremizPLCObjectService.SERVICE_ID,

   254

            request=interface.IBeremizPLCObjectService.RESETLOGCOUNT_ID,

   255

            sequence=sequence))

   256

        codec.write_uint32(_result)

   257

   258

    def _handle_SeedBlob(self, sequence, codec):

   259

        # Create reference objects to pass into handler for out/inout parameters.

   260

        blobID = erpc.Reference()

   261

   262

        # Read incoming parameters.

   263

        seed = codec.read_binary()

   264

   265

        # Invoke user implementation of remote function.

   266

        _result = self._handler.SeedBlob(seed, blobID)

   267

   268

        # Prepare codec for reply message.

   269

        codec.reset()

   270

   271

        # Construct reply message.

   272

        codec.start_write_message(erpc.codec.MessageInfo(

   273

            type=erpc.codec.MessageType.kReplyMessage,

   274

            service=interface.IBeremizPLCObjectService.SERVICE_ID,

   275

            request=interface.IBeremizPLCObjectService.SEEDBLOB_ID,

   276

            sequence=sequence))

   277

        if blobID.value is None:

   278

            raise ValueError("blobID.value is None")

   279

        codec.write_binary(blobID.value)

   280

        codec.write_uint32(_result)

   281

   282

    def _handle_SetTraceVariablesList(self, sequence, codec):

   283

        # Read incoming parameters.

   284

        _n0 = codec.start_read_list()

   285

        orders = []

   286

        for _i0 in range(_n0):

   287

            _v0 = common.trace_order()._read(codec)

   288

            orders.append(_v0)

   289

   290

   291

        # Invoke user implementation of remote function.

   292

        _result = self._handler.SetTraceVariablesList(orders)

   293

   294

        # Prepare codec for reply message.

   295

        codec.reset()

   296

   297

        # Construct reply message.

   298

        codec.start_write_message(erpc.codec.MessageInfo(

   299

            type=erpc.codec.MessageType.kReplyMessage,

   300

            service=interface.IBeremizPLCObjectService.SERVICE_ID,

   301

            request=interface.IBeremizPLCObjectService.SETTRACEVARIABLESLIST_ID,

   302

            sequence=sequence))

   303

        codec.write_uint32(_result)

   304

   305

    def _handle_StartPLC(self, sequence, codec):

   306

        # Read incoming parameters.

   307

   308

        # Invoke user implementation of remote function.

   309

        _result = self._handler.StartPLC()

   310

   311

        # Prepare codec for reply message.

   312

        codec.reset()

   313

   314

        # Construct reply message.

   315

        codec.start_write_message(erpc.codec.MessageInfo(

   316

            type=erpc.codec.MessageType.kReplyMessage,

   317

            service=interface.IBeremizPLCObjectService.SERVICE_ID,

   318

            request=interface.IBeremizPLCObjectService.STARTPLC_ID,

   319

            sequence=sequence))

   320

        codec.write_uint32(_result)

   321

   322

    def _handle_StopPLC(self, sequence, codec):

   323

        # Read incoming parameters.

   324

   325

        # Invoke user implementation of remote function.

   326

        _result = self._handler.StopPLC()

   327

   328

        # Prepare codec for reply message.

   329

        codec.reset()

   330

   331

        # Construct reply message.

   332

        codec.start_write_message(erpc.codec.MessageInfo(

   333

            type=erpc.codec.MessageType.kReplyMessage,

   334

            service=interface.IBeremizPLCObjectService.SERVICE_ID,

   335

            request=interface.IBeremizPLCObjectService.STOPPLC_ID,

   336

            sequence=sequence))

   337

        codec.write_uint32(_result)

   338

   339