1

from __future__ import print_function

     2

from __future__ import absolute_import

     3

     4

import csv

     5

import functools

     6

from threading import Thread

     7

from collections import OrderedDict

     8

     9

import wx

    10

import wx.dataview as dv

    11

    12

import util.paths as paths

    13

    14

# from perfect_hash import generate_code, IntSaltHash

    15

    16

MQTT_IEC_types = dict(

    17

# IEC61131|  C  type   | sz

    18

    BOOL  = ("uint8_t" , "X"),

    19

    SINT  = ("int8_t"  , "B"),

    20

    USINT = ("uint8_t" , "B"),

    21

    INT   = ("int16_t" , "W"),

    22

    UINT  = ("uint16_t", "W"),

    23

    DINT  = ("uint32_t", "D"),

    24

    UDINT = ("int32_t" , "D"),

    25

    LINT  = ("int64_t" , "L"),

    26

    ULINT = ("uint64_t", "L"),

    27

    REAL  = ("float"   , "D"),

    28

    LREAL = ("double"  , "L"),

    29

)

    30

    31

"""

    32

 QoS - Quality of Service

    33

  0  : "At most one delivery"

    34

  1  : "At least one delivery"

    35

  2  : "Exactly one delivery"

    36

"""

    37

QoS_values = [0, 1, 2]

    38

    39

def boolean(v):

    40

    if v in ["False","0"]:

    41

        return False

    42

    else:

    43

        return bool(v)

    44

    45

_lstcolnames  = [ "Topic",  "QoS",  "Retained", "Type", "Location"]

    46

_lstcolwidths = [     100,     50,         100,    100,         50]

    47

_lstcoltypess = [     str,    int,     boolean,    str,        int]

    48

_lstcoldeflts = [ "a/b/c",    "1",       False, "DINT",        "0"]

    49

    50

subsublist = lambda l : l[0:2] + l[3:5]

    51

    52

lstcoldsc = {

    53

    "input" : type("",(),dict(

    54

        lstcolnames  = subsublist(_lstcolnames),

    55

        lstcolwidths = subsublist(_lstcolwidths),

    56

        lstcoltypess = subsublist(_lstcoltypess),

    57

        lstcoldeflts = subsublist(_lstcoldeflts),

    58

        Location_column = 3)),

    59

    "output" : type("",(),dict(

    60

        lstcolnames  = _lstcolnames,

    61

        lstcolwidths = _lstcolwidths,

    62

        lstcoltypess = _lstcoltypess,

    63

        lstcoldeflts = _lstcoldeflts,

    64

        Location_column = 4)),

    65

}

    66

    67

directions = ["input", "output"]

    68

    69

authParams = {

    70

    "x509":[

    71

        ("Certificate", "certificate.der"),

    72

        ("PrivateKey", "private_key.pem")],

    73

    "UserPassword":[

    74

        ("User", None),

    75

        ("Password", None)]}

    76

    77

class MQTTTopicListModel(dv.PyDataViewIndexListModel):

    78

    def __init__(self, data, log, direction):

    79

        dv.PyDataViewIndexListModel.__init__(self, len(data))

    80

        self.data = data

    81

        self.log = log

    82

        self.dsc = lstcoldsc[direction]

    83

    84

    def GetColumnType(self, col):

    85

        return "string"

    86

    87

    def GetValueByRow(self, row, col):

    88

        return str(self.data[row][col])

    89

    90

    # This method is called when the user edits a data item in the view.

    91

    def SetValueByRow(self, value, row, col):

    92

        expectedtype = self.dsc.lstcoltypess[col]

    93

    94

        try:

    95

            v = expectedtype(value)

    96

        except ValueError: 

    97

            self.log("String {} is invalid for type {}\n".format(value,expectedtype.__name__))

    98

            return False

    99

   100

        if col == self.dsc.lstcolnames.index("QoS") and v not in QoS_values:

   101

            self.log("{} is invalid for IdType\n".format(value))

   102

            return False

   103

   104

        self.data[row][col] = v

   105

        return True

   106

   107

    # Report how many columns this model provides data for.

   108

    def GetColumnCount(self):

   109

        return len(self.dsc.lstcolnames)

   110

   111

    # Report the number of rows in the model

   112

    def GetCount(self):

   113

        #self.log.write('GetCount')

   114

        return len(self.data)

   115

   116

    # Called to check if non-standard attributes should be used in the

   117

    # cell at (row, col)

   118

    def GetAttrByRow(self, row, col, attr):

   119

        if col == self.dsc.Location_column:

   120

            attr.SetColour('blue')

   121

            attr.SetBold(True)

   122

            return True

   123

        return False

   124

   125

   126

    def DeleteRows(self, rows):

   127

        # make a copy since we'll be sorting(mutating) the list

   128

        # use reverse order so the indexes don't change as we remove items

   129

        rows = sorted(rows, reverse=True)

   130

   131

        for row in rows:

   132

            # remove it from our data structure

   133

            del self.data[row]

   134

            # notify the view(s) using this model that it has been removed

   135

            self.RowDeleted(row)

   136

   137

   138

    def AddRow(self, value):

   139

        if self.data.append(value):

   140

            # notify views

   141

            self.RowAppended()

   142

   143

    def InsertDefaultRow(self, row):

   144

        self.data.insert(row, self.dsc.lstcoldeflts[:])

   145

        # notify views

   146

        self.RowInserted(row)

   147

   148

    def ResetData(self):

   149

        self.Reset(len(self.data))

   150

   151

class MQTTTopicListPanel(wx.Panel):

   152

    def __init__(self, parent, log, model, direction):

   153

        self.log = log

   154

        wx.Panel.__init__(self, parent, -1)

   155

   156

        self.dvc = dv.DataViewCtrl(self,

   157

                                   style=wx.BORDER_THEME

   158

                                   | dv.DV_ROW_LINES

   159

                                   | dv.DV_HORIZ_RULES

   160

                                   | dv.DV_VERT_RULES

   161

                                   | dv.DV_MULTIPLE

   162

                                   )

   163

   164

        self.model = model

   165

   166

        self.dvc.AssociateModel(self.model)

   167

   168

        dsc = lstcoldsc[direction]

   169

        for idx,(colname,width) in enumerate(zip(dsc.lstcolnames,dsc.lstcolwidths)):

   170

            self.dvc.AppendTextColumn(colname,  idx, width=width, mode=dv.DATAVIEW_CELL_EDITABLE)

   171

   172

   173

        self.Sizer = wx.BoxSizer(wx.VERTICAL)

   174

   175

        self.direction =  direction

   176

        titlestr = direction + " variables"

   177

   178

        title = wx.StaticText(self, label = titlestr)

   179

   180

        addbt = wx.Button(self, label="Add")

   181

        self.Bind(wx.EVT_BUTTON, self.OnAddRow, addbt)

   182

        delbt = wx.Button(self, label="Delete")

   183

        self.Bind(wx.EVT_BUTTON, self.OnDeleteRows, delbt)

   184

   185

        topsizer = wx.BoxSizer(wx.HORIZONTAL)

   186

        topsizer.Add(title, 1, wx.ALIGN_CENTER_VERTICAL|wx.LEFT|wx.RIGHT, 5)

   187

        topsizer.Add(addbt, 0, wx.LEFT|wx.RIGHT, 5)

   188

        topsizer.Add(delbt, 0, wx.LEFT|wx.RIGHT, 5)

   189

        self.Sizer.Add(topsizer, 0, wx.EXPAND|wx.TOP|wx.BOTTOM, 5)

   190

        self.Sizer.Add(self.dvc, 1, wx.EXPAND)

   191

   192

   193

    def OnAddRow(self, evt):

   194

        items = self.dvc.GetSelections()

   195

        row = self.model.GetRow(items[0]) if items else 0

   196

        self.model.InsertDefaultRow(row)

   197

   198

    def OnDeleteRows(self, evt):

   199

        items = self.dvc.GetSelections()

   200

        rows = [self.model.GetRow(item) for item in items]

   201

        self.model.DeleteRows(rows)

   202

   203

   204

class MQTTClientPanel(wx.SplitterWindow):

   205

    def __init__(self, parent, modeldata, log, config_getter):

   206

        self.log = log

   207

        wx.SplitterWindow.__init__(self, parent, style=wx.SUNKEN_BORDER | wx.SP_3D)

   208

   209

        self.config_getter = config_getter

   210

   211

        self.selected_datas = modeldata

   212

        self.selected_models = { direction:MQTTTopicListModel(

   213

            self.selected_datas[direction], log, direction) for direction in directions }

   214

        self.selected_lists = { direction:MQTTTopicListPanel(

   215

                self, log, 

   216

                self.selected_models[direction], direction) 

   217

            for direction in directions }

   218

   219

        self.SplitHorizontally(*[self.selected_lists[direction] for direction in directions]+[300])

   220

   221

        self.SetAutoLayout(True)

   222

   223

    def OnClose(self):

   224

        pass

   225

   226

    def __del__(self):

   227

        self.OnClose()

   228

   229

    def Reset(self):

   230

        for direction in directions:

   231

            self.selected_models[direction].ResetData() 

   232

   233

   234

class MQTTClientList(list):

   235

    def __init__(self, log, change_callback, direction):

   236

        super(MQTTClientList, self).__init__(self)

   237

        self.log = log

   238

        self.change_callback = change_callback

   239

        self.dsc = lstcoldsc[direction]

   240

   241

    def append(self, value):

   242

        v = dict(list(zip(self.dsc.lstcolnames, value)))

   243

   244

        if type(v["Location"]) != int:

   245

            if len(self) == 0:

   246

                v["Location"] = 0

   247

            else:

   248

                iecnums = set(zip(*self)[self.dsc.Location_column])

   249

                greatest = max(iecnums)

   250

                holes = set(range(greatest)) - iecnums

   251

                v["Location"] = min(holes) if holes else greatest+1

   252

   253

        if v["QoS"] not in QoS_values:

   254

            self.log("Unknown QoS\n".format(value))

   255

            return False

   256

   257

        try:

   258

            for t,n in zip(self.dsc.lstcoltypess, self.dsc.lstcolnames):

   259

                v[n] = t(v[n]) 

   260

        except ValueError: 

   261

            self.log("MQTT topic {} (Location={}) has invalid type\n".format(v["Topic"],v["Location"]))

   262

            return False

   263

   264

        if len(self)>0 and v["Topic"] in list(zip(*self))[self.dsc.lstcolnames.index("Topic")]:

   265

            self.log("MQTT topic {} (Location={}) already in the list\n".format(v["Topic"],v["Location"]))

   266

            return False

   267

   268

        list.append(self, [v[n] for n in self.dsc.lstcolnames])

   269

   270

        self.change_callback()

   271

   272

        return True

   273

   274

    def __delitem__(self, index):

   275

        list.__delitem__(self, index)

   276

        self.change_callback()

   277

   278

class MQTTClientModel(dict):

   279

    def __init__(self, log, change_callback = lambda : None):

   280

        super(MQTTClientModel, self).__init__()

   281

        for direction in directions:

   282

            self[direction] = MQTTClientList(log, change_callback, direction)

   283

   284

    def LoadCSV(self,path):

   285

        with open(path, 'r') as csvfile:

   286

            reader = csv.reader(csvfile, delimiter=',', quotechar='"')

   287

            buf = {direction:[] for direction, _model in self.iteritems()}

   288

            for direction, model in self.iteritems():

   289

                self[direction][:] = []

   290

            for row in reader:

   291

                direction = row[0]

   292

                # avoids calling change callback when loading CSV

   293

                list.append(self[direction],row[1:])

   294

   295

    def SaveCSV(self,path):

   296

        with open(path, 'w') as csvfile:

   297

            for direction, data in self.items():

   298

                writer = csv.writer(csvfile, delimiter=',',

   299

                                quotechar='"', quoting=csv.QUOTE_MINIMAL)

   300

                for row in data:

   301

                    writer.writerow([direction] + row)

   302

   303

    def GenerateC(self, path, locstr, config):

   304

        c_template_filepath = paths.AbsNeighbourFile(__file__, "mqtt_template.c")

   305

        c_template_file = open(c_template_filepath , 'rb')

   306

        c_template = c_template_file.read()

   307

        c_template_file.close()

   308

   309

        formatdict = dict(

   310

            locstr          = locstr,

   311

            uri             = config["URI"],

   312

            clientID        = config["clientID"],

   313

            decl            = "",

   314

            topics          = "",

   315

            cleanup         = "",

   316

            init            = "",

   317

            retrieve        = "",

   318

            publish         = "",

   319

            publish_changes = ""

   320

        )

   321

   322

   323

        # Use Config's "MQTTVersion" to switch between protocol version at build time

   324

        if config["UseMQTT5"]:

   325

            formatdict["decl"] += """

   326

#define USE_MQTT_5""".format(**config)

   327

   328

        AuthType = config["AuthType"]

   329

        if AuthType == "x509":

   330

            formatdict["init"] += """

   331

    INIT_x509("{PrivateKey}", "{Certificate}")""".format(**config)

   332

        elif AuthType == "UserPassword":

   333

            formatdict["init"] += """

   334

    INIT_UserPassword("{User}", "{Password}")""".format(**config)

   335

        else:

   336

            formatdict["init"] += """

   337

    INIT_NoAuth()"""

   338

   339

        for row in self["output"]:

   340

            Topic, QoS, _Retained, iec_type, iec_number = row

   341

            Retained = 1 if _Retained=="True" else 0

   342

            C_type, iec_size_prefix = MQTT_IEC_types[iec_type]

   343

            c_loc_name = "__Q" + iec_size_prefix + locstr + "_" + str(iec_number)

   344

   345

            formatdict["decl"] += """

   346

DECL_VAR({iec_type}, {C_type}, {c_loc_name})""".format(**locals())

   347

            formatdict["init"] += """

   348

    INIT_PUBLICATION({Topic}, {QoS}, {C_type}, {c_loc_name}, {Retained})""".format(**locals())

   349

            formatdict["publish"] += """

   350

        WRITE_VALUE({c_loc_name}, {C_type})""".format(**locals())

   351

            formatdict["publish_changes"] += """

   352

            PUBLISH_CHANGE({Topic}, {QoS}, {C_type}, {c_loc_name}, {Retained})""".format(**locals())

   353

   354

        # inputs need to be sorted for bisection search 

   355

        for row in sorted(self["input"]):

   356

            Topic, QoS, iec_type, iec_number = row

   357

            C_type, iec_size_prefix = MQTT_IEC_types[iec_type]

   358

            c_loc_name = "__I" + iec_size_prefix + locstr + "_" + str(iec_number)

   359

            formatdict["decl"] += """

   360

DECL_VAR({iec_type}, {C_type}, {c_loc_name})""".format(**locals())

   361

            formatdict["topics"] += """

   362

    INIT_TOPIC({Topic}, {iec_type}, {c_loc_name})""".format(**locals())

   363

            formatdict["init"] += """

   364

    INIT_SUBSCRIPTION({Topic}, {QoS})""".format(**locals())

   365

            formatdict["retrieve"] += """

   366

        READ_VALUE({c_loc_name}, {C_type})""".format(**locals())

   367

   368

        Ccode = c_template.format(**formatdict)

   369

   370

        return Ccode

   371

   372

if __name__ == "__main__":

   373

   374

    import wx.lib.mixins.inspection as wit

   375

    import sys,os

   376

   377

    app = wit.InspectableApp()

   378

   379

    frame = wx.Frame(None, -1, "MQTT Client Test App", size=(800,600))

   380

   381

    argc = len(sys.argv)

   382

   383

    config={}

   384

    config["URI"] = sys.argv[1] if argc>1 else "tcp://localhost:1883"

   385

    config["clientID"] = sys.argv[2] if argc>2 else ""

   386

    config["AuthType"] = None

   387

    config["UseMQTT5"] = True

   388

   389

    if argc > 3:

   390

        AuthType = sys.argv[3]

   391

        config["AuthType"] = AuthType

   392

        for (name, default), value in zip_longest(authParams[AuthType], sys.argv[4:]):

   393

            if value is None:

   394

                if default is None:

   395

                    raise Exception(name+" param expected")

   396

                value = default

   397

            config[name] = value

   398

   399

    test_panel = wx.Panel(frame)

   400

    test_sizer = wx.FlexGridSizer(cols=1, hgap=0, rows=2, vgap=0)

   401

    test_sizer.AddGrowableCol(0)

   402

    test_sizer.AddGrowableRow(0)

   403

   404

    modeldata = MQTTClientModel(print)

   405

   406

    mqtttestpanel = MQTTClientPanel(test_panel, modeldata, print, lambda:config)

   407

   408

    def OnGenerate(evt):

   409

        dlg = wx.FileDialog(

   410

            frame, message="Generate file as ...", defaultDir=os.getcwd(),

   411

            defaultFile="",

   412

            wildcard="C (*.c)|*.c", style=wx.FD_SAVE | wx.FD_OVERWRITE_PROMPT

   413

            )

   414

   415

        if dlg.ShowModal() == wx.ID_OK:

   416

            path = dlg.GetPath()

   417

            Ccode = """

   418

/*

   419

In case open62541 was built just aside beremiz, you can build this test with:

   420

gcc %s -o %s \\

   421

    -I ../../open62541/plugins/include/ \\

   422

    -I ../../open62541/build/src_generated/ \\

   423

    -I ../../open62541/include/ \\

   424

    -I ../../open62541/arch/ ../../open62541/build/bin/libopen62541.a

   425

*/

   426

   427

"""%(path, path[:-2]) + modeldata.GenerateC(path, "test", config) + """

   428

   429

int LogMessage(uint8_t level, char* buf, uint32_t size){

   430

    printf("log level:%d message:'%.*s'\\n", level, size, buf);

   431

};

   432

   433

int main(int argc, char *argv[]) {

   434

   435

    __init_test(arc,argv);

   436

   437

    __retrieve_test();

   438

   439

    __publish_test();

   440

   441

    __cleanup_test();

   442

   443

    return EXIT_SUCCESS;

   444

}

   445

"""

   446

   447

            with open(path, 'w') as Cfile:

   448

                Cfile.write(Ccode)

   449

   450

   451

        dlg.Destroy()

   452

   453

    def OnLoad(evt):

   454

        dlg = wx.FileDialog(

   455

            frame, message="Choose a file",

   456

            defaultDir=os.getcwd(),

   457

            defaultFile="",

   458

            wildcard="CSV (*.csv)|*.csv",

   459

            style=wx.FD_OPEN | wx.FD_CHANGE_DIR | wx.FD_FILE_MUST_EXIST )

   460

   461

        if dlg.ShowModal() == wx.ID_OK:

   462

            path = dlg.GetPath()

   463

            modeldata.LoadCSV(path)

   464

            mqtttestpanel.Reset()

   465

   466

        dlg.Destroy()

   467

   468

    def OnSave(evt):

   469

        dlg = wx.FileDialog(

   470

            frame, message="Save file as ...", defaultDir=os.getcwd(),

   471

            defaultFile="",

   472

            wildcard="CSV (*.csv)|*.csv", style=wx.FD_SAVE | wx.FD_OVERWRITE_PROMPT

   473

            )

   474

   475

        if dlg.ShowModal() == wx.ID_OK:

   476

            path = dlg.GetPath()

   477

            modeldata.SaveCSV(path)

   478

   479

        dlg.Destroy()

   480

   481

    test_sizer.Add(mqtttestpanel, flag=wx.GROW|wx.EXPAND)

   482

   483

    testbt_sizer = wx.BoxSizer(wx.HORIZONTAL)

   484

   485

    loadbt = wx.Button(test_panel, label="Load")

   486

    test_panel.Bind(wx.EVT_BUTTON, OnLoad, loadbt)

   487

   488

    savebt = wx.Button(test_panel, label="Save")

   489

    test_panel.Bind(wx.EVT_BUTTON, OnSave, savebt)

   490

   491

    genbt = wx.Button(test_panel, label="Generate")

   492

    test_panel.Bind(wx.EVT_BUTTON, OnGenerate, genbt)

   493

   494

    testbt_sizer.Add(loadbt, 0, wx.LEFT|wx.RIGHT, 5)

   495

    testbt_sizer.Add(savebt, 0, wx.LEFT|wx.RIGHT, 5)

   496

    testbt_sizer.Add(genbt, 0, wx.LEFT|wx.RIGHT, 5)

   497

   498

    test_sizer.Add(testbt_sizer, flag=wx.GROW)

   499

    test_sizer.Layout()

   500

    test_panel.SetAutoLayout(True)

   501

    test_panel.SetSizer(test_sizer)

   502

   503

    def OnClose(evt):

   504

        mqtttestpanel.OnClose()

   505

        evt.Skip()

   506

   507

    frame.Bind(wx.EVT_CLOSE, OnClose)

   508

   509

    frame.Show()

   510

   511

    app.MainLoop()