1

#!/usr/bin/env python

     2

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

     3

     4

# This file is part of Beremiz, a Integrated Development Environment for

     5

# programming IEC 61131-3 automates supporting plcopen standard and CanFestival.

     6

#

     7

# Copyright (c) 2016 Mario de Sousa (msousa@fe.up.pt)

     8

#

     9

# This program is free software: you can redistribute it and/or modify

    10

# it under the terms of the GNU General Public License as published by

    11

# the Free Software Foundation, either version 2 of the License, or

    12

# (at your option) any later version.

    13

#

    14

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

    15

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

    16

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    17

# GNU General Public License for more details.

    18

#

    19

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

    20

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

    21

#

    22

# This code is made available on the understanding that it will not be

    23

# used in safety-critical situations without a full and competent review.

    24

    25

    26

import os

    27

    28

from modbus.mb_utils import *

    29

from ConfigTreeNode import ConfigTreeNode

    30

from PLCControler import LOCATION_CONFNODE, LOCATION_VAR_MEMORY

    31

import util.paths as paths

    32

    33

ModbusPath = paths.ThirdPartyPath("Modbus")

    34

    35

    36

#

    37

#

    38

#

    39

# C L I E N T    R E Q U E S T            #

    40

#

    41

#

    42

#

    43

    44

    45

class _RequestPlug(object):

    46

    XSD = """<?xml version="1.0" encoding="ISO-8859-1" ?>

    47

    <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">

    48

      <xsd:element name="ModbusRequest">

    49

        <xsd:complexType>

    50

          <xsd:attribute name="Function" type="xsd:string" use="optional" default="01 - Read Coils"/>

    51

          <xsd:attribute name="SlaveID" use="optional" default="1">

    52

            <xsd:simpleType>

    53

                <xsd:restriction base="xsd:integer">

    54

                    <xsd:minInclusive value="0"/>

    55

                    <xsd:maxInclusive value="255"/>

    56

                </xsd:restriction>

    57

            </xsd:simpleType>

    58

          </xsd:attribute>

    59

          <xsd:attribute name="Nr_of_Channels" use="optional" default="1">

    60

            <xsd:simpleType>

    61

                <xsd:restriction base="xsd:integer">

    62

                    <xsd:minInclusive value="1"/>

    63

                    <xsd:maxInclusive value="2000"/>

    64

                </xsd:restriction>

    65

            </xsd:simpleType>

    66

          </xsd:attribute>

    67

          <xsd:attribute name="Start_Address" use="optional" default="0">

    68

            <xsd:simpleType>

    69

                <xsd:restriction base="xsd:integer">

    70

                    <xsd:minInclusive value="0"/>

    71

                    <xsd:maxInclusive value="65535"/>

    72

                </xsd:restriction>

    73

            </xsd:simpleType>

    74

          </xsd:attribute>

    75

          <xsd:attribute name="Timeout_in_ms" use="optional" default="10">

    76

            <xsd:simpleType>

    77

                <xsd:restriction base="xsd:integer">

    78

                    <xsd:minInclusive value="1"/>

    79

                    <xsd:maxInclusive value="100000"/>

    80

                </xsd:restriction>

    81

            </xsd:simpleType>

    82

          </xsd:attribute>

    83

          <xsd:attribute name="Write_on_change" type="xsd:boolean" use="optional" default="false"/>

    84

        </xsd:complexType>

    85

      </xsd:element>

    86

    </xsd:schema>

    87

    """

    88

    89

    def GetParamsAttributes(self, path=None):

    90

        infos = ConfigTreeNode.GetParamsAttributes(self, path=path)

    91

        for element in infos:

    92

            if element["name"] == "ModbusRequest":

    93

                for child in element["children"]:

    94

                    if child["name"] == "Function":

    95

                        _list = list(modbus_function_dict.keys())

    96

                        _list.sort()

    97

                        child["type"] = _list

    98

        return infos

    99

   100

    def GetVariableLocationTree(self):

   101

        current_location = self.GetCurrentLocation()

   102

        name = self.BaseParams.getName()

   103

        address = self.GetParamsAttributes()[0]["children"][3]["value"]

   104

        count = self.GetParamsAttributes()[0]["children"][2]["value"]

   105

        function = self.GetParamsAttributes()[0]["children"][0]["value"]

   106

        # 'BOOL' or 'WORD'

   107

        datatype = modbus_function_dict[function][3]

   108

        # 1 or 16

   109

        datasize = modbus_function_dict[function][4]

   110

        # 'Q' for coils and holding registers, 'I' for input discretes and input registers

   111

        # datazone = modbus_function_dict[function][5]

   112

        # 'X' for bits, 'W' for words

   113

        datatacc = modbus_function_dict[function][6]

   114

        # 'Coil', 'Holding Register', 'Input Discrete' or 'Input Register'

   115

        dataname = modbus_function_dict[function][7]

   116

        # start off with a boolean entry

   117

        # This is a flag used to allow the user program to control when to 

   118

        # execute the Modbus request.

   119

        # NOTE: If the Modbus request has a 'current_location' of

   120

        #          %QX1.2.3

   121

        #       then the execution control flag will be

   122

        #          %QX1.2.3.0.0

   123

        #       and all the Modbus registers/coils will be

   124

        #          %QX1.2.3.0

   125

        #          %QX1.2.3.1

   126

        #          %QX1.2.3.2

   127

        #            ..

   128

        #          %QX1.2.3.n

   129

        entries = []

   130

        entries.append({

   131

            "name": "Execute request flag",

   132

            "type": LOCATION_VAR_MEMORY,

   133

            "size": 1,           # BOOL flag

   134

            "IEC_type": "BOOL",  # BOOL flag

   135

            "var_name": "var_name",

   136

            "location": "X" + ".".join([str(i) for i in current_location]) + ".0.0",

   137

            "description": "Modbus request execution control flag",

   138

            "children": []})        

   139

        entries.append({

   140

            "name": "Modbus Request Status flag",

   141

            "type": LOCATION_VAR_MEMORY,

   142

            "size": 8,           # BYTE flag

   143

            "IEC_type": "BYTE",  # BYTE flag

   144

            "var_name": "var_name",

   145

            "location": "B" + ".".join([str(i) for i in current_location]) + ".0.1",

   146

            "description": "Modbus request status flag (0 -> OK, 1 -> Network error, 2 -> Received invalid frame, 3 -> Timeout, 4 -> Received error frame)",

   147

            "children": []})        

   148

        entries.append({

   149

            "name": "Modbus Error Code",

   150

            "type": LOCATION_VAR_MEMORY,

   151

            "size": 8,           # BYTE flag

   152

            "IEC_type": "BYTE",  # BYTE flag

   153

            "var_name": "var_name",

   154

            "location": "B" + ".".join([str(i) for i in current_location]) + ".0.2",

   155

            "description": "Modbus Error Code received in Modbus error frame",

   156

            "children": []})        

   157

        for offset in range(address, address + count):

   158

            entries.append({

   159

                "name": dataname + " " + str(offset),

   160

                "type": LOCATION_VAR_MEMORY,

   161

                "size": datasize,

   162

                "IEC_type": datatype,

   163

                "var_name": "MB_" + "".join([w[0] for w in dataname.split()]) + "_" + str(offset),

   164

                "location": datatacc + ".".join([str(i) for i in current_location]) + "." + str(offset),

   165

                "description": "description",

   166

                "children": []})

   167

        return {"name": name,

   168

                "type": LOCATION_CONFNODE,

   169

                "location": ".".join([str(i) for i in current_location]) + ".x",

   170

                "children": entries}

   171

   172

    def CTNGenerate_C(self, buildpath, locations):

   173

        """

   174

        Generate C code

   175

        @param current_location: Tupple containing plugin IEC location : %I0.0.4.5 => (0,0,4,5)

   176

        @param locations: List of complete variables locations \

   177

            [{"IEC_TYPE" : the IEC type (i.e. "INT", "STRING", ...)

   178

            "NAME" : name of the variable (generally "__IW0_1_2" style)

   179

            "DIR" : direction "Q","I" or "M"

   180

            "SIZE" : size "X", "B", "W", "D", "L"

   181

            "LOC" : tuple of interger for IEC location (0,1,2,...)

   182

            }, ...]

   183

        @return: [(C_file_name, CFLAGS),...] , LDFLAGS_TO_APPEND

   184

        """

   185

        return [], "", False

   186

   187

   188

   189

#

   190

#

   191

#

   192

# S E R V E R    M E M O R Y    A R E A       #

   193

#

   194

#

   195

#

   196

   197

# dictionary implementing:

   198

# key - string with the description we want in the request plugin GUI

   199

# list - (modbus function number, request type, max count value)

   200

modbus_memtype_dict = {

   201

    "01 - Coils":            ('1', 'rw_bits',  65536, "BOOL", 1, "Q", "X", "Coil"),

   202

    "02 - Input Discretes":  ('2', 'ro_bits',  65536, "BOOL", 1, "I", "X", "Input Discrete"),

   203

    "03 - Holding Registers": ('3', 'rw_words', 65536, "WORD", 16, "Q", "W", "Holding Register"),

   204

    "04 - Input Registers":  ('4', 'ro_words', 65536, "WORD", 16, "I", "W", "Input Register"),

   205

}

   206

   207

   208

class _MemoryAreaPlug(object):

   209

    XSD = """<?xml version="1.0" encoding="ISO-8859-1" ?>

   210

    <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">

   211

      <xsd:element name="MemoryArea">

   212

        <xsd:complexType>

   213

          <xsd:attribute name="MemoryAreaType" type="xsd:string" use="optional" default="01 - Coils"/>

   214

          <xsd:attribute name="Nr_of_Channels" use="optional" default="1">

   215

            <xsd:simpleType>

   216

                <xsd:restriction base="xsd:integer">

   217

                    <xsd:minInclusive value="1"/>

   218

                    <xsd:maxInclusive value="65536"/>

   219

                </xsd:restriction>

   220

            </xsd:simpleType>

   221

          </xsd:attribute>

   222

          <xsd:attribute name="Start_Address" use="optional" default="0">

   223

            <xsd:simpleType>

   224

                <xsd:restriction base="xsd:integer">

   225

                    <xsd:minInclusive value="0"/>

   226

                    <xsd:maxInclusive value="65535"/>

   227

                </xsd:restriction>

   228

            </xsd:simpleType>

   229

          </xsd:attribute>

   230

        </xsd:complexType>

   231

      </xsd:element>

   232

    </xsd:schema>

   233

    """

   234

   235

    def GetParamsAttributes(self, path=None):

   236

        infos = ConfigTreeNode.GetParamsAttributes(self, path=path)

   237

        for element in infos:

   238

            if element["name"] == "MemoryArea":

   239

                for child in element["children"]:

   240

                    if child["name"] == "MemoryAreaType":

   241

                        _list = list(modbus_memtype_dict.keys())

   242

                        _list.sort()

   243

                        child["type"] = _list

   244

        return infos

   245

   246

    def GetVariableLocationTree(self):

   247

        current_location = self.GetCurrentLocation()

   248

        name = self.BaseParams.getName()

   249

        address = self.GetParamsAttributes()[0]["children"][2]["value"]

   250

        count = self.GetParamsAttributes()[0]["children"][1]["value"]

   251

        function = self.GetParamsAttributes()[0]["children"][0]["value"]

   252

        # 'BOOL' or 'WORD'

   253

        datatype = modbus_memtype_dict[function][3]

   254

        # 1 or 16

   255

        datasize = modbus_memtype_dict[function][4]

   256

        # 'Q' for coils and holding registers, 'I' for input discretes and input registers

   257

        # datazone = modbus_memtype_dict[function][5]

   258

        # 'X' for bits, 'W' for words

   259

        datatacc = modbus_memtype_dict[function][6]

   260

        # 'Coil', 'Holding Register', 'Input Discrete' or 'Input Register'

   261

        dataname = modbus_memtype_dict[function][7]

   262

        entries = []

   263

        for offset in range(address, address + count):

   264

            entries.append({

   265

                "name": dataname + " " + str(offset),

   266

                "type": LOCATION_VAR_MEMORY,

   267

                "size": datasize,

   268

                "IEC_type": datatype,

   269

                "var_name": "MB_" + "".join([w[0] for w in dataname.split()]) + "_" + str(offset),

   270

                "location": datatacc + ".".join([str(i) for i in current_location]) + "." + str(offset),

   271

                "description": "description",

   272

                "children": []})

   273

        return {"name": name,

   274

                "type": LOCATION_CONFNODE,

   275

                "location": ".".join([str(i) for i in current_location]) + ".x",

   276

                "children": entries}

   277

   278

    def CTNGenerate_C(self, buildpath, locations):

   279

        """

   280

        Generate C code

   281

        @param current_location: Tupple containing plugin IEC location : %I0.0.4.5 => (0,0,4,5)

   282

        @param locations: List of complete variables locations \

   283

            [{"IEC_TYPE" : the IEC type (i.e. "INT", "STRING", ...)

   284

            "NAME" : name of the variable (generally "__IW0_1_2" style)

   285

            "DIR" : direction "Q","I" or "M"

   286

            "SIZE" : size "X", "B", "W", "D", "L"

   287

            "LOC" : tuple of interger for IEC location (0,1,2,...)

   288

            }, ...]

   289

        @return: [(C_file_name, CFLAGS),...] , LDFLAGS_TO_APPEND

   290

        """

   291

        return [], "", False

   292

   293

   294

#

   295

#

   296

#

   297

# T C P    C L I E N T                 #

   298

#

   299

#

   300

#

   301

   302

# XXX TODO "Configuration_Name" should disapear in favor of CTN Name, which is already unique

   303

   304

class _ModbusTCPclientPlug(object):

   305

    XSD = """<?xml version="1.0" encoding="ISO-8859-1" ?>

   306

    <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">

   307

      <xsd:element name="ModbusTCPclient">

   308

        <xsd:complexType>

   309

          <xsd:attribute name="Configuration_Name" type="xsd:string" use="optional" default=""/>

   310

          <xsd:attribute name="Remote_IP_Address" type="xsd:string" use="optional" default="localhost"/>

   311

          <xsd:attribute name="Remote_Port_Number" type="xsd:string" use="optional" default="502"/>

   312

          <xsd:attribute name="Invocation_Rate_in_ms" use="optional" default="100">

   313

            <xsd:simpleType>

   314

                <xsd:restriction base="xsd:unsignedLong">

   315

                    <xsd:minInclusive value="0"/>

   316

                    <xsd:maxInclusive value="2147483647"/>

   317

                </xsd:restriction>

   318

            </xsd:simpleType>

   319

          </xsd:attribute>

   320

          <xsd:attribute name="Request_Delay_in_ms" use="optional" default="0">

   321

            <xsd:simpleType>

   322

                <xsd:restriction base="xsd:integer">

   323

                    <xsd:minInclusive value="0"/>

   324

                    <xsd:maxInclusive value="2147483647"/>

   325

                </xsd:restriction>

   326

            </xsd:simpleType>

   327

          </xsd:attribute>

   328

        </xsd:complexType>

   329

      </xsd:element>

   330

    </xsd:schema>

   331

    """

   332

    # NOTE: Max value of 2147483647 (i32_max) for Invocation_Rate_in_ms and Request_Delay_in_ms

   333

    # corresponds to aprox 25 days.

   334

    CTNChildrenTypes = [("ModbusRequest", _RequestPlug, "Request")]

   335

    # TODO: Replace with CTNType !!!

   336

    PlugType = "ModbusTCPclient"

   337

   338

   339

    def __init__(self):

   340

        # NOTE:

   341

        # The ModbusTCPclient attribute is added dynamically by ConfigTreeNode._AddParamsMembers()

   342

        # It will be an XML parser object created by

   343

        # GenerateParserFromXSDstring(self.XSD).CreateRoot()

   344

   345

        # Set the default value for the "Configuration_Name" parameter

   346

        # The default value will need to be different for each instance of the 

   347

        # _ModbusTCPclientPlug class, so we cannot hardcode the default value in the XSD above

   348

        # This value will be used by the web interface 

   349

        #   (i.e. the extension to the web server used to configure the Modbus parameters).

   350

        #   (The web server is run/activated/started by Beremiz_service.py)

   351

        #   (The web server code is found in runtime/NevowServer.py)

   352

        #   (The Modbus extension to the web server is found in runtime/Modbus_config.py)

   353

        loc_str = ".".join(map(str, self.GetCurrentLocation()))

   354

        self.ModbusTCPclient.setConfiguration_Name("Modbus TCP Client " + loc_str)

   355

   356

    # Return the number of (modbus library) nodes this specific TCP client will need

   357

    #   return type: (tcp nodes, rtu nodes, ascii nodes)

   358

    def GetNodeCount(self):

   359

        return (1, 0, 0)

   360

   361

    def GetConfigName(self):

   362

        """ Return the node's Configuration_Name """

   363

        return self.ModbusTCPclient.getConfiguration_Name()

   364

   365

    def CTNGenerate_C(self, buildpath, locations):

   366

        """

   367

        Generate C code

   368

        @param current_location: Tupple containing plugin IEC location : %I0.0.4.5 => (0,0,4,5)

   369

        @param locations: List of complete variables locations \

   370

            [{"IEC_TYPE" : the IEC type (i.e. "INT", "STRING", ...)

   371

            "NAME" : name of the variable (generally "__IW0_1_2" style)

   372

            "DIR" : direction "Q","I" or "M"

   373

            "SIZE" : size "X", "B", "W", "D", "L"

   374

            "LOC" : tuple of interger for IEC location (0,1,2,...)

   375

            }, ...]

   376

        @return: [(C_file_name, CFLAGS),...] , LDFLAGS_TO_APPEND

   377

        """

   378

        return [], "", False

   379

   380

   381

#

   382

#

   383

#

   384

# T C P    S E R V E R                 #

   385

#

   386

#

   387

#

   388

   389

# XXX TODO "Configuration_Name" should disapear in favor of CTN Name, which is already unique

   390

   391

class _ModbusTCPserverPlug(object):

   392

    # NOTE: the Port number is a 'string' and not an 'integer'!

   393

    # This is because the underlying modbus library accepts strings

   394

    # (e.g.: well known port names!)

   395

    XSD = """<?xml version="1.0" encoding="ISO-8859-1" ?>

   396

    <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">

   397

      <xsd:element name="ModbusServerNode">

   398

        <xsd:complexType>

   399

          <xsd:attribute name="Configuration_Name" type="xsd:string" use="optional" default=""/>

   400

          <xsd:attribute name="Local_IP_Address" type="xsd:string" use="optional"  default="#ANY#"/>

   401

          <xsd:attribute name="Local_Port_Number" type="xsd:string" use="optional" default="502"/>

   402

          <xsd:attribute name="SlaveID" use="optional" default="0">

   403

            <xsd:simpleType>

   404

                <xsd:restriction base="xsd:integer">

   405

                    <xsd:minInclusive value="0"/>

   406

                    <xsd:maxInclusive value="255"/>

   407

                </xsd:restriction>

   408

            </xsd:simpleType>

   409

          </xsd:attribute>

   410

        </xsd:complexType>

   411

      </xsd:element>

   412

    </xsd:schema>

   413

    """

   414

    CTNChildrenTypes = [("MemoryArea", _MemoryAreaPlug, "Memory Area")]

   415

    # TODO: Replace with CTNType !!!

   416

    PlugType = "ModbusTCPserver"

   417

   418

    def __init__(self):

   419

        # NOTE:

   420

        # The ModbusServerNode attribute is added dynamically by ConfigTreeNode._AddParamsMembers()

   421

        # It will be an XML parser object created by

   422

        # GenerateParserFromXSDstring(self.XSD).CreateRoot()

   423

   424

        # Set the default value for the "Configuration_Name" parameter

   425

        # The default value will need to be different for each instance of the 

   426

        # _ModbusTCPclientPlug class, so we cannot hardcode the default value in the XSD above

   427

        # This value will be used by the web interface 

   428

        #   (i.e. the extension to the web server used to configure the Modbus parameters).

   429

        #   (The web server is run/activated/started by Beremiz_service.py)

   430

        #   (The web server code is found in runtime/NevowServer.py)

   431

        #   (The Modbus extension to the web server is found in runtime/Modbus_config.py)

   432

        loc_str = ".".join(map(str, self.GetCurrentLocation()))

   433

        self.ModbusServerNode.setConfiguration_Name("Modbus TCP Server " + loc_str)

   434

   435

    # Return the number of (modbus library) nodes this specific TCP server will need

   436

    #   return type: (tcp nodes, rtu nodes, ascii nodes)

   437

    def GetNodeCount(self):

   438

        return (1, 0, 0)

   439

   440

    # Return a list with a single tuple conatining the (location, IP address, port number)

   441

    #     location   : location of this node in the configuration tree

   442

    #     port number: IP port used by this Modbus/IP server

   443

    #     IP address : IP address of the network interface on which the server will be listening

   444

    #                  ("", "*", or "#ANY#" => listening on all interfaces!)

   445

    def GetIPServerPortNumbers(self):

   446

        port = self.ModbusServerNode.getLocal_Port_Number()

   447

        addr = self.ModbusServerNode.getLocal_IP_Address()

   448

        return [(self.GetCurrentLocation(), addr, port)]

   449

   450

    def GetConfigName(self):

   451

        """ Return the node's Configuration_Name """

   452

        return self.ModbusServerNode.getConfiguration_Name()

   453

   454

    def GetVariableLocationTree(self):

   455

        current_location = self.GetCurrentLocation()

   456

        name             = self.BaseParams.getName()

   457

        # start off with flags that count the number of Modbus requests/transactions

   458

        # handled by this Modbus server/slave.

   459

        # These flags are mapped onto located variables and therefore available to the user programs

   460

        # May be used to detect communication errors.

   461

        # execute the Modbus request.

   462

        # NOTE: If the Modbus slave has a 'current_location' of

   463

        #          %QX1.2

   464

        #       then the "Modbus Read Request Counter"  will be %MD1.2.0

   465

        #       then the "Modbus Write Request Counter" will be %MD1.2.1

   466

        #       then the "Modbus Read Request Flag"     will be %MD1.2.2

   467

        #       then the "Modbus Write Request Flag"    will be %MD1.2.3

   468

        #

   469

        # Note that any MemoryArea contained under this server/slave

   470

        # will ocupy the locations of type

   471

        #          %MX or %MW

   472

        # which will never clash with the %MD used here.

   473

        # Additionaly, any MemoryArea contained under this server/slave

   474

        # will ocupy locations with

   475

        #           %M1.2.a.b (with a and b being numbers in range 0, 1, ...)

   476

        # and therefore never ocupy the locations

   477

        #           %M1.2.0

   478

        #           %M1.2.1

   479

        #           %M1.2.2

   480

        #           %M1.2.3

   481

        # used by the following flags/counters.

   482

        entries = []

   483

        entries.append({

   484

            "name": "Modbus Read Request Counter",

   485

            "type": LOCATION_VAR_MEMORY,

   486

            "size": 32,           # UDINT flag

   487

            "IEC_type": "UDINT",  # UDINT flag

   488

            "var_name": "var_name",

   489

            "location": "D" + ".".join([str(i) for i in current_location]) + ".0",

   490

            "description": "Modbus read request counter",

   491

            "children": []})        

   492

        entries.append({

   493

            "name": "Modbus Write Request Counter",

   494

            "type": LOCATION_VAR_MEMORY,

   495

            "size": 32,           # UDINT flag

   496

            "IEC_type": "UDINT",  # UDINT flag

   497

            "var_name": "var_name",

   498

            "location": "D" + ".".join([str(i) for i in current_location]) + ".1",

   499

            "description": "Modbus write request counter",

   500

            "children": []})        

   501

        entries.append({

   502

            "name": "Modbus Read Request Flag",

   503

            "type": LOCATION_VAR_MEMORY,

   504

            "size": 1,            # BOOL flag