1

#

     2

# Generated by erpcgen 1.13.0 on Fri Nov  8 11:06:24 2024.

     3

#

     4

# AUTOGENERATED - DO NOT EDIT

     5

#

     6

     7

import erpc

     8

from . import common, interface

     9

    10

# Client for BeremizPLCObjectService

    11

class BeremizPLCObjectServiceClient(interface.IBeremizPLCObjectService):

    12

    def __init__(self, manager):

    13

        super(BeremizPLCObjectServiceClient, self).__init__()

    14

        self._clientManager = manager

    15

    16

    def AppendChunkToBlob(self, data, blobID, newBlobID):

    17

        assert type(newBlobID) is erpc.Reference, "out parameter must be a Reference object"

    18

    19

        # Build remote function invocation message.

    20

        request = self._clientManager.create_request()

    21

        codec = request.codec

    22

        codec.start_write_message(erpc.codec.MessageInfo(

    23

                type=erpc.codec.MessageType.kInvocationMessage,

    24

                service=self.SERVICE_ID,

    25

                request=self.APPENDCHUNKTOBLOB_ID,

    26

                sequence=request.sequence))

    27

        if data is None:

    28

            raise ValueError("data is None")

    29

        codec.write_binary(data)

    30

        if blobID is None:

    31

            raise ValueError("blobID is None")

    32

        codec.write_binary(blobID)

    33

    34

        # Send request and process reply.

    35

        self._clientManager.perform_request(request)

    36

        newBlobID.value = codec.read_binary()

    37

        _result = codec.read_uint32()

    38

        return _result

    39

    40

    def GetLogMessage(self, level, msgID, message):

    41

        assert type(message) is erpc.Reference, "out parameter must be a Reference object"

    42

    43

        # Build remote function invocation message.

    44

        request = self._clientManager.create_request()

    45

        codec = request.codec

    46

        codec.start_write_message(erpc.codec.MessageInfo(

    47

                type=erpc.codec.MessageType.kInvocationMessage,

    48

                service=self.SERVICE_ID,

    49

                request=self.GETLOGMESSAGE_ID,

    50

                sequence=request.sequence))

    51

        if level is None:

    52

            raise ValueError("level is None")

    53

        codec.write_uint8(level)

    54

        if msgID is None:

    55

            raise ValueError("msgID is None")

    56

        codec.write_uint32(msgID)

    57

    58

        # Send request and process reply.

    59

        self._clientManager.perform_request(request)

    60

        message.value = common.log_message()._read(codec)

    61

        _result = codec.read_uint32()

    62

        return _result

    63

    64

    def GetPLCID(self, plcID):

    65

        assert type(plcID) is erpc.Reference, "out parameter must be a Reference object"

    66

    67

        # Build remote function invocation message.

    68

        request = self._clientManager.create_request()

    69

        codec = request.codec

    70

        codec.start_write_message(erpc.codec.MessageInfo(

    71

                type=erpc.codec.MessageType.kInvocationMessage,

    72

                service=self.SERVICE_ID,

    73

                request=self.GETPLCID_ID,

    74

                sequence=request.sequence))

    75

    76

        # Send request and process reply.

    77

        self._clientManager.perform_request(request)

    78

        plcID.value = common.PSKID()._read(codec)

    79

        _result = codec.read_uint32()

    80

        return _result

    81

    82

    def GetPLCstatus(self, status):

    83

        assert type(status) is erpc.Reference, "out parameter must be a Reference object"

    84

    85

        # Build remote function invocation message.

    86

        request = self._clientManager.create_request()

    87

        codec = request.codec

    88

        codec.start_write_message(erpc.codec.MessageInfo(

    89

                type=erpc.codec.MessageType.kInvocationMessage,

    90

                service=self.SERVICE_ID,

    91

                request=self.GETPLCSTATUS_ID,

    92

                sequence=request.sequence))

    93

    94

        # Send request and process reply.

    95

        self._clientManager.perform_request(request)

    96

        status.value = common.PLCstatus()._read(codec)

    97

        _result = codec.read_uint32()

    98

        return _result

    99

   100

    def GetTraceVariables(self, debugToken, traces):

   101

        assert type(traces) is erpc.Reference, "out parameter must be a Reference object"

   102

   103

        # Build remote function invocation message.

   104

        request = self._clientManager.create_request()

   105

        codec = request.codec

   106

        codec.start_write_message(erpc.codec.MessageInfo(

   107

                type=erpc.codec.MessageType.kInvocationMessage,

   108

                service=self.SERVICE_ID,

   109

                request=self.GETTRACEVARIABLES_ID,

   110

                sequence=request.sequence))

   111

        if debugToken is None:

   112

            raise ValueError("debugToken is None")

   113

        codec.write_uint32(debugToken)

   114

   115

        # Send request and process reply.

   116

        self._clientManager.perform_request(request)

   117

        traces.value = common.TraceVariables()._read(codec)

   118

        _result = codec.read_uint32()

   119

        return _result

   120

   121

    def MatchMD5(self, MD5, match):

   122

        assert type(match) is erpc.Reference, "out parameter must be a Reference object"

   123

   124

        # Build remote function invocation message.

   125

        request = self._clientManager.create_request()

   126

        codec = request.codec

   127

        codec.start_write_message(erpc.codec.MessageInfo(

   128

                type=erpc.codec.MessageType.kInvocationMessage,

   129

                service=self.SERVICE_ID,

   130

                request=self.MATCHMD5_ID,

   131

                sequence=request.sequence))

   132

        if MD5 is None:

   133

            raise ValueError("MD5 is None")

   134

        codec.write_string(MD5)

   135

   136

        # Send request and process reply.

   137

        self._clientManager.perform_request(request)

   138

        match.value = codec.read_bool()

   139

        _result = codec.read_uint32()

   140

        return _result

   141

   142

    def NewPLC(self, md5sum, plcObjectBlobID, extrafiles, success):

   143

        assert type(success) is erpc.Reference, "out parameter must be a Reference object"

   144

   145

        # Build remote function invocation message.

   146

        request = self._clientManager.create_request()

   147

        codec = request.codec

   148

        codec.start_write_message(erpc.codec.MessageInfo(

   149

                type=erpc.codec.MessageType.kInvocationMessage,

   150

                service=self.SERVICE_ID,

   151

                request=self.NEWPLC_ID,

   152

                sequence=request.sequence))

   153

        if md5sum is None:

   154

            raise ValueError("md5sum is None")

   155

        codec.write_string(md5sum)

   156

        if plcObjectBlobID is None:

   157

            raise ValueError("plcObjectBlobID is None")

   158

        codec.write_binary(plcObjectBlobID)

   159

        if extrafiles is None:

   160

            raise ValueError("extrafiles is None")

   161

        codec.start_write_list(len(extrafiles))

   162

        for _i0 in extrafiles:

   163

            _i0._write(codec)

   164

   165

   166

        # Send request and process reply.

   167

        self._clientManager.perform_request(request)

   168

        success.value = codec.read_bool()

   169

        _result = codec.read_uint32()

   170

        return _result

   171

   172

    def PurgeBlobs(self):

   173

        # Build remote function invocation message.

   174

        request = self._clientManager.create_request()

   175

        codec = request.codec

   176

        codec.start_write_message(erpc.codec.MessageInfo(

   177

                type=erpc.codec.MessageType.kInvocationMessage,

   178

                service=self.SERVICE_ID,

   179

                request=self.PURGEBLOBS_ID,

   180

                sequence=request.sequence))

   181

   182

        # Send request and process reply.

   183

        self._clientManager.perform_request(request)

   184

        _result = codec.read_uint32()

   185

        return _result

   186

   187

    def RepairPLC(self):

   188

        # Build remote function invocation message.

   189

        request = self._clientManager.create_request()

   190

        codec = request.codec

   191

        codec.start_write_message(erpc.codec.MessageInfo(

   192

                type=erpc.codec.MessageType.kInvocationMessage,

   193

                service=self.SERVICE_ID,

   194

                request=self.REPAIRPLC_ID,

   195

                sequence=request.sequence))

   196

   197

        # Send request and process reply.

   198

        self._clientManager.perform_request(request)

   199

        _result = codec.read_uint32()

   200

        return _result

   201

   202

    def ResetLogCount(self):

   203

        # Build remote function invocation message.

   204

        request = self._clientManager.create_request()

   205

        codec = request.codec

   206

        codec.start_write_message(erpc.codec.MessageInfo(

   207

                type=erpc.codec.MessageType.kInvocationMessage,

   208

                service=self.SERVICE_ID,

   209

                request=self.RESETLOGCOUNT_ID,

   210

                sequence=request.sequence))

   211

   212

        # Send request and process reply.

   213

        self._clientManager.perform_request(request)

   214

        _result = codec.read_uint32()

   215

        return _result

   216

   217

    def SeedBlob(self, seed, blobID):

   218

        assert type(blobID) is erpc.Reference, "out parameter must be a Reference object"

   219

   220

        # Build remote function invocation message.

   221

        request = self._clientManager.create_request()

   222

        codec = request.codec

   223

        codec.start_write_message(erpc.codec.MessageInfo(

   224

                type=erpc.codec.MessageType.kInvocationMessage,

   225

                service=self.SERVICE_ID,

   226

                request=self.SEEDBLOB_ID,

   227

                sequence=request.sequence))

   228

        if seed is None:

   229

            raise ValueError("seed is None")

   230

        codec.write_binary(seed)

   231

   232

        # Send request and process reply.

   233

        self._clientManager.perform_request(request)

   234

        blobID.value = codec.read_binary()

   235

        _result = codec.read_uint32()

   236

        return _result

   237

   238

    def SetTraceVariablesList(self, orders, debugtoken):

   239

        assert type(debugtoken) is erpc.Reference, "out parameter must be a Reference object"

   240

   241

        # Build remote function invocation message.

   242

        request = self._clientManager.create_request()

   243

        codec = request.codec

   244

        codec.start_write_message(erpc.codec.MessageInfo(

   245

                type=erpc.codec.MessageType.kInvocationMessage,

   246

                service=self.SERVICE_ID,

   247

                request=self.SETTRACEVARIABLESLIST_ID,

   248

                sequence=request.sequence))

   249

        if orders is None:

   250

            raise ValueError("orders is None")

   251

        codec.start_write_list(len(orders))

   252

        for _i0 in orders:

   253

            _i0._write(codec)

   254

   255

   256

        # Send request and process reply.

   257

        self._clientManager.perform_request(request)

   258

        debugtoken.value = codec.read_int32()

   259

        _result = codec.read_uint32()

   260

        return _result

   261

   262

    def StartPLC(self):

   263

        # Build remote function invocation message.

   264

        request = self._clientManager.create_request()

   265

        codec = request.codec

   266

        codec.start_write_message(erpc.codec.MessageInfo(

   267

                type=erpc.codec.MessageType.kInvocationMessage,

   268

                service=self.SERVICE_ID,

   269

                request=self.STARTPLC_ID,

   270

                sequence=request.sequence))

   271

   272

        # Send request and process reply.

   273

        self._clientManager.perform_request(request)

   274

        _result = codec.read_uint32()

   275

        return _result

   276

   277

    def StopPLC(self, success):

   278

        assert type(success) is erpc.Reference, "out parameter must be a Reference object"

   279

   280

        # Build remote function invocation message.

   281

        request = self._clientManager.create_request()

   282

        codec = request.codec

   283

        codec.start_write_message(erpc.codec.MessageInfo(

   284

                type=erpc.codec.MessageType.kInvocationMessage,

   285

                service=self.SERVICE_ID,

   286

                request=self.STOPPLC_ID,

   287

                sequence=request.sequence))

   288

   289

        # Send request and process reply.

   290

        self._clientManager.perform_request(request)

   291

        success.value = codec.read_bool()

   292

        _result = codec.read_uint32()

   293

        return _result

   294

   295

    def ExtendedCall(self, method, argument, answer):

   296

        assert type(answer) is erpc.Reference, "out parameter must be a Reference object"

   297

   298

        # Build remote function invocation message.

   299

        request = self._clientManager.create_request()

   300

        codec = request.codec

   301

        codec.start_write_message(erpc.codec.MessageInfo(

   302

                type=erpc.codec.MessageType.kInvocationMessage,

   303

                service=self.SERVICE_ID,

   304

                request=self.EXTENDEDCALL_ID,

   305

                sequence=request.sequence))

   306

        if method is None:

   307

            raise ValueError("method is None")

   308

        codec.write_string(method)

   309

        if argument is None:

   310

            raise ValueError("argument is None")

   311

        codec.write_binary(argument)

   312

   313

        # Send request and process reply.

   314

        self._clientManager.perform_request(request)

   315

        answer.value = codec.read_binary()

   316

        _result = codec.read_uint32()

   317

        return _result

   318

   319