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 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):

   239         # Build remote function invocation message.

   240         request = self._clientManager.create_request()

   241         codec = request.codec

   242         codec.start_write_message(erpc.codec.MessageInfo(

   243                 type=erpc.codec.MessageType.kInvocationMessage,

   244                 service=self.SERVICE_ID,

   245                 request=self.SETTRACEVARIABLESLIST_ID,

   246                 sequence=request.sequence))

   247         if orders is None:

   248             raise ValueError("orders is None")

   249         codec.start_write_list(len(orders))

   250         for _i0 in orders:

   251             _i0._write(codec)

   252 

   253 

   254         # Send request and process reply.

   255         self._clientManager.perform_request(request)

   256         _result = codec.read_uint32()

   257         return _result

   258 

   259     def StartPLC(self):

   260         # Build remote function invocation message.

   261         request = self._clientManager.create_request()

   262         codec = request.codec

   263         codec.start_write_message(erpc.codec.MessageInfo(

   264                 type=erpc.codec.MessageType.kInvocationMessage,

   265                 service=self.SERVICE_ID,

   266                 request=self.STARTPLC_ID,

   267                 sequence=request.sequence))

   268 

   269         # Send request and process reply.

   270         self._clientManager.perform_request(request)

   271         _result = codec.read_uint32()

   272         return _result

   273 

   274     def StopPLC(self):

   275         # Build remote function invocation message.

   276         request = self._clientManager.create_request()

   277         codec = request.codec

   278         codec.start_write_message(erpc.codec.MessageInfo(

   279                 type=erpc.codec.MessageType.kInvocationMessage,

   280                 service=self.SERVICE_ID,

   281                 request=self.STOPPLC_ID,

   282                 sequence=request.sequence))

   283 

   284         # Send request and process reply.

   285         self._clientManager.perform_request(request)

   286         _result = codec.read_uint32()

   287         return _result

   288 

   289