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

    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

   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)

   148

   149

   150

#def _CheckPortnumber(port_number):

   151

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

   152

#    try:

   153

#        portnum = int(port_number)

   154

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

   155

#           raise Exception

   156

#    except Exception:    

   157

#        return False

   158

#        

   159

#    return True

   160

   161

   162

   163

   164

#def _CheckConfiguration(BACnetConfig):

   165

#    res = True    

   166

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

   167

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

   168

#    return res

   169

   170

   171

   172

#def _CheckWebConfiguration(BACnetConfig):

   173

#    res = True

   174

#    

   175

#    # check the port number

   176

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

   177

#        raise annotate.ValidateError(

   178

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

   179

#            _("Modbus configuration error:"))

   180

#        res = False

   181

#    

   182

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

   183

#        raise annotate.ValidateError(

   184

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

   185

#            _("Modbus configuration error:"))

   186

#        res = False

   187

#        

   188

#    return res

   189

   190

   191

   192

   193

   194

   196

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

   197

   199

   200

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

   201

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

   202

   209

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

   211

   212

    if os.path.exists(filename):

   213

        os.remove(filename)

   214

   215

   216

   217

   219

    """

   220

    Returns a dictionary containing the Modbus parameter configuration

   221

    that was last saved to file. If no file exists, then return None

   222

    """

   224

    try:

   225

        #if os.path.isfile(filename):

   226

        saved_config = json.load(open(filename))

   227

    except Exception:    

   228

        return None

   229

   230

    #if _CheckConfiguration(saved_config):

   231

    #    return saved_config

   232

    #else:

   233

    #    return None

   234

   235

    return saved_config

   236

   237

   238

   240

    """

   241

    Returns a dictionary containing the current Modbus parameter configuration

   242

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

   243

    """

   244

    current_config = {}

   251

        if value is not None:

   252

            current_config[par_name] = value

   253

   254

    return current_config

   255

   256

   257

   259

    """

   260

    Stores the Modbus parameter configuration into the

   261

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

   262

    """

   266

    for par_name in newconfig:

   267

        value = newconfig[par_name]

   268

        if value is not None:

   270

   271

   272

   273

   275

    """

   276

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

   277

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

   278

   279

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

   281

    as a parameter.

   283

    try:

   285

    except Exception:

   286

        return ""

   287

   288

   289

   290

   292

    """

   293

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

   294

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

   295

    """

   296

   299

   300

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

   302

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

   303

    else:

   304

        def __OnButtonDel(**kwargs):

   306

   307

        _NS.ConfigurableSettings.addSettings(

   308

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

   309

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

   310

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

   311

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

   312

            __OnButtonDel,                              # callback    

   313

            "ModbusConfigParm"          + config_hash)  # Add after entry xxxx

   314

   315

   316

   317

def OnButtonSave(**kwargs):

   318

    """

   319

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

   320

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

   321

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

   322

   323

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

   324

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

   326

    """

   327

   328

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

   329

   335

        value = kwargs.get(par_name, None)

   336

        if value is not None:

   337

            newConfig[par_name] = value

   338

   340

   341

    # First check if configuration is OK.

   342

    ## TODO...

   343

    #if not _CheckWebConfiguration(newConfig):

   344

    #    return

   345

   346

    # store to file the new configuration so that 

   347

    # we can recoup the configuration the next time the PLC

   348

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

   350

   351

    # Configure PLC with the current Modbus parameters

   353

   354

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

   356

   357

   358

   359

   360

def OnButtonDel(**kwargs):

   361

    """

   362

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

   363

    The function will delete the file containing the persistent

   364

    Modbus configution

   365

    """

   366

   368

   369

    # Delete the file

   371

   372

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

   375

   376

    #Update the webviewconfiguration

   378

   379

    # Reset SavedConfiguration

   381

   382

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

   384

   385

   386

   387

   388

def OnButtonShowCur(**kwargs):

   389

    """

   390

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

   391

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

   392

   393

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

   394

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

   415

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

   417

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

   418

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

   419

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

   420

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

   421

   423

   424

    # Add the new entry to the global list

   442

   443

    # Dictionary that contains the Modbus configuration currently being shown

   444

    # on the web interface

   445

    # This configuration will almost always be identical to the current

   446

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

   447

    # C variables in the .so file).

   448

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

   449

    # configuration when the user edits the configuration, and when

   450

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

   452

   453

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

   454

    # hardcoded in the C file

   455

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

   458

   459

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

   460

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

   464

   465

    if SavedConfig is not None:

   468

   469

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

   470

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

   471

    def __GetWebviewConfigurationValue(ctx, argument):

   473

   474

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

   476

   477

    # Configure the web interface to include the Modbus config parameters

   478

    def __OnButtonSave(**kwargs):

   480

   481

    _NS.ConfigurableSettings.addSettings(

   482

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

   483

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

   484

        webFormInterface,                              # fields

   485

        _("Save Configuration to Persistent Storage"), # button label

   486

        __OnButtonSave)                                # callback   

   487

   488

    # Add a "View Current Configuration" button 

   489

    def __OnButtonShowCur(**kwargs):

   491

   492

    _NS.ConfigurableSettings.addSettings(

   493

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

   494

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

   495

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

   496

        _("Show Current PLC Configuration"),       # button label

   497

        __OnButtonShowCur)                         # callback    

   498

   499

    # Add the Delete button to the web interface, if required

   502

   503

   504

   505

   506

def OnLoadPLC():

   507

    """

   508

    Callback function, called (by PLCObject.py) when a new PLC program

   509

    (i.e. XXX.so file) is transfered to the PLC runtime

   510

    and loaded into memory

   511

    """

   512

   513

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