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