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) 2007: Edouard TISSERANT and Laurent BESSARD

     8

#

     9

# See COPYING file for copyrights details.

    10

#

    11

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

    12

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

    13

# as published by the Free Software Foundation; either version 2

    14

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

    15

#

    16

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

    17

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

    18

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    19

# GNU General Public License for more details.

    20

#

    21

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

    22

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

    23

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

    24

    25

    26

    27

from threading import Lock, Timer

    28

from time import time as gettime

    29

    30

import wx

    31

    32

REFRESH_PERIOD = 0.1         # Minimum time between 2 refresh

    33

DEBUG_REFRESH_LOCK = Lock()  # Common refresh lock for all debug viewers

    34

    35

# -------------------------------------------------------------------------------

    36

#                               Debug Viewer Class

    37

# -------------------------------------------------------------------------------

    38

    39

    40

class DebugViewer(object):

    41

    """

    42

    Class that implements common behavior of every viewers able to display debug

    43

    values

    44

    """

    45

    46

    def __init__(self, producer, debug, subscribe_tick=True):

    47

        """

    48

        Constructor

    49

        @param producer: Object receiving debug value and dispatching them to

    50

        consumers

    51

        @param debug: Flag indicating that Viewer is debugging

    52

        @param subscribe_tick: Flag indicating that viewer need tick value to

    53

        synchronize

    54

        """

    55

        self.Debug = debug

    56

        self.SubscribeTick = subscribe_tick

    57

    58

        # Flag indicating that consumer value update inhibited

    59

        # (DebugViewer is refreshing)

    60

        self.Inhibited = False

    61

    62

        # List of data consumers subscribed to DataProducer

    63

        self.DataConsumers = {}

    64

    65

        # Time stamp indicating when last refresh have been initiated

    66

        self.LastRefreshTime = gettime()

    67

        # Flag indicating that DebugViewer has acquire common debug lock

    68

        self.HasAcquiredLock = False

    69

        # Lock for access to the two preceding variable

    70

        self.AccessLock = Lock()

    71

    72

        # Timer to refresh Debug Viewer one last time in the case that a new

    73

        # value have been received during refresh was inhibited and no one

    74

        # after refresh was activated

    75

        self.LastRefreshTimer = None

    76

        # Lock for access to the timer

    77

        self.TimerAccessLock = Lock()

    78

    79

        # Set DataProducer and subscribe tick if needed

    80

        self.SetDataProducer(producer)

    81

    82

    def SetDataProducer(self, producer):

    83

        """

    84

        Set Data Producer

    85

        @param producer: Data Producer

    86

        """

    87

        # In the case that tick need to be subscribed and DebugViewer is

    88

        # debugging

    89

        if self.SubscribeTick and self.Debug:

    90

    91

            # Subscribe tick to new data producer

    92

            if producer is not None:

    93

                producer.SubscribeDebugIECVariable("__tick__", self, True)

    94

    95

            # Unsubscribe tick from old data producer

    96

            if getattr(self, "DataProducer", None) is not None:

    97

                self.DataProducer.UnsubscribeDebugIECVariable("__tick__", self)

    98

    99

        # Save new data producer

   100

        self.DataProducer = producer

   101

   102

    def IsDebugging(self):

   103

        """

   104

        Get flag indicating if Debug Viewer is debugging

   105

        @return: Debugging flag

   106

        """

   107

        return self.Debug

   108

   109

    def Inhibit(self, inhibit):

   110

        """

   111

        Set consumer value update inhibit flag

   112

        @param inhibit: Inhibit flag

   113

        """

   114

        # Inhibit every data consumers in list

   115

        for consumer, _iec_path in self.DataConsumers.items():

   116

            consumer.Inhibit(inhibit)

   117

   118

        # Save inhibit flag

   119

        self.Inhibited = inhibit

   120

   121

    def AddDataConsumer(self, iec_path, consumer, buffer_list=False):

   122

        """

   123

        Subscribe data consumer to DataProducer

   124

        @param iec_path: Path in PLC of variable needed by data consumer

   125

        @param consumer: Data consumer to subscribe

   126

        @return: List of value already received [(tick, data),...] (None if

   127

        subscription failed)

   128

        """

   129

        # Return immediately if no DataProducer defined

   130

        if self.DataProducer is None:

   131

            return None

   132

   133

        # Subscribe data consumer to DataProducer

   134

        result = self.DataProducer.SubscribeDebugIECVariable(

   135

            iec_path, consumer, buffer_list)

   136

        if result is not None and consumer != self:

   137

   138

            # Store data consumer if successfully subscribed and inform

   139

            # consumer of variable data type

   140

            self.DataConsumers[consumer] = iec_path

   141

            consumer.SetDataType(self.GetDataType(iec_path))

   142

   143

        return result

   144

   145

    def RemoveDataConsumer(self, consumer):

   146

        """

   147

        Unsubscribe data consumer from DataProducer

   148

        @param consumer: Data consumer to unsubscribe

   149

        """

   150

        # Remove consumer from data consumer list

   151

        iec_path = self.DataConsumers.pop(consumer, None)

   152

   153

        # Unsubscribe consumer from DataProducer

   154

        if iec_path is not None:

   155

            self.DataProducer.UnsubscribeDebugIECVariable(iec_path, consumer)

   156

   157

    def SubscribeAllDataConsumers(self):

   158

        """

   159

        Called to Subscribe all data consumers contained in DebugViewer.

   160

        May be overridden by inherited classes.

   161

        """

   162

        # Subscribe tick if needed

   163

        if self.SubscribeTick and self.Debug and self.DataProducer is not None:

   164

            self.DataProducer.SubscribeDebugIECVariable("__tick__", self, True)

   165

   166

    def UnsubscribeAllDataConsumers(self, tick=True):

   167

        """

   168

        Called to Unsubscribe all data consumers.

   169

        """

   170

        if self.DataProducer is not None:

   171

   172

            # Unscribe tick if needed

   173

            if self.SubscribeTick and tick and self.Debug:

   174

                self.DataProducer.UnsubscribeDebugIECVariable("__tick__", self)

   175

   176

            # Unsubscribe all data consumers in list

   177

            for consumer, iec_path in self.DataConsumers.items():

   178

                self.DataProducer.UnsubscribeDebugIECVariable(iec_path, consumer)

   179

   180

        self.DataConsumers = {}

   181

   182

    def GetDataType(self, iec_path):

   183

        """

   184

        Return variable data type.

   185

        @param iec_path: Path in PLC of variable

   186

        @return: variable data type (None if not found)

   187

        """

   188

        if self.DataProducer is not None:

   189

   190

            # Search for variable informations in project compilation files

   191

            data_type = self.DataProducer.GetDebugIECVariableType(

   192

                iec_path.upper())

   193

            if data_type is not None:

   194

                return data_type

   195

   196

            # Search for variable informations in project data

   197

            infos = self.DataProducer.GetInstanceInfos(iec_path)

   198

            if infos is not None:

   199

                return infos.type

   200

   201

        return None

   202

   203

    def IsNumType(self, data_type):

   204

        """

   205

        Indicate if data type given is a numeric data type

   206

        @param data_type: Data type to test

   207

        @return: True if data type given is numeric

   208

        """

   209

        if self.DataProducer is not None:

   210

            return self.DataProducer.IsNumType(data_type)

   211

   212

        return False

   213

   214

    def ForceDataValue(self, iec_path, value):

   215

        """

   216

        Force PLC variable value

   217

        @param iec_path: Path in PLC of variable to force

   218

        @param value: Value forced

   219

        """

   220

        if self.DataProducer is not None:

   221

            self.DataProducer.ForceDebugIECVariable(iec_path, value)

   222

   223

    def ReleaseDataValue(self, iec_path):

   224

        """

   225

        Release PLC variable value

   226

        @param iec_path: Path in PLC of variable to release

   227

        """

   228

        if self.DataProducer is not None:

   229

            self.DataProducer.ReleaseDebugIECVariable(iec_path)

   230

   231

    def NewDataAvailable(self, ticks):

   232

        """

   233

        Called by DataProducer for each tick captured

   234

        @param tick: PLC tick captured

   235

        All other parameters are passed to refresh function

   236

        """

   237

        # Stop last refresh timer

   238

        self.TimerAccessLock.acquire()

   239

        if self.LastRefreshTimer is not None:

   240

            self.LastRefreshTimer.cancel()

   241

            self.LastRefreshTimer = None

   242

        self.TimerAccessLock.release()

   243

   244

        # Only try to refresh DebugViewer if it is visible on screen and not

   245

        # already refreshing

   246

        if self.IsShown() and not self.Inhibited:

   247

   248

            # Try to get acquire common refresh lock if minimum period between

   249

            # two refresh has expired

   250

            if gettime() - self.LastRefreshTime > REFRESH_PERIOD and \

   251

               DEBUG_REFRESH_LOCK.acquire(False):

   252

                self.StartRefreshing()

   253

   254

            # If common lock wasn't acquired for any reason, restart last

   255

            # refresh timer

   256

            else:

   257

                self.StartLastRefreshTimer()

   258

   259

        # In the case that DebugViewer isn't visible on screen and has already

   260

        # acquired common refresh lock, reset DebugViewer

   261

        elif not self.IsShown() and self.HasAcquiredLock:

   262

            DebugViewer.RefreshNewData(self)

   263

   264

    def ShouldRefresh(self):

   265

        """

   266

        Callback function called when last refresh timer expired

   267

        All parameters are passed to refresh function

   268

        """

   269

        # Cancel if DebugViewer is not visible on screen

   270

        if self and self.IsShown():

   271

   272

            # Try to acquire common refresh lock

   273

            if DEBUG_REFRESH_LOCK.acquire(False):

   274

                self.StartRefreshing()

   275

   276

            # Restart last refresh timer if common refresh lock acquired failed

   277

            else:

   278

                self.StartLastRefreshTimer()

   279

   280

    def StartRefreshing(self):

   281

        """

   282

        Called to initiate a refresh of DebugViewer

   283

        All parameters are passed to refresh function

   284

        """

   285

        # Update last refresh time stamp and flag for common refresh

   286

        # lock acquired

   287

        self.AccessLock.acquire()

   288

        self.HasAcquiredLock = True

   289

        self.LastRefreshTime = gettime()

   290

        self.AccessLock.release()

   291

   292

        # Inhibit data consumer value update

   293

        self.Inhibit(True)

   294

   295

        # Initiate DebugViewer refresh

   296

        wx.CallAfter(self.RefreshNewData)

   297

   298

    def StartLastRefreshTimer(self):

   299

        """

   300

        Called to start last refresh timer for the minimum time between 2

   301

        refresh

   302

        All parameters are passed to refresh function

   303

        """

   304

        self.TimerAccessLock.acquire()

   305

        self.LastRefreshTimer = Timer(

   306

            REFRESH_PERIOD, self.ShouldRefresh)

   307

        self.LastRefreshTimer.start()

   308

        self.TimerAccessLock.release()

   309

   310

    def RefreshNewData(self):

   311

        """

   312

        Called to refresh DebugViewer according to values received by data

   313

        consumers

   314

        May be overridden by inherited classes

   315

        Can receive any parameters depending on what is needed by inherited

   316

        class

   317

        """

   318

        if self:

   319

            # Activate data consumer value update

   320

            self.Inhibit(False)

   321

   322

            # Release common refresh lock if acquired and update

   323

            # last refresh time

   324

            self.AccessLock.acquire()

   325

            if self.HasAcquiredLock:

   326

                DEBUG_REFRESH_LOCK.release()

   327

                self.HasAcquiredLock = False

   328

            if gettime() - self.LastRefreshTime > REFRESH_PERIOD:

   329

                self.LastRefreshTime = gettime()

   330

            self.AccessLock.release()