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",  "Retained", "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

    48

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

    49

    50

lstcoldsc = {

    51

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

    52

        lstcolnames  = subsublist(_lstcolnames),

    53

        lstcolwidths = subsublist(_lstcolwidths),

    54

        lstcoltypess = subsublist(_lstcoltypess),

    55

        lstcoldeflts = subsublist(_lstcoldeflts),

    56

        Location_column = 3)),

    57

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

    58

        lstcolnames  = _lstcolnames,

    59

        lstcolwidths = _lstcolwidths,

    60

        lstcoltypess = _lstcoltypess,

    61

        lstcoldeflts = _lstcoldeflts,

    62

        Location_column = 4)),

    63

}

    64

    65

directions = ["input", "output"]

    66

    67

authParams = {

    68

    "x509":[

    69

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

    70

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

    71

    "UserPassword":[

    72

        ("User", None),

    73

        ("Password", None)]}

    74

    75

class MQTTTopicListModel(dv.PyDataViewIndexListModel):

    76

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

    77

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

    78

        self.data = data

    79

        self.log = log

    80

        self.dsc = lstcoldsc[direction]

    81

    82

    def GetColumnType(self, col):

    83

        return "string"

    84

    85

    def GetValueByRow(self, row, col):

    86

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

    87

    88

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

    89

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

    90

        expectedtype = self.dsc.lstcoltypess[col]

    91

    92

        try:

    93

            v = expectedtype(value)

    94

        except ValueError: 

    95

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

    96

            return False

    97

    98

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

    99

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

   100

            return False

   101

   102

        self.data[row][col] = v

   103

        return True

   104

   105

    # Report how many columns this model provides data for.

   106

    def GetColumnCount(self):

   107

        return len(self.dsc.lstcolnames)

   108

   109

    # Report the number of rows in the model

   110

    def GetCount(self):

   111

        #self.log.write('GetCount')

   112

        return len(self.data)

   113

   114

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

   115

    # cell at (row, col)

   116

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

   117

        if col == self.dsc.Location_column:

   118

            attr.SetColour('blue')

   119

            attr.SetBold(True)

   120

            return True

   121

        return False

   122

   123

   124

    def DeleteRows(self, rows):

   125

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

   126

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

   127

        rows = sorted(rows, reverse=True)

   128

   129

        for row in rows:

   130

            # remove it from our data structure

   131

            del self.data[row]

   132

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

   133

            self.RowDeleted(row)

   134

   135

   136

    def AddRow(self, value):

   137

        if self.data.append(value):

   138

            # notify views

   139

            self.RowAppended()

   140

   141

    def InsertDefaultRow(self, row):

   142

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

   143

        # notify views

   144

        self.RowInserted(row)

   145

   146

    def ResetData(self):

   147

        self.Reset(len(self.data))

   148

   149

class MQTTTopicListPanel(wx.Panel):

   150

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

   151

        self.log = log

   152

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

   153

   154

        self.dvc = dv.DataViewCtrl(self,

   155

                                   style=wx.BORDER_THEME

   156

                                   | dv.DV_ROW_LINES

   157

                                   | dv.DV_HORIZ_RULES

   158

                                   | dv.DV_VERT_RULES

   159

                                   | dv.DV_MULTIPLE

   160

                                   )

   161

   162

        self.model = model

   163

   164

        self.dvc.AssociateModel(self.model)

   165

   166

        dsc = lstcoldsc[direction]

   167

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

   168

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

   169

   170

   171

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

   172

   173

        self.direction =  direction

   174

        titlestr = direction + " variables"

   175

   176

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

   177

   178

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

   179

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

   180

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

   181

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

   182

   183

        topsizer = wx.BoxSizer(wx.HORIZONTAL)

   184

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

   185

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

   186

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

   187

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

   188

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

   189

   190

   191

    def OnAddRow(self, evt):

   192

        items = self.dvc.GetSelections()

   193

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

   194

        self.model.InsertDefaultRow(row)

   195

   196

    def OnDeleteRows(self, evt):

   197

        items = self.dvc.GetSelections()

   198

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

   199

        self.model.DeleteRows(rows)

   200

   201

   203

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

   204

        self.log = log

   206

   207

        self.config_getter = config_getter

   208

   209

        self.selected_datas = modeldata

   210

        self.selected_models = { direction:MQTTTopicListModel(

   211

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

   212

        self.selected_lists = { direction:MQTTTopicListPanel(

   214

                self.selected_models[direction], direction) 

   215

            for direction in directions }

   216

   219

        self.SetAutoLayout(True)

   220

   221

    def OnClose(self):

   222

        pass

   223

   224

    def __del__(self):

   225

        self.OnClose()

   226

   227

    def Reset(self):

   228

        for direction in directions:

   229

            self.selected_models[direction].ResetData() 

   230

   231

   232

class MQTTClientList(list):

   233

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

   234

        super(MQTTClientList, self).__init__(self)

   235

        self.log = log

   236

        self.change_callback = change_callback

   237

        self.dsc = lstcoldsc[direction]

   238

   239

    def append(self, value):

   240

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

   241

   242

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

   243

            if len(self) == 0:

   244

                v["Location"] = 0

   245

            else:

   246

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

   247

                greatest = max(iecnums)

   248

                holes = set(range(greatest)) - iecnums

   249

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

   250

   251

        if v["QoS"] not in QoS_values:

   252

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

   253

            return False

   254

   255

        try:

   256

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

   257

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

   258

        except ValueError: 

   259

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

   260

            return False

   261

   262

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

   263

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

   264

            return False

   265

   266

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

   267

   268

        self.change_callback()

   269

   270

        return True

   271

   272

    def __delitem__(self, index):

   273

        list.__delitem__(self, index)

   274

        self.change_callback()

   275

   276

class MQTTClientModel(dict):

   277

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

   278

        super(MQTTClientModel, self).__init__()

   279

        for direction in directions:

   280

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

   281

   282

    def LoadCSV(self,path):

   283

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

   284

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

   285

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

   286

            for direction, model in self.iteritems():

   287

                self[direction][:] = []

   288

            for row in reader:

   289

                direction = row[0]

   290

                # avoids calling change callback when loading CSV

   291

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

   292

   293

    def SaveCSV(self,path):

   294

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

   295

            for direction, data in self.items():

   296

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

   297

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

   298

                for row in data:

   299

                    writer.writerow([direction] + row)

   300

   301

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

   302

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

   303

   304

#include <stdint.h>

   305

#include <pthread.h>

   306

#include <string.h>

   307

   308

#include "MQTTClient.h"

   309

#include "MQTTClientPersistence.h"

   310

   311

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

   312

    {{                                                                                            \\

   313

        char mstr[256];                                                                           \\

   314

        snprintf(mstr, 255, __VA_ARGS__);                                                         \\

   315

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

   316

        printf(__VA_ARGS__);                                                                      \\

   317

    }}

   318

   319

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

   320

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

   321

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

   322

   323

void trace_callback(enum MQTTCLIENT_TRACE_LEVELS level, char* message)

   324

{{

   325

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

   326

}}

   327

   328

#define CHANGED 1

   329

#define UNCHANGED 0

   330

   331

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

   332

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

   333

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

   334

static int MQTT_##c_loc_name##_state = UNCHANGED;  /* systematically published at init */          \\

   335

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

   336

   337

{decl}

   338

   339

static MQTTClient client;

   340

#ifdef USE_MQTT_5

   341

static MQTTClient_connectOptions conn_opts = MQTTClient_connectOptions_initializer5;

   342

#else

   343

static MQTTClient_connectOptions conn_opts = MQTTClient_connectOptions_initializer;

   344

#endif

   345

   346

/* condition to quit publish thread */

   347

static int MQTT_stop_thread = 0;

   348

   349

/* condition to wakeup publish thread */

   350

static int MQTT_any_pub_var_changed = 0;

   351

   352

/* mutex to keep PLC data consistent, and protect MQTT_any_pub_var_changed */

   353

static pthread_mutex_t MQTT_mutex;

   354

   355

/* wakeup publish thread when PLC changed published variable */

   356

static pthread_cond_t MQTT_new_data = PTHREAD_COND_INITIALIZER;

   357

   358

/* publish thread */

   359

static pthread_t publishThread;

   360

   361

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

   362

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

   363

   364

static struct {{

   365

    const char *topic; //null terminated topic string

   366

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

   367

    int *mqtt_pchanged; // pointer to changed flag

   368

    __IEC_types_enum vartype;

   369

}} topics [] = {{

   370

{topics}

   371

}};

   372

   373

static int _connect_mqtt(void)

   374

{{

   375

    int rc;

   376

   377

#ifdef USE_MQTT_5

   378

    MQTTProperties props = MQTTProperties_initializer;

   379

    MQTTProperties willProps = MQTTProperties_initializer;

   380

    MQTTResponse response = MQTTResponse_initializer;

   381

   382

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

   383

    rc = response.reasonCode;

   384

    MQTTResponse_free(response);

   385

#else

   386

    rc = MQTTClient_connect(client, &conn_opts);

   387

#endif

   388

   389

    return rc;

   390

}}

   391

   392

void __cleanup_{locstr}(void)

   393

{{

   394

    int rc;

   395

   396

    /* TODO stop publish thread */

   397

   398

#ifdef USE_MQTT_5

   399

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

   400

#else

   401

    if (rc = MQTTClient_disconnect(client, 5000) != MQTTCLIENT_SUCCESS)

   402

#endif

   403

    {{

   404

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

   405

    }}

   406

    MQTTClient_destroy(&client);

   407

}}

   408

   409

void connectionLost(void* context, char* reason)

   410

{{

   411

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

   412

    _connect_mqtt();

   413

    /* TODO wait if error */

   414

}}

   415

   416

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

   417

{{

   418

    int low = 0;

   419

    int size = sizeof(topics) / sizeof(topics[0]);

   420

    int high = size - 1;

   421

    int mid;

   422

   423

    // bisect topic among subscribed topics

   424

    while (low <= high) {{

   425

        int res;

   426

        mid = low + (high - low) / 2;

   427

        res = strncmp(topics[mid].topic, topicName, topicLen);

   428

   429

        // Check if key is present at mid

   430

        if (res == 0)

   431

            goto found;

   432

   433

        // If key greater, ignore left half

   434

        if (res < 0)

   435

            low = mid + 1;

   436

   437

        // If key is smaller, ignore right half

   438

        else

   439

            high = mid - 1;

   440

    }}

   441

    // If we reach here, then the element was not present

   442

    LogWarning("MQTT unknown topic: %s", topicName);

   443

    goto exit;

   444

   445

found:

   446

    if(__get_type_enum_size(topics[mid].vartype) == message->payloadlen){{

   447

        memcpy(topics[mid].mqtt_pdata, (char*)message->payload, message->payloadlen);

   448

        *topics[mid].mqtt_pchanged = 1;

   449

    }} else {{

   450

        LogWarning("MQTT wrong payload size for topic: %s. Should be %d, but got %d.", 

   451

            topicName, __get_type_enum_size(topics[mid].vartype), message->payloadlen);

   452

    }}

   453

exit:

   454

    MQTTClient_freeMessage(&message);

   455

    MQTTClient_free(topicName);

   456

    return 1;

   457

}}

   458

   459

#define INIT_NoAuth()                                                                             \\

   460

    LogInfo("MQTT Init no auth\\n");

   461

   462

#define INIT_x509(PrivateKey, Certificate)                                                        \\

   463

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

   464

    /* TODO */

   465

   466

#define INIT_UserPassword(User, Password)                                                         \\

   467

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

   468

    conn_opts.username = User;                                                                    \\

   469

    conn_opts.password = Password;

   470

   471

#ifdef USE_MQTT_5

   472

#define _SUBSCRIBE(Topic, QoS)                                                                    \\

   473

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

   474

        /* when using MQTT5 responce code is 1 for some reason even if no error */                \\

   475

        rc = response.reasonCode == 1 ? MQTTCLIENT_SUCCESS : response.reasonCode;                 \\

   476

        MQTTResponse_free(response);

   477

#else

   478

#define _SUBSCRIBE(Topic, QoS)                                                                    \\

   479

        rc = MQTTClient_subscribe(client, #Topic, QoS);

   480

#endif

   481

   482

#define INIT_SUBSCRIPTION(Topic, QoS)                                                             \\

   483

    {{                                                                                            \\

   484

        int rc;                                                                                   \\

   485

        _SUBSCRIBE(Topic, QoS)                                                                  \\

   486

        if (rc != MQTTCLIENT_SUCCESS)                                                             \\

   487

        {{                                                                                        \\

   488

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

   489

        }}                                                                                        \\

   490

    }}

   491

   492

   493

#ifdef USE_MQTT_5

   494

#define _PUBLISH(Topic, QoS, C_type, c_loc_name, Retained)                                        \\

   495

        MQTTResponse response = MQTTClient_publish5(client, #Topic, sizeof(C_type),               \\

   496

            &MQTT_##c_loc_name##_buf, QoS, Retained, NULL, NULL);                                  \\

   497

        rc = response.reasonCode;                                                                 \\

   498

        MQTTResponse_free(response);

   499

#else

   500

#define _PUBLISH(Topic, QoS, C_type, c_loc_name, Retained)                                        \\

   501

        rc = MQTTClient_publish(client, #Topic, sizeof(C_type),                                   \\

   502

            &PLC_##c_loc_name##_buf, QoS, Retained, NULL);

   503

#endif

   504

   505

#define INIT_PUBLICATION(Topic, QoS, C_type, c_loc_name, Retained)                                \\