1

#

     3

#

     4

# AUTOGENERATED - DO NOT EDIT

     5

#

     6

     7

     8

# Enumerators data types declarations

     9

class PLCstatus_enum:

    10

    Empty = 0

    11

    Stopped = 1

    12

    Started = 2

    13

    Broken = 3

    14

    Disconnected = 4

    15

    16

    17

# Structures data types declarations

    18

class log_message(object):

    19

    def __init__(self, msg=None, tick=None, sec=None, nsec=None):

    20

        self.msg = msg # string

    21

        self.tick = tick # uint32

    22

        self.sec = sec # uint32

    23

        self.nsec = nsec # uint32

    24

    25

    def _read(self, codec):

    26

        self.msg = codec.read_string()

    27

        self.tick = codec.read_uint32()

    28

        self.sec = codec.read_uint32()

    29

        self.nsec = codec.read_uint32()

    30

        return self

    31

    32

    def _write(self, codec):

    33

        if self.msg is None:

    34

            raise ValueError("msg is None")

    35

        codec.write_string(self.msg)

    36

        if self.tick is None:

    37

            raise ValueError("tick is None")

    38

        codec.write_uint32(self.tick)

    39

        if self.sec is None:

    40

            raise ValueError("sec is None")

    41

        codec.write_uint32(self.sec)

    42

        if self.nsec is None:

    43

            raise ValueError("nsec is None")

    44

        codec.write_uint32(self.nsec)

    45

    46

    def __str__(self):

    47

        return "<%s@%x msg=%s tick=%s sec=%s nsec=%s>" % (self.__class__.__name__, id(self), self.msg, self.tick, self.sec, self.nsec)

    48

    49

    def __repr__(self):

    50

        return self.__str__()

    51

    52

class PSKID(object):

    53

    def __init__(self, ID=None, PSK=None):

    54

        self.ID = ID # string

    55

        self.PSK = PSK # string

    56

    57

    def _read(self, codec):

    58

        self.ID = codec.read_string()

    59

        self.PSK = codec.read_string()

    60

        return self

    61

    62

    def _write(self, codec):

    63

        if self.ID is None:

    64

            raise ValueError("ID is None")

    65

        codec.write_string(self.ID)

    66

        if self.PSK is None:

    67

            raise ValueError("PSK is None")

    68

        codec.write_string(self.PSK)

    69

    70

    def __str__(self):

    71

        return "<%s@%x ID=%s PSK=%s>" % (self.__class__.__name__, id(self), self.ID, self.PSK)

    72

    73

    def __repr__(self):

    74

        return self.__str__()

    75

    76

class PLCstatus(object):

    77

    def __init__(self, PLCstatus=None, logcounts=None):

    78

        self.PLCstatus = PLCstatus # PLCstatus_enum

    79

        self.logcounts = logcounts # uint32[4]

    80

    81

    82

    def _read(self, codec):

    83

        self.PLCstatus = codec.read_int32()

    84

        self.logcounts = []

    85

        for _i0 in range(4):

    86

            _v0 = codec.read_uint32()

    87

            self.logcounts.append(_v0)

    88

    89

        return self

    90

    91

    def _write(self, codec):

    92

        if self.PLCstatus is None:

    93

            raise ValueError("PLCstatus is None")

    94

        codec.write_int32(self.PLCstatus)

    95

        if self.logcounts is None:

    96

            raise ValueError("logcounts is None")

    97

        for _i0 in self.logcounts:

    98

            codec.write_uint32(_i0)

    99

   100

   101

    def __str__(self):

   102

        return "<%s@%x PLCstatus=%s logcounts=%s>" % (self.__class__.__name__, id(self), self.PLCstatus, self.logcounts)

   103

   104

    def __repr__(self):

   105

        return self.__str__()

   106

   107

class trace_sample(object):

   108

    def __init__(self, tick=None, TraceBuffer=None):

   109

        self.tick = tick # uint32

   110

        self.TraceBuffer = TraceBuffer # binary

   111

   112

    def _read(self, codec):

   113

        self.tick = codec.read_uint32()

   114

        self.TraceBuffer = codec.read_binary()

   115

        return self

   116

   117

    def _write(self, codec):

   118

        if self.tick is None:

   119

            raise ValueError("tick is None")

   120

        codec.write_uint32(self.tick)

   121

        if self.TraceBuffer is None:

   122

            raise ValueError("TraceBuffer is None")

   123

        codec.write_binary(self.TraceBuffer)

   124

   125

    def __str__(self):

   126

        return "<%s@%x tick=%s TraceBuffer=%s>" % (self.__class__.__name__, id(self), self.tick, self.TraceBuffer)

   127

   128

    def __repr__(self):

   129

        return self.__str__()

   130

   131

class TraceVariables(object):

   132

    def __init__(self, PLCstatus=None, traces=None):

   133

        self.PLCstatus = PLCstatus # PLCstatus_enum

   134

        self.traces = traces # list<trace_sample>

   135

   136

    def _read(self, codec):

   137

        self.PLCstatus = codec.read_int32()

   138

        _n0 = codec.start_read_list()

   139

        self.traces = []

   140

        for _i0 in range(_n0):

   141

            _v0 = trace_sample()._read(codec)

   142

            self.traces.append(_v0)

   143

   144

        return self

   145

   146

    def _write(self, codec):

   147

        if self.PLCstatus is None:

   148

            raise ValueError("PLCstatus is None")

   149

        codec.write_int32(self.PLCstatus)

   150

        if self.traces is None:

   151

            raise ValueError("traces is None")

   152

        codec.start_write_list(len(self.traces))

   153

        for _i0 in self.traces:

   154

            _i0._write(codec)

   155

   156

   157

    def __str__(self):

   158

        return "<%s@%x PLCstatus=%s traces=%s>" % (self.__class__.__name__, id(self), self.PLCstatus, self.traces)

   159

   160

    def __repr__(self):

   161

        return self.__str__()

   162

   163

class extra_file(object):

   164

    def __init__(self, fname=None, blobID=None):

   165

        self.fname = fname # string

   166

        self.blobID = blobID # binary

   167

   168

    def _read(self, codec):

   169

        self.fname = codec.read_string()

   170

        self.blobID = codec.read_binary()

   171

        return self

   172

   173

    def _write(self, codec):

   174

        if self.fname is None:

   175

            raise ValueError("fname is None")

   176

        codec.write_string(self.fname)

   177

        if self.blobID is None:

   178

            raise ValueError("blobID is None")

   179

        codec.write_binary(self.blobID)

   180

   181

    def __str__(self):

   182

        return "<%s@%x fname=%s blobID=%s>" % (self.__class__.__name__, id(self), self.fname, self.blobID)

   183

   184

    def __repr__(self):

   185

        return self.__str__()

   186

   187

class trace_order(object):

   189

        self.idx = idx # uint32

   190

        self.force = force # binary

   191

   192

    def _read(self, codec):

   193

        self.idx = codec.read_uint32()

   194

        self.force = codec.read_binary()

   195

        return self

   196

   197

    def _write(self, codec):

   198

        if self.idx is None:

   199

            raise ValueError("idx is None")

   200

        codec.write_uint32(self.idx)

   201

        if self.force is None:

   202

            raise ValueError("force is None")

   203

        codec.write_binary(self.force)

   204

   205

    def __str__(self):