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

    41

    42

# Structures data types declarations

    43

class log_message(object):

    44

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

    45

        self.msg = msg # string

    46

        self.tick = tick # uint32

    47

        self.sec = sec # uint32

    48

        self.nsec = nsec # uint32

    49

    50

    def _read(self, codec):

    51

        self.msg = codec.read_string()

    52

        self.tick = codec.read_uint32()

    53

        self.sec = codec.read_uint32()

    54

        self.nsec = codec.read_uint32()

    55

        return self

    56

    57

    def _write(self, codec):

    58

        if self.msg is None:

    59

            raise ValueError("msg is None")

    60

        codec.write_string(self.msg)

    61

        if self.tick is None:

    62

            raise ValueError("tick is None")

    63

        codec.write_uint32(self.tick)

    64

        if self.sec is None:

    65

            raise ValueError("sec is None")

    66

        codec.write_uint32(self.sec)

    67

        if self.nsec is None:

    68

            raise ValueError("nsec is None")

    69

        codec.write_uint32(self.nsec)

    70

    71

    def __str__(self):

    72

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

    73

    74

    def __repr__(self):

    75

        return self.__str__()

    76

    77

class PSKID(object):

    78

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

    79

        self.ID = ID # string

    80

        self.PSK = PSK # string

    81

    82

    def _read(self, codec):

    83

        self.ID = codec.read_string()

    84

        self.PSK = codec.read_string()

    85

        return self

    86

    87

    def _write(self, codec):

    88

        if self.ID is None:

    89

            raise ValueError("ID is None")

    90

        codec.write_string(self.ID)

    91

        if self.PSK is None:

    92

            raise ValueError("PSK is None")

    93

        codec.write_string(self.PSK)

    94

    95

    def __str__(self):

    96

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

    97

    98

    def __repr__(self):

    99

        return self.__str__()

   100

   101

class PLCstatus(object):

   102

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

   103

        self.PLCstatus = PLCstatus # PLCstatus_enum

   104

        self.logcounts = logcounts # uint32[4]

   105

   106

   107

    def _read(self, codec):

   108

        self.PLCstatus = codec.read_int32()

   109

        self.logcounts = []

   110

        for _i0 in range(4):

   111

            _v0 = codec.read_uint32()

   112

            self.logcounts.append(_v0)

   113

   114

        return self

   115

   116

    def _write(self, codec):

   117

        if self.PLCstatus is None:

   118

            raise ValueError("PLCstatus is None")

   119

        codec.write_int32(self.PLCstatus)

   120

        if self.logcounts is None:

   121

            raise ValueError("logcounts is None")

   122

        for _i0 in self.logcounts:

   123

            codec.write_uint32(_i0)

   124

   125

   126

    def __str__(self):

   127

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

   128

   129

    def __repr__(self):

   130

        return self.__str__()

   131

   132

class trace_sample(object):

   133

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

   134

        self.tick = tick # uint32

   135

        self.TraceBuffer = TraceBuffer # binary

   136

   137

    def _read(self, codec):

   138

        self.tick = codec.read_uint32()

   139

        self.TraceBuffer = codec.read_binary()

   140

        return self

   141

   142

    def _write(self, codec):

   143

        if self.tick is None:

   144

            raise ValueError("tick is None")

   145

        codec.write_uint32(self.tick)

   146

        if self.TraceBuffer is None:

   147

            raise ValueError("TraceBuffer is None")

   148

        codec.write_binary(self.TraceBuffer)

   149

   150

    def __str__(self):

   151

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

   152

   153

    def __repr__(self):

   154

        return self.__str__()

   155

   156

class TraceVariables(object):

   157

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

   158

        self.PLCstatus = PLCstatus # PLCstatus_enum

   159

        self.traces = traces # list<trace_sample>

   160

   161

    def _read(self, codec):

   162

        self.PLCstatus = codec.read_int32()

   163

        _n0 = codec.start_read_list()

   164

        self.traces = []

   165

        for _i0 in range(_n0):

   166

            _v0 = trace_sample()._read(codec)

   167

            self.traces.append(_v0)

   168

   169

        return self

   170

   171

    def _write(self, codec):

   172

        if self.PLCstatus is None:

   173

            raise ValueError("PLCstatus is None")

   174

        codec.write_int32(self.PLCstatus)

   175

        if self.traces is None:

   176

            raise ValueError("traces is None")

   177

        codec.start_write_list(len(self.traces))

   178

        for _i0 in self.traces:

   179

            _i0._write(codec)

   180

   181

   182

    def __str__(self):

   183

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

   184

   185

    def __repr__(self):

   186

        return self.__str__()

   187

   188

class extra_file(object):

   189

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

   190

        self.fname = fname # string

   191

        self.blobID = blobID # binary

   192

   193

    def _read(self, codec):

   194

        self.fname = codec.read_string()

   195

        self.blobID = codec.read_binary()

   196

        return self

   197

   198

    def _write(self, codec):

   199

        if self.fname is None:

   200

            raise ValueError("fname is None")

   201

        codec.write_string(self.fname)

   202

        if self.blobID is None:

   203

            raise ValueError("blobID is None")

   204

        codec.write_binary(self.blobID)

   205

   206

    def __str__(self):

   207

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

   208

   209

    def __repr__(self):

   210

        return self.__str__()

   211

   212

class trace_order(object):

   213

    def __init__(self, idx=None, iectype=None, force=None):

   214

        self.idx = idx # uint32

   216

        self.force = force # binary

   217

   218

    def _read(self, codec):

   219

        self.idx = codec.read_uint32()

   221

        self.force = codec.read_binary()

   222

        return self

   223

   224

    def _write(self, codec):

   225

        if self.idx is None:

   226

            raise ValueError("idx is None")

   227

        codec.write_uint32(self.idx)

   228

        if self.iectype is None:

   229

            raise ValueError("iectype is None")

   231

        if self.force is None:

   232

            raise ValueError("force is None")

   233

        codec.write_binary(self.force)

   234

   235

    def __str__(self):

   236

        return "<%s@%x idx=%s iectype=%s force=%s>" % (self.__class__.__name__, id(self), self.idx, self.iectype, self.force)

   237

   238

    def __repr__(self):

   239

        return self.__str__()

   240