1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

# This file is part of Beremiz runtime.

     5

#

     6

# Copyright (C) 2020: Mario de Sousa

     7

#

     8

# See COPYING.Runtime file for copyrights details.

     9

#

    10

# This library is free software; you can redistribute it and/or

    11

# modify it under the terms of the GNU Lesser General Public

    12

# License as published by the Free Software Foundation; either

    13

# version 2.1 of the License, or (at your option) any later version.

    14

    15

# This library is distributed in the hope that it will be useful,

    16

# but WITHOUT ANY WARRANTY; without even the implied warranty of

    17

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    18

# Lesser General Public License for more details.

    19

    20

# You should have received a copy of the GNU Lesser General Public

    21

# License along with this library; if not, write to the Free Software

    22

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

    23

    24

    25

    26

    27

##############################################################################################

    28

# This file implements an extension to the web server embedded in the Beremiz_service.py     #

    29

# runtime manager (webserver is in runtime/NevowServer.py).                                  #

    30

#                                                                                            #

    31

# The extension implemented in this file allows for runtime configuration                    #

    32

# of Modbus plugin parameters                                                                #

    33

##############################################################################################

    34

    35

    36

    37

import json

    38

import os

    39

import ctypes

    40

import string

    41

import hashlib

    42

    43

from formless import annotate, webform

    44

    45

    46

    47

# reference to the PLCObject in runtime/PLCObject.py

    48

# PLCObject is a singleton, created in runtime/__init__.py

    49

_plcobj = None

    50

    51

# reference to the Nevow web server (a.k.a as NS in Beremiz_service.py)

    52

# (Note that NS will reference the NevowServer.py _module_, and not an object/class)

    53

_NS = None

    54

    55

    56

# WorkingDir: the directory on which Beremiz_service.py is running, and where 

    57

#             all the files downloaded to the PLC get stored

    58

_WorkingDir = None

    59

    60

# Directory in which to store the persistent configurations

    61

# Should be a directory that does not get wiped on reboot!

    62

_ModbusConfFiledir = "/tmp"

    63

    64

# List of all Web Extension Setting nodes we are handling.

    65

# One WebNode each for:

    66

#   - Modbus TCP client 

    67

#   - Modbus TCP server

    68

#   - Modbus RTU client

    69

#   - Modbus RTU slave

    70

# configured in the loaded PLC (i.e. the .so file loaded into memory)

    71

# Each entry will be a dictionary. See _AddWebNode() for the details

    72

# of the data structure in each entry.

    73

_WebNodeList = []

    74

    75

    76

    77

    78

# Parameters we will need to get from the C code, but that will not be shown

    79

# on the web interface. Common to all modbus entry types (client/server, tcp/rtu/ascii)

    80

General_parameters = [

    81

    #    param. name       label                        ctype type         annotate type

    82

    # (C code var name)   (used on web interface)      (C data type)       (web data type)

    83

    #                                                                      (annotate.String,

    84

    #                                                                       annotate.Integer, ...)

    85

    ("config_name"      , _("")                      , ctypes.c_char_p,    annotate.String),

    86

    ("addr_type"        , _("")                      , ctypes.c_char_p,    annotate.String)

    87

    ]                                                                      

    88

    89

TCPclient_parameters = [                                                   

    90

    #    param. name       label                        ctype type         annotate type

    91

    # (C code var name)   (used on web interface)      (C data type)       (web data type)

    92

    #                                                                      (annotate.String,

    93

    #                                                                       annotate.Integer, ...)

    94

    ("host"             , _("Remote IP Address")     , ctypes.c_char_p,    annotate.String),

    95

    ("port"             , _("Remote Port Number")    , ctypes.c_char_p,    annotate.String),

    96

    ("comm_period"      , _("Invocation Rate (ms)")  , ctypes.c_ulonglong, annotate.Integer)

    97

    ]

    98

    99

RTUclient_parameters = [                                                   

   100

    #    param. name       label                        ctype type         annotate type

   101

    # (C code var name)   (used on web interface)      (C data type)       (web data type)

   102

    #                                                                      (annotate.String,

   103

    #                                                                       annotate.Integer, ...)

   104

    ("device"           , _("Serial Port")           , ctypes.c_char_p,    annotate.String),

   105

    ("baud"             , _("Baud Rate")             , ctypes.c_int,       annotate.Integer),

   106

    ("parity"           , _("Parity")                , ctypes.c_int,       annotate.Integer),

   107

    ("stop_bits"        , _("Stop Bits")             , ctypes.c_int,       annotate.Integer),

   108

    ("comm_period"      , _("Invocation Rate (ms)")  , ctypes.c_ulonglong, annotate.Integer)

   109

    ]

   110

   111

TCPserver_parameters = [                                                   

   112

    #    param. name       label                        ctype type         annotate type

   113

    # (C code var name)   (used on web interface)      (C data type)       (web data type)

   114

    #                                                                      (annotate.String,

   115

    #                                                                       annotate.Integer, ...)

   116

    ("host"             , _("Local IP Address")      , ctypes.c_char_p,    annotate.String),

   117

    ("port"             , _("Local Port Number")     , ctypes.c_char_p,    annotate.String),

   118

    ("slave_id"         , _("Slave ID")              , ctypes.c_ubyte,     annotate.Integer)

   119

    ]

   120

   121

RTUslave_parameters = [                                                   

   122

    #    param. name       label                        ctype type         annotate type

   123

    # (C code var name)   (used on web interface)      (C data type)       (web data type)

   124

    #                                                                      (annotate.String,

   125

    #                                                                       annotate.Integer, ...)

   126

    ("device"           , _("Serial Port")           , ctypes.c_char_p,    annotate.String),

   127

    ("baud"             , _("Baud Rate")             , ctypes.c_int,       annotate.Integer),

   128

    ("parity"           , _("Parity")                , ctypes.c_int,       annotate.Integer),

   129

    ("stop_bits"        , _("Stop Bits")             , ctypes.c_int,       annotate.Integer),

   130

    ("slave_id"         , _("Slave ID")              , ctypes.c_ulonglong, annotate.Integer)

   131

    ]

   132

   133

   134

# Dictionary containing List of Web viewable parameters

   135

# Note: the dictionary key must be the same as the string returned by the 

   136

# __modbus_get_ClientNode_addr_type()

   137

# __modbus_get_ServerNode_addr_type()

   138

# functions implemented in C (see modbus/mb_runtime.c)

   139

_client_WebParamListDict = {}

   140

_client_WebParamListDict["tcp"  ] = TCPclient_parameters

   141

_client_WebParamListDict["rtu"  ] = RTUclient_parameters

   142

_client_WebParamListDict["ascii"] = []  # (Note: ascii not yet implemented in Beremiz modbus plugin)

   143

   144

_server_WebParamListDict = {}

   145

_server_WebParamListDict["tcp"  ] = TCPserver_parameters

   146

_server_WebParamListDict["rtu"  ] = RTUslave_parameters

   147

_server_WebParamListDict["ascii"] = []  # (Note: ascii not yet implemented in Beremiz modbus plugin)

   148

   153

   154

#def _CheckPortnumber(port_number):

   155

#    """ check validity of the port number """

   156

#    try:

   157

#        portnum = int(port_number)

   158

#        if (portnum < 0) or (portnum > 65535):

   159

#           raise Exception

   160

#    except Exception:    

   161

#        return False

   162

#        

   163

#    return True

   164

   165

   166

   167

   168

#def _CheckConfiguration(BACnetConfig):

   169

#    res = True    

   170

#    res = res and _CheckPortnumber(BACnetConfig["port_number"])

   171

#    res = res and _CheckDeviceID  (BACnetConfig["device_id"])

   172

#    return res

   173

   174

   175

   176

#def _CheckWebConfiguration(BACnetConfig):

   177

#    res = True

   178

#    

   179

#    # check the port number

   180

#    if not _CheckPortnumber(BACnetConfig["port_number"]):

   181

#        raise annotate.ValidateError(

   182

#            {"port_number": "Invalid port number: " + str(BACnetConfig["port_number"])},

   183

#            _("Modbus configuration error:"))

   184

#        res = False

   185

#    

   186

#    if not _CheckDeviceID(BACnetConfig["device_id"]):

   187

#        raise annotate.ValidateError(

   188

#            {"device_id": "Invalid device ID: " + str(BACnetConfig["device_id"])},

   189

#            _("Modbus configuration error:"))

   190

#        res = False

   191

#        

   192

#    return res

   193

   194

   195

   196

   197

   198

   199

def _SetSavedConfiguration(WebNode_id, newConfig):

   200

    """ Stores a dictionary in a persistant file containing the Modbus parameter configuration """

   201

   210

    filename = _WebNodeList[WebNode_id]["filename"]

   211

   212

    with open(os.path.realpath(filename), 'w') as f:

   214

   215

    _WebNodeList[WebNode_id]["SavedConfiguration"] = newConfig

   216

   217

   218

   219

   220

def _DelSavedConfiguration(WebNode_id):

   221

    """ Deletes the file cotaining the persistent Modbus configuration """

   222

    filename = _WebNodeList[WebNode_id]["filename"]

   223

   224

    if os.path.exists(filename):

   225

        os.remove(filename)

   226

   227

   228

   229

   230

def _GetSavedConfiguration(WebNode_id):

   231

    """

   232

    Returns a dictionary containing the Modbus parameter configuration

   236

    """

   237

    filename = _WebNodeList[WebNode_id]["filename"]

   238

    try:

   239

        #if os.path.isfile(filename):

   241

    except Exception:    

   242

        return None

   243

   253

    #if _CheckConfiguration(saved_config):

   254

    #    return saved_config

   255

    #else:

   256

    #    return None

   257

   258

    return saved_config

   259

   260

   261

   262

def _GetPLCConfiguration(WebNode_id):

   263

    """

   264

    Returns a dictionary containing the current Modbus parameter configuration

   265

    stored in the C variables in the loaded PLC (.so file)

   266

    """

   267

    current_config = {}

   268

    C_node_id      = _WebNodeList[WebNode_id]["C_node_id"]

   269

    WebParamList   = _WebNodeList[WebNode_id]["WebParamList"]

   270

    GetParamFuncs  = _WebNodeList[WebNode_id]["GetParamFuncs"]

   271

   272

    for par_name, x1, x2, x3 in WebParamList:

   273

        value = GetParamFuncs[par_name](C_node_id)

   274

        if value is not None:

   275

            current_config[par_name] = value

   276

   277

    return current_config

   278

   279

   280

   281

def _SetPLCConfiguration(WebNode_id, newconfig):

   282

    """

   283

    Stores the Modbus parameter configuration into the

   284

    the C variables in the loaded PLC (.so file)

   285

    """

   286

    C_node_id      = _WebNodeList[WebNode_id]["C_node_id"]

   287

    SetParamFuncs  = _WebNodeList[WebNode_id]["SetParamFuncs"]

   288

   289

    for par_name in newconfig:

   290

        value = newconfig[par_name]

   291

        if value is not None:

   292

            SetParamFuncs[par_name](C_node_id, value)

   293

   294

   295

   296

   297

def _GetWebviewConfigurationValue(ctx, WebNode_id, argument):

   298

    """

   299

    Callback function, called by the web interface (NevowServer.py)

   300

    to fill in the default value of each parameter of the web form

   301

   302

    Note that the real callback function is a dynamically created function that

   303

    will simply call this function to do the work. It will also pass the WebNode_id 

   304

    as a parameter.

   305

    """    

   306

    try:

   307

        return _WebNodeList[WebNode_id]["WebviewConfiguration"][argument.name]

   308

    except Exception:

   309

        return ""

   310

   311

   312

   313

   314

def _updateWebInterface(WebNode_id):

   315

    """

   316

    Add/Remove buttons to/from the web interface depending on the current state

   317

       - If there is a saved state => add a delete saved state button

   318

    """

   319

   320

    config_hash = _WebNodeList[WebNode_id]["config_hash"]

   321

    config_name = _WebNodeList[WebNode_id]["config_name"]

   322

   323

    # Add a "Delete Saved Configuration" button if there is a saved configuration!

   324

    if _WebNodeList[WebNode_id]["SavedConfiguration"] is None:

   325

        _NS.ConfigurableSettings.delSettings("ModbusConfigDelSaved" + config_hash)

   326

    else:

   327

        def __OnButtonDel(**kwargs):

   328

            return OnButtonDel(WebNode_id = WebNode_id, **kwargs)

   329

   330

        _NS.ConfigurableSettings.addSettings(

   331

            "ModbusConfigDelSaved"      + config_hash,  # name (internal, may not contain spaces, ...)

   332

            _("Modbus Configuration: ") + config_name,  # description (user visible label)

   333

            [],                                         # fields  (empty, no parameters required!)

   334

            _("Delete Configuration Stored in Persistent Storage"), # button label

   335

            __OnButtonDel,                              # callback    

   336

            "ModbusConfigParm"          + config_hash)  # Add after entry xxxx

   337

   338

   339

   340

def OnButtonSave(**kwargs):

   341

    """

   342

    Function called when user clicks 'Save' button in web interface

   343

    The function will configure the Modbus plugin in the PLC with the values

   344

    specified in the web interface. However, values must be validated first!

   345

   346

    Note that this function does not get called directly. The real callback

   347

    function is the dynamic __OnButtonSave() function, which will add the 

   348

    "WebNode_id" argument, and call this function to do the work.

   349

    """

   350

   351

    #_plcobj.LogMessage("Modbus web server extension::OnButtonSave()  Called")

   352

   353

    newConfig    = {}

   354

    WebNode_id   =  kwargs.get("WebNode_id", None)

   355

    WebParamList = _WebNodeList[WebNode_id]["WebParamList"]

   356

   357

    for par_name, x1, x2, x3 in WebParamList:

   358

        value = kwargs.get(par_name, None)

   359

        if value is not None:

   360

            newConfig[par_name] = value

   361

   362

    _WebNodeList[WebNode_id]["WebviewConfiguration"] = newConfig

   363

   364

    # First check if configuration is OK.

   365

    ## TODO...

   366

    #if not _CheckWebConfiguration(newConfig):

   367

    #    return

   368

   369

    # store to file the new configuration so that 

   370

    # we can recoup the configuration the next time the PLC

   371

    # has a cold start (i.e. when Beremiz_service.py is retarted)

   372

    _SetSavedConfiguration(WebNode_id, newConfig)

   373

   374

    # Configure PLC with the current Modbus parameters

   375

    _SetPLCConfiguration(WebNode_id, newConfig)

   376

   377

    # File has just been created => Delete button must be shown on web interface!

   378

    _updateWebInterface(WebNode_id)

   379

   380

   381

   382

   383

def OnButtonDel(**kwargs):

   384

    """

   385

    Function called when user clicks 'Delete' button in web interface

   386

    The function will delete the file containing the persistent

   387

    Modbus configution

   388

    """

   389

   390

    WebNode_id = kwargs.get("WebNode_id", None)

   391

   392

    # Delete the file

   393

    _DelSavedConfiguration(WebNode_id)

   394

   395

    # Set the current configuration to the default (hardcoded in C)

   396

    new_config = _WebNodeList[WebNode_id]["DefaultConfiguration"]

   397

    _SetPLCConfiguration(WebNode_id, new_config)

   398

   399

    #Update the webviewconfiguration

   400

    _WebNodeList[WebNode_id]["WebviewConfiguration"] = new_config

   401

   402

    # Reset SavedConfiguration

   403

    _WebNodeList[WebNode_id]["SavedConfiguration"] = None

   404

   405

    # File has just been deleted => Delete button on web interface no longer needed!

   406

    _updateWebInterface(WebNode_id)

   407

   408

   409

   410

   411

def OnButtonShowCur(**kwargs):

   412

    """

   413

    Function called when user clicks 'Show Current PLC Configuration' button in web interface

   414

    The function will load the current PLC configuration into the web form

   415

   416

    Note that this function does not get called directly. The real callback

   417

    function is the dynamic __OnButtonShowCur() function, which will add the 

   418

    "WebNode_id" argument, and call this function to do the work.

   419

    """

   420

    WebNode_id = kwargs.get("WebNode_id", None)

   421

   422

    _WebNodeList[WebNode_id]["WebviewConfiguration"] = _GetPLCConfiguration(WebNode_id)

   423

   424

   425

   426

   428

    """

   429

    Load from the compiled code (.so file, aloready loaded into memmory)

   430

    the configuration parameters of a specific Modbus plugin node.

   431

    This function works with both client and server nodes, depending on the

   432

    Get/SetParamFunc dictionaries passed to it (either the client or the server

   433

    node versions of the Get/Set functions)

   434

    """

   435

    WebNode_entry = {}

   436

   438

    config_name = GetParamFuncs["config_name"](C_node_id)

   440

    # addr_type will be one of "tcp", "rtu" or "ascii"

   441

    addr_type   = GetParamFuncs["addr_type"  ](C_node_id)   

   442

    # For some operations we cannot use the config name (e.g. filename to store config)

   443

    # because the user may be using characters that are invalid for that purpose ('/' for

   444

    # example), so we create a hash of the config_name, and use that instead.

   445

    config_hash = hashlib.md5(config_name).hexdigest()

   446

   447

    #_plcobj.LogMessage("Modbus web server extension::_AddWebNode("+str(C_node_id)+") config_name="+config_name)

   448

   449

    # Add the new entry to the global list

   450

    # Note: it is OK, and actually necessary, to do this _before_ seting all the parameters in WebNode_entry

   451

    #       WebNode_entry will be stored as a reference, so we can later insert parameters at will.

   452

    global _WebNodeList

   453

    _WebNodeList.append(WebNode_entry)

   454

    WebNode_id = len(_WebNodeList) - 1

   455

   456

    # store all WebNode relevant data for future reference

   457

    #

   458

    # Note that "WebParamList" will reference one of:

   459

    #  - TCPclient_parameters, TCPserver_parameters, RTUclient_parameters, RTUslave_parameters

   460

    WebNode_entry["C_node_id"    ] = C_node_id

   461

    WebNode_entry["config_name"  ] = config_name 

   462

    WebNode_entry["config_hash"  ] = config_hash

   463

    WebNode_entry["filename"     ] = os.path.join(_ModbusConfFiledir, "Modbus_config_" + config_hash + ".json")

   464

    WebNode_entry["GetParamFuncs"] = GetParamFuncs

   465

    WebNode_entry["SetParamFuncs"] = SetParamFuncs

   470

   471

    # Dictionary that contains the Modbus configuration currently being shown

   472

    # on the web interface

   473

    # This configuration will almost always be identical to the current

   474

    # configuration in the PLC (i.e., the current state stored in the 

   475

    # C variables in the .so file).

   476

    # The configuration viewed on the web will only be different to the current 

   477

    # configuration when the user edits the configuration, and when

   478

    # the user asks to save an edited configuration that contains an error.

   479

    WebNode_entry["WebviewConfiguration"] = None

   480

   481

    # Upon PLC load, this Dictionary is initialised with the Modbus configuration

   482

    # hardcoded in the C file

   483

    # (i.e. the configuration inserted in Beremiz IDE when project was compiled)

   484

    WebNode_entry["DefaultConfiguration"] = _GetPLCConfiguration(WebNode_id)

   485

    WebNode_entry["WebviewConfiguration"] = WebNode_entry["DefaultConfiguration"]

   486

   487

    # Dictionary that stores the Modbus configuration currently stored in a file

   488

    # Currently only used to decide whether or not to show the "Delete" button on the

   489

    # web interface (only shown if "SavedConfiguration" is not None)

   490

    SavedConfig = _GetSavedConfiguration(WebNode_id)

   491

    WebNode_entry["SavedConfiguration"] = SavedConfig

   492

   493

    if SavedConfig is not None:

   494

        _SetPLCConfiguration(WebNode_id, SavedConfig)

   495

        WebNode_entry["WebviewConfiguration"] = SavedConfig

   496

   497

    # Define the format for the web form used to show/change the current parameters

   498

    # We first declare a dynamic function to work as callback to obtain the default values for each parameter

   499

    def __GetWebviewConfigurationValue(ctx, argument):

   500

        return _GetWebviewConfigurationValue(ctx, WebNode_id, argument)

   501

   502

    webFormInterface = [(name, web_dtype (label=web_label, default=__GetWebviewConfigurationValue)) 

   504

   505

    # Configure the web interface to include the Modbus config parameters

   506

    def __OnButtonSave(**kwargs):

   507

        OnButtonSave(WebNode_id=WebNode_id, **kwargs)

   508

   509

    _NS.ConfigurableSettings.addSettings(

   510

        "ModbusConfigParm"          + config_hash,     # name (internal, may not contain spaces, ...)

   511