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

# from perfect_hash import generate_code, IntSaltHash

    13

    14

MQTT_IEC_types = dict(

    15

# IEC61131|  C  type   | sz

    16

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

    17

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

    18

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

    19

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

    20

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

    21

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

    22

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

    23

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

    24

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

    25

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

    26

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

    27

)

    28

    29

"""

    30

 QoS - Quality of Service

    31

  0  : "At most one delivery"

    32

  1  : "At least one delivery"

    33

  2  : "Exactly one delivery"

    34

"""

    35

QoS_values = [0, 1, 2]

    36

    37

def boolean(v):

    38

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

    39

        return False

    40

    else:

    41

        return bool(v)

    42

    43

lstcolnames  = [ "Topic",  "QoS",  "Retain", "Type", "Location"]

    44

lstcolwidths = [     100,     50,       100,    100,         50]

    45

lstcoltypess = [     str,    int,   boolean,    str,        int]

    46

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

    47

Location_column = lstcolnames.index("Location")

    48

    49

directions = ["input", "output"]

    50

    51

authParams = {

    52

    "x509":[

    53

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

    54

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

    55

    "UserPassword":[

    56

        ("User", None),

    57

        ("Password", None)]}

    58

    59

class MQTTTopicListModel(dv.PyDataViewIndexListModel):

    60

    def __init__(self, data, log):

    61

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

    62

        self.data = data

    63

        self.log = log

    64

    65

    def GetColumnType(self, col):

    66

        return "string"

    67

    68

    def GetValueByRow(self, row, col):

    69

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

    70

    71

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

    72

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

    73

        expectedtype = lstcoltypess[col]

    74

    75

        try:

    76

            v = expectedtype(value)

    77

        except ValueError: 

    78

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

    79

            return False

    80

    81

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

    82

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

    83

            return False

    84

    85

        self.data[row][col] = v

    86

        return True

    87

    88

    # Report how many columns this model provides data for.

    89

    def GetColumnCount(self):

    90

        return len(lstcolnames)

    91

    92

    # Report the number of rows in the model

    93

    def GetCount(self):

    94

        #self.log.write('GetCount')

    95

        return len(self.data)

    96

    97

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

    98

    # cell at (row, col)

    99

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

   100

        if col == Location_column:

   101

            attr.SetColour('blue')

   102

            attr.SetBold(True)

   103

            return True

   104

        return False

   105

   106

   107

    def DeleteRows(self, rows):

   108

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

   109

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

   110

        rows = sorted(rows, reverse=True)

   111

   112

        for row in rows:

   113

            # remove it from our data structure

   114

            del self.data[row]

   115

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

   116

            self.RowDeleted(row)

   117

   118

   119

    def AddRow(self, value):

   120

        if self.data.append(value):

   121

            # notify views

   122

            self.RowAppended()

   123

   124

    def InsertDefaultRow(self, row):

   125

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

   126

        # notify views

   127

        self.RowInserted(row)

   128

   129

    def ResetData(self):

   130

        self.Reset(len(self.data))

   131

   132

class MQTTTopicListPanel(wx.Panel):

   133

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

   134

        self.log = log

   135

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

   136

   137

        self.dvc = dv.DataViewCtrl(self,

   138

                                   style=wx.BORDER_THEME

   139

                                   | dv.DV_ROW_LINES

   140

                                   | dv.DV_HORIZ_RULES

   141

                                   | dv.DV_VERT_RULES

   142

                                   | dv.DV_MULTIPLE

   143

                                   )

   144

   145

        self.model = model

   146

   147

        self.dvc.AssociateModel(self.model)

   148

   149

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

   150

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

   151

   152

   153

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

   154

   155

        self.direction =  direction

   156

        titlestr = direction + " variables"

   157

   158

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

   159

   160

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

   161

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

   162

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

   163

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

   164

   165

        topsizer = wx.BoxSizer(wx.HORIZONTAL)

   166

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

   167

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

   168

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

   169

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

   170

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

   171

   172

   173

    def OnAddRow(self, evt):

   174

        items = self.dvc.GetSelections()

   175

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

   176

        self.model.InsertDefaultRow(row)

   177

   178

    def OnDeleteRows(self, evt):

   179

        items = self.dvc.GetSelections()

   180

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

   181

        self.model.DeleteRows(rows)

   182

   183

   184

class MQTTClientPanel(wx.Panel):

   185

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

   186

        self.log = log

   187

        wx.Panel.__init__(self, parent)

   188

   189

        # TODO replace FlexGridSizer with a simpler one

   190

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

   191

        self.inout_sizer.AddGrowableCol(0)

   192

        self.inout_sizer.AddGrowableRow(0)

   193

   194

        self.config_getter = config_getter

   195

   196

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

   197

   198

        self.selected_datas = modeldata

   199

        self.selected_models = { direction:MQTTTopicListModel(self.selected_datas[direction], log) for direction in directions }

   200

        self.selected_lists = { direction:MQTTTopicListPanel(

   201

                self.selected_splitter, log, 

   202

                self.selected_models[direction], direction) 

   203

            for direction in directions }

   204

   205

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

   206

   207

        self.inout_sizer.Add(self.selected_splitter, flag=wx.GROW)

   208

        self.inout_sizer.Layout()

   209

        self.SetAutoLayout(True)

   210

        self.SetSizer(self.inout_sizer)

   211

   212

    def OnClose(self):

   213

        pass

   214

   215

    def __del__(self):

   216

        self.OnClose()

   217

   218

    def Reset(self):

   219

        for direction in directions:

   220

            self.selected_models[direction].ResetData() 

   221

   222

   223

class MQTTClientList(list):

   224

    def __init__(self, log, change_callback):

   225

        super(MQTTClientList, self).__init__(self)

   226

        self.log = log

   227

        self.change_callback = change_callback

   228

   229

    def append(self, value):

   230

        v = dict(list(zip(lstcolnames, value)))

   231

   232

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

   233

            if len(self) == 0:

   234

                v["Location"] = 0

   235

            else:

   236

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

   237

                greatest = max(iecnums)

   238

                holes = set(range(greatest)) - iecnums

   239

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

   240

   241

        if v["QoS"] not in QoS_values:

   242

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

   243

            return False

   244

   245

        try:

   246

            for t,n in zip(lstcoltypess, lstcolnames):

   247

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

   248

        except ValueError: 

   249

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

   250

            return False

   251

   252

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

   253

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

   254

            return False

   255

   256

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

   257

   258

        self.change_callback()

   259

   260

        return True

   261

   262

    def __delitem__(self, index):

   263

        list.__delitem__(self, index)

   264

        self.change_callback()

   265

   266

class MQTTClientModel(dict):

   267

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

   268

        super(MQTTClientModel, self).__init__()

   269

        for direction in directions:

   270

            self[direction] = MQTTClientList(log, change_callback)

   271

   272

    def LoadCSV(self,path):

   273

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

   274

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

   275

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

   276

            for direction, model in self.iteritems():

   277

                self[direction][:] = []

   278

            for row in reader:

   279

                direction = row[0]

   280

                # avoids calling change callback when loading CSV

   281

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

   282

   283

    def SaveCSV(self,path):

   284

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

   285

            for direction, data in self.items():

   286

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

   287

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

   288

                for row in data:

   289

                    writer.writerow([direction] + row)

   290

   291

    def _TopicsPerfectHash(self, topics):

   292

        template = """

   293

#define NK  $NK       /* number of keys */

   294

#define NG  $NG       /* number of vertices */

   295

#define NS  $NS       /* length of array T1 and T2 */

   296

   297

int S1[] = {$S1};

   298

int S2[] = {$S2};

   299

int G[] = {$G};

   300

char *K[] = {$K};

   301

"""

   302

        code = generate_code(topics, Hash=IntSaltHash, template=template)

   303

        code += """

   304

/* return index of key in K if key is found, -1 otherwise */

   305

int MQTT_Topic_index(const char *key)

   306

{

   307

    int i, f1 = 0, f2 = 0;

   308

   309

    for (i = 0; key[i] != '\\0' && i < NS; i++) {

   310

        f1 += S1[i] * key[i];

   311

        f2 += S2[i] * key[i];

   312

        f1 %= NG;

   313

        f2 %= NG;

   314

    }

   315

    i = (G[f1] + G[f2]) % NG;

   316

    if (i < NK && strcmp(key, K[i]) == 0)

   317

        return i;

   318

   319

    return -1;

   320

}

   321

""" 

   322

        return code

   323

   324

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

   325

        template = """/* code generated by beremiz MQTT extension */

   326

   327

#include <stdint.h>

   328

#include <pthread.h>

   329

   330

#include "MQTTClient.h"

   331

#include "MQTTClientPersistence.h"

   332

   333

#define _Log(level, ...)                                                                           \\

   334

    {{                                                                                             \\

   335

        /* char mstr[256];                          */                                            \\

   336

        /* snprintf(mstr, 255, __VA_ARGS__);        */                                            \\

   337

        /* LogMessage(level, mstr, strlen(mstr));   */                                            \\

   338

        printf(__VA_ARGS__);                                                          \\

   339

    }}

   340

   341

#define LogInfo(...) _Log(LOG_INFO, __VA_ARGS__);

   342

#define LogError(...) _Log(LOG_CRITICAL, __VA_ARGS__);

   343

#define LogWarning(...) _Log(LOG_WARNING, __VA_ARGS__);

   344

   345

static MQTTClient client;

   346

static MQTTClient_connectOptions conn_opts = MQTTClient_connectOptions_initializer5;

   347

static pthread_mutex_t clientMutex;  // mutex to keep PLC data consistent

   348

   349

void trace_callback(enum MQTTCLIENT_TRACE_LEVELS level, char* message)

   350

{{

   351

    LogWarning("Paho MQTT Trace : %d, %s\\n", level, message);

   352

}}

   353

   354

#define DECL_VAR(iec_type, C_type, c_loc_name)                                                     \\

   355

static C_type PLC_##c_loc_name##_buf = 0;                                                          \\

   356

static C_type MQTT_##c_loc_name##_buf = 0;                                                         \\

   357

C_type *c_loc_name = &PLC_##c_loc_name##_buf;

   358

   359

{decl}

   360

   361

#define INIT_TOPIC(topic, iec_type, c_loc_name)                                            \\

   362

{{#topic, &MQTT_##c_loc_name##_buf, iec_type##_ENUM}},

   363

   364

static struct {{

   365

    const char *topic; //null terminated topic string

   366

    void *mqtt_pdata; //data from/for MQTT stack

   367

    __IEC_types_enum vartype;

   368

}} topics [] = {{

   369

{topics}

   370

}};

   371

   372

static int _connect_mqtt(void)

   373

{{

   374

    int rc;

   375

    MQTTProperties props = MQTTProperties_initializer;

   376

    MQTTProperties willProps = MQTTProperties_initializer;

   377

    MQTTResponse response = MQTTResponse_initializer;

   378

   379

    response = MQTTClient_connect5(client, &conn_opts, &props, &willProps);

   380

    rc = response.reasonCode;

   381

    MQTTResponse_free(response);

   382

   383

	return rc;

   384

}}

   385

   386

void __cleanup_{locstr}(void)

   387

{{

   388

    int rc;

   389

   390

    /* TODO stop publish thread */

   391

   392

    if (rc = MQTTClient_disconnect5(client, 5000, MQTTREASONCODE_SUCCESS, NULL) != MQTTCLIENT_SUCCESS)

   393

    {{

   394

        LogError("MQTT Failed to disconnect, return code %d\\n", rc);

   395

    }}

   396

    MQTTClient_destroy(&client);

   397

}}

   398

   399

void connectionLost(void* context, char* reason)

   400

{{

   401

    LogWarning("ConnectionLost, reconnecting\\n");

   402

	_connect_mqtt();

   403

    /* TODO wait if error */

   404

}}

   405

   406

int messageArrived(void *context, char *topicName, int topicLen, MQTTClient_message *message)

   407

{{

   408

    /* TODO : something with message */

   409

    printf("Message arrived\\n");

   410

    printf("     topic: %s\\n", topicName);

   411

    printf("   message: %.*s\\n", message->payloadlen, (char*)message->payload);

   412

    MQTTClient_freeMessage(&message);

   413

    MQTTClient_free(topicName);

   414

    return 1;

   415

}}

   416

   417

#define INIT_NoAuth()                                                                             \\

   418

    LogInfo("MQTT Init no auth");

   419

   420

#define INIT_x509(PrivateKey, Certificate)                                                        \\

   421

    LogInfo("MQTT Init x509 %s,%s", PrivateKey, Certificate);

   422

    /* TODO */

   423

   424

#define INIT_UserPassword(User, Password)                                                         \\

   425

    LogInfo("MQTT Init UserPassword %s,%s", User, Password);                                      \\

   426

	conn_opts.username = User;                                                                    \\

   427

	conn_opts.password = Password;

   428

   429

#define INIT_SUBSCRIPTION(Topic, QoS)                                                             \\

   430

    {{                                                                                            \\

   431

        MQTTResponse response = MQTTClient_subscribe5(client, #Topic, QoS, NULL, NULL);            \\

   432

        rc = response.reasonCode;                                                                 \\

   433

        MQTTResponse_free(response);                                                              \\

   434

        if (rc != MQTTCLIENT_SUCCESS)                                                             \\

   435

        {{                                                                                        \\

   436

            LogError("MQTT client failed to subscribe to '%s', return code %d\\n", #Topic, rc);\\

   437

        }}                                                                                        \\

   438

    }}

   439

   440

int __init_{locstr}(int argc,char **argv)

   441

{{

   442

    char *uri = "{uri}";

   443

    char *clientID = "{clientID}";

   444

    int rc;

   445

   446

	MQTTClient_createOptions createOpts = MQTTClient_createOptions_initializer;

   447

   448

	conn_opts.MQTTVersion = MQTTVERSION_5;

   449

    conn_opts.cleanstart = 1;

   450

   451

    createOpts.MQTTVersion = MQTTVERSION_5;

   452

   453

    MQTTClient_setTraceCallback(trace_callback);

   454

    MQTTClient_setTraceLevel(MQTTCLIENT_TRACE_ERROR);

   455

   456

   457

	rc = MQTTClient_createWithOptions(

   458

        &client, uri, clientID, MQTTCLIENT_PERSISTENCE_NONE, NULL, &createOpts);

   459

	if (rc != MQTTCLIENT_SUCCESS)

   460

	{{

   461

        LogError("MQTT Failed to create client, return code %d\\n", rc);

   462

        return rc;

   463

    }}

   464

   465

	rc = MQTTClient_setCallbacks(client, NULL, connectionLost, messageArrived, NULL);

   466

	if (rc != MQTTCLIENT_SUCCESS)

   467

	{{

   468

        LogError("MQTT Failed to set callbacks %d", rc);

   469

        return rc;

   470

	}}

   471

   472

{init}

   473

   474

	rc = _connect_mqtt();

   475

   476

	if (rc != MQTTCLIENT_SUCCESS) {{

   477

        LogError("MQTT Init Failed %d", rc);

   478

        return rc;

   479

    }}

   480

    /* TODO start publish thread */

   481

   482

    return 0;

   483

}}

   484

   485

#define READ_VALUE(c_loc_name, C_type) \\

   486

    PLC_##c_loc_name##_buf = MQTT_##c_loc_name##_buf;

   487

   488

void __retrieve_{locstr}(void)

   489

{{

   490

    /* TODO try take mutex */

   491

{retrieve}

   492

    /* TODO free mutex */

   493

}}

   494

   495

#define WRITE_VALUE(c_loc_name, C_type) \\

   496

    MQTT_##c_loc_name##_buf = PLC_##c_loc_name##_buf;

   497

   498

void __publish_{locstr}(void)

   499

{{

   500

    /* TODO try take mutex */

   501

{publish}

   502

    /* TODO free mutex */

   503

    /* TODO unblock publish thread */

   504

}}

   505

   506

"""

   507

   508

        formatdict = dict(

   509

            locstr   = locstr,

   510

            uri      = config["URI"],

   511

            clientID = config["clientID"],

   512

            decl     = "",

   513

            topics   = "",