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

   130

   131

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

   132

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

   133

General_parameters = [

   134

    #    param. name       label                        ctype type         annotate type

   135

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

   136

    #                                                                      (annotate.String,

   137

    #                                                                       annotate.Integer, ...)

   138

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

   139

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

   140

    ]                                                                      

   141

   142

TCPclient_parameters = [                                                   

   143

    #    param. name       label                        ctype type         annotate type

   144

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

   145

    #                                                                      (annotate.String,

   146

    #                                                                       annotate.Integer, ...)

   147

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

   148

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

   149

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

   150

    ]

   151

   152

RTUclient_parameters = [                                                   

   153

    #    param. name       label                        ctype type         annotate type

   154

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

   155

    #                                                                      (annotate.String,

   156

    #                                                                       annotate.Integer, ...)

   161

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

   162

    ]

   163

   164

TCPserver_parameters = [                                                   

   165

    #    param. name       label                        ctype type         annotate type

   166

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

   167

    #                                                                      (annotate.String,

   168

    #                                                                       annotate.Integer, ...)

   169

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

   170

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

   171

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

   172

    ]

   173

   174

RTUslave_parameters = [                                                   

   175

    #    param. name       label                        ctype type         annotate type

   176

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

   177

    #                                                                      (annotate.String,

   178

    #                                                                       annotate.Integer, ...)

   183

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

   184

    ]

   185

   186

   189

# Dictionary containing List of Web viewable parameters

   190

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

   191

# __modbus_get_ClientNode_addr_type()

   192

# __modbus_get_ServerNode_addr_type()

   193

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

   194

_client_WebParamListDict = {}

   195

_client_WebParamListDict["tcp"  ] = TCPclient_parameters

   196

_client_WebParamListDict["rtu"  ] = RTUclient_parameters

   197

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

   198

   199

_server_WebParamListDict = {}

   200

_server_WebParamListDict["tcp"  ] = TCPserver_parameters

   201

_server_WebParamListDict["rtu"  ] = RTUslave_parameters

   202

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

   203

   204

WebParamListDictDict = {}

   205

WebParamListDictDict['client'] = _client_WebParamListDict

   206

WebParamListDictDict['server'] = _server_WebParamListDict

   207

   208

   213

#def _CheckPortnumber(port_number):

   214

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

   215

#    try:

   216

#        portnum = int(port_number)

   217

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

   218

#           raise Exception

   219

#    except Exception:    

   220

#        return False

   221

#        

   222

#    return True

   223

   224

   225

   226

   227

#def _CheckConfiguration(BACnetConfig):

   228

#    res = True    

   229

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

   230

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

   231

#    return res

   232

   233

   234

   235

#def _CheckWebConfiguration(BACnetConfig):

   236

#    res = True

   237

#    

   238

#    # check the port number

   239

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

   240

#        raise annotate.ValidateError(

   241

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

   242

#            _("Modbus configuration error:"))

   243

#        res = False

   244

#    

   245

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

   246

#        raise annotate.ValidateError(

   247

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

   248

#            _("Modbus configuration error:"))

   249

#        res = False

   250

#        

   251

#    return res

   252

   253

   254

   255

   256

   257

   258

def _SetSavedConfiguration(WebNode_id, newConfig):

   259

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

   260

   261

    # Add the addr_type and node_type to the data that will be saved to file

   262

    # This allows us to confirm the saved data contains the correct addr_type

   263

    # when loading from file

   264

    save_info = {}

   265

    save_info["addr_type"] = _WebNodeList[WebNode_id]["addr_type"]

   266

    save_info["node_type"] = _WebNodeList[WebNode_id]["node_type"]

   267

    save_info["config"   ] = newConfig

   268

   269

    filename = _WebNodeList[WebNode_id]["filename"]

   270

   271

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

   272

        json.dump(save_info, f, sort_keys=True, indent=4)

   273

   274

    _WebNodeList[WebNode_id]["SavedConfiguration"] = newConfig

   275

   276

   277

   278

   279

def _DelSavedConfiguration(WebNode_id):

   280

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

   281

    filename = _WebNodeList[WebNode_id]["filename"]

   282

   283

    if os.path.exists(filename):

   284

        os.remove(filename)

   285

   286

   287

   288

   289

def _GetSavedConfiguration(WebNode_id):

   290

    """

   291

    Returns a dictionary containing the Modbus parameter configuration

   292

    that was last saved to file. If no file exists, or file contains 

   293

    wrong addr_type (i.e. 'tcp', 'rtu' or 'ascii' -> does not match the

   294

    addr_type of the WebNode_id), then return None

   295

    """

   296

    filename = _WebNodeList[WebNode_id]["filename"]

   297

    try:

   298

        #if os.path.isfile(filename):

   299

        save_info = json.load(open(filename))

   300

    except Exception:    

   301

        return None

   302

   303

    if save_info["addr_type"] != _WebNodeList[WebNode_id]["addr_type"]:

   304

        return None

   305

    if save_info["node_type"] != _WebNodeList[WebNode_id]["node_type"]:

   306

        return None

   307

    if "config" not in save_info:

   308

        return None

   309

   310

    saved_config = save_info["config"]

   311

   312

    #if _CheckConfiguration(saved_config):

   313

    #    return saved_config

   314

    #else:

   315

    #    return None

   316

   317

    return saved_config

   318

   319

   320

   321

def _GetPLCConfiguration(WebNode_id):

   322

    """

   323

    Returns a dictionary containing the current Modbus parameter configuration

   324

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

   325

    """

   326

    current_config = {}

   327

    C_node_id      = _WebNodeList[WebNode_id]["C_node_id"]

   328

    WebParamList   = _WebNodeList[WebNode_id]["WebParamList"]

   329

    GetParamFuncs  = _WebNodeList[WebNode_id]["GetParamFuncs"]

   330

   331

    for par_name, x1, x2, x3 in WebParamList:

   332

        value = GetParamFuncs[par_name](C_node_id)

   333

        if value is not None:

   334

            current_config[par_name] = value

   335

   336

    return current_config

   337

   338

   339

   340

def _SetPLCConfiguration(WebNode_id, newconfig):

   341

    """

   342

    Stores the Modbus parameter configuration into the

   343

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

   344

    """

   345

    C_node_id      = _WebNodeList[WebNode_id]["C_node_id"]

   346

    SetParamFuncs  = _WebNodeList[WebNode_id]["SetParamFuncs"]

   347

   348

    for par_name in newconfig:

   349

        value = newconfig[par_name]

   350

        if value is not None:

   351

            SetParamFuncs[par_name](C_node_id, value)

   352

   353

   354

   355

   356

def _GetWebviewConfigurationValue(ctx, WebNode_id, argument):

   357

    """

   358

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

   359

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

   360

   361

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

   362

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

   363

    as a parameter.

   364

    """    

   365

    try:

   366

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

   367

    except Exception:

   368

        return ""

   369

   370

   371

   372

   373

def _updateWebInterface(WebNode_id):

   374

    """

   375

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

   376

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

   377

    """

   378

   379

    config_hash = _WebNodeList[WebNode_id]["config_hash"]

   380

    config_name = _WebNodeList[WebNode_id]["config_name"]

   381

   382

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

   383

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

   384

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

   385

    else:

   386

        def __OnButtonDel(**kwargs):

   387

            return OnButtonDel(WebNode_id = WebNode_id, **kwargs)

   388

   389

        _NS.ConfigurableSettings.addSettings(

   390

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

   391

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

   392

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

   393

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

   394

            __OnButtonDel,                              # callback    

   395

            "ModbusConfigParm"          + config_hash)  # Add after entry xxxx

   396

   397

   398

   399

def OnButtonSave(**kwargs):

   400

    """

   401

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

   402

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

   403

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

   404

   405

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

   406

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

   407

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

   408

    """

   409

   410

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

   411

   412

    newConfig    = {}

   413

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

   414

    WebParamList = _WebNodeList[WebNode_id]["WebParamList"]

   415

   416

    for par_name, x1, x2, x3 in WebParamList:

   417

        value = kwargs.get(par_name, None)

   418

        if value is not None:

   419

            newConfig[par_name] = value

   420

   421

    _WebNodeList[WebNode_id]["WebviewConfiguration"] = newConfig

   422

   423

    # First check if configuration is OK.

   424

    ## TODO...

   425

    #if not _CheckWebConfiguration(newConfig):

   426

    #    return

   427

   428

    # store to file the new configuration so that 

   429

    # we can recoup the configuration the next time the PLC

   430

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

   431

    _SetSavedConfiguration(WebNode_id, newConfig)

   432

   433

    # Configure PLC with the current Modbus parameters

   434

    _SetPLCConfiguration(WebNode_id, newConfig)

   435

   436

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

   437

    _updateWebInterface(WebNode_id)

   438

   439

   440

   441

   442

def OnButtonDel(**kwargs):

   443

    """

   444

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

   445

    The function will delete the file containing the persistent

   446

    Modbus configution

   447

    """

   448

   449

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

   450

   451

    # Delete the file

   452

    _DelSavedConfiguration(WebNode_id)

   453

   454

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

   455

    new_config = _WebNodeList[WebNode_id]["DefaultConfiguration"]

   456

    _SetPLCConfiguration(WebNode_id, new_config)

   457

   458

    #Update the webviewconfiguration

   459

    _WebNodeList[WebNode_id]["WebviewConfiguration"] = new_config

   460

   461

    # Reset SavedConfiguration

   462

    _WebNodeList[WebNode_id]["SavedConfiguration"] = None

   463

   464

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

   465

    _updateWebInterface(WebNode_id)

   466

   467

   468

   469

   470

def OnButtonShowCur(**kwargs):

   471

    """

   472

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

   473

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

   474

   475

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

   476

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

   477

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

   478

    """

   479

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

   480

   481

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

   482

   483

   484

   485

   486

def _AddWebNode(C_node_id, node_type, GetParamFuncs, SetParamFuncs):

   487

    """

   488

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

   489

    the configuration parameters of a specific Modbus plugin node.

   490

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

   491

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

   492

    node versions of the Get/Set functions)

   493

    """

   494

    WebNode_entry = {}

   495

   496

    # Get the config_name from the C code...

   497

    config_name = GetParamFuncs["config_name"](C_node_id)

   498

    # Get the addr_type from the C code...

   499

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

   500

    addr_type   = GetParamFuncs["addr_type"  ](C_node_id)   

   501

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

   502

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

   503

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

   504

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

   505

   506

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

   507

   508

    # Add the new entry to the global list

   509

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