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

from __future__ import absolute_import

    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 __del__(self):

    83

        """

    84

        Destructor

    85

        """

    86

        # Unsubscribe all data consumers

    87

        self.UnsubscribeAllDataConsumers()

    88

    89

        # Delete reference to DataProducer

    90

        self.DataProducer = None

    91

    92

        # Stop last refresh timer

    93

        if self.LastRefreshTimer is not None:

    94

            self.LastRefreshTimer.cancel()

    95

    96

        # Release Common debug lock if DebugViewer has acquired it

    97

        if self.HasAcquiredLock:

    98

            DEBUG_REFRESH_LOCK.release()

    99

   100

    def SetDataProducer(self, producer):

   101

        """

   102

        Set Data Producer

   103

        @param producer: Data Producer

   104

        """

   105

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

   106

        # debugging

   107

        if self.SubscribeTick and self.Debug:

   108

   109

            # Subscribe tick to new data producer

   110

            if producer is not None:

   111

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

   112

   113

            # Unsubscribe tick from old data producer

   114

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

   115

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

   116

   117

        # Save new data producer

   118

        self.DataProducer = producer

   119

   120

    def IsDebugging(self):

   121

        """

   122

        Get flag indicating if Debug Viewer is debugging

   123

        @return: Debugging flag

   124

        """

   125

        return self.Debug

   126

   127

    def Inhibit(self, inhibit):

   128

        """

   129

        Set consumer value update inhibit flag

   130

        @param inhibit: Inhibit flag

   131

        """

   132

        # Inhibit every data consumers in list

   133

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

   134

            consumer.Inhibit(inhibit)

   135

   136

        # Save inhibit flag

   137

        self.Inhibited = inhibit

   138

   139

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

   140

        """

   141

        Subscribe data consumer to DataProducer

   142

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

   143

        @param consumer: Data consumer to subscribe

   144

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

   145

        subscription failed)

   146

        """

   147

        # Return immediately if no DataProducer defined

   148

        if self.DataProducer is None:

   149

            return None

   150

   151

        # Subscribe data consumer to DataProducer

   152

        result = self.DataProducer.SubscribeDebugIECVariable(

   153

            iec_path, consumer, buffer_list)

   154

        if result is not None and consumer != self:

   155

   156

            # Store data consumer if successfully subscribed and inform

   157

            # consumer of variable data type

   158

            self.DataConsumers[consumer] = iec_path

   159

            consumer.SetDataType(self.GetDataType(iec_path))

   160

   161

        return result

   162

   163

    def RemoveDataConsumer(self, consumer):

   164

        """

   165

        Unsubscribe data consumer from DataProducer

   166

        @param consumer: Data consumer to unsubscribe

   167

        """

   168

        # Remove consumer from data consumer list

   169

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

   170

   171

        # Unsubscribe consumer from DataProducer

   172

        if iec_path is not None:

   173

            self.DataProducer.UnsubscribeDebugIECVariable(iec_path, consumer)

   174

   175

    def SubscribeAllDataConsumers(self):

   176

        """

   177

        Called to Subscribe all data consumers contained in DebugViewer.

   178

        May be overridden by inherited classes.

   179

        """

   180

        # Subscribe tick if needed

   181

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

   182

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

   183

   184

    def UnsubscribeAllDataConsumers(self, tick=True):

   185

        """

   186

        Called to Unsubscribe all data consumers.

   187

        """

   188

        if self.DataProducer is not None:

   189

   190

            # Unscribe tick if needed

   191

            if self.SubscribeTick and tick and self.Debug:

   192

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

   193

   194

            # Unsubscribe all data consumers in list

   195

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

   196

                self.DataProducer.UnsubscribeDebugIECVariable(iec_path, consumer)

   197

   198

        self.DataConsumers = {}

   199

   200

    def GetDataType(self, iec_path):

   201

        """

   202

        Return variable data type.

   203

        @param iec_path: Path in PLC of variable

   204

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

   205

        """

   206

        if self.DataProducer is not None:

   207

   208

            # Search for variable informations in project compilation files

   209

            data_type = self.DataProducer.GetDebugIECVariableType(

   210

                iec_path.upper())

   211

            if data_type is not None:

   212

                return data_type

   213

   214

            # Search for variable informations in project data

   215

            infos = self.DataProducer.GetInstanceInfos(iec_path)

   216

            if infos is not None:

   217

                return infos.type

   218

   219

        return None

   220

   221

    def IsNumType(self, data_type):

   222

        """

   223

        Indicate if data type given is a numeric data type

   224

        @param data_type: Data type to test

   225

        @return: True if data type given is numeric

   226

        """

   227

        if self.DataProducer is not None:

   228

            return self.DataProducer.IsNumType(data_type)

   229

   230

        return False

   231

   232

    def ForceDataValue(self, iec_path, value):

   233

        """

   234

        Force PLC variable value

   235

        @param iec_path: Path in PLC of variable to force

   236

        @param value: Value forced

   237

        """

   238

        if self.DataProducer is not None:

   239

            self.DataProducer.ForceDebugIECVariable(iec_path, value)

   240

   241

    def ReleaseDataValue(self, iec_path):

   242

        """

   243

        Release PLC variable value

   244

        @param iec_path: Path in PLC of variable to release

   245

        """

   246

        if self.DataProducer is not None:

   247

            self.DataProducer.ReleaseDebugIECVariable(iec_path)

   248

   249

    def NewDataAvailable(self, ticks):

   250

        """

   251

        Called by DataProducer for each tick captured

   252

        @param tick: PLC tick captured

   253

        All other parameters are passed to refresh function

   254

        """

   255

        # Stop last refresh timer

   256

        self.TimerAccessLock.acquire()

   257

        if self.LastRefreshTimer is not None:

   258

            self.LastRefreshTimer.cancel()

   259

            self.LastRefreshTimer = None

   260

        self.TimerAccessLock.release()

   261

   262

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

   263

        # already refreshing

   264

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

   265

   266

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

   267

            # two refresh has expired

   268

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

   269

               DEBUG_REFRESH_LOCK.acquire(False):

   270

                self.StartRefreshing()

   271

   272

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

   273

            # refresh timer

   274

            else:

   275

                self.StartLastRefreshTimer()

   276

   277

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

   278

        # acquired common refresh lock, reset DebugViewer

   279

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

   280

            DebugViewer.RefreshNewData(self)

   281

   282

    def ShouldRefresh(self):

   283

        """

   284

        Callback function called when last refresh timer expired

   285

        All parameters are passed to refresh function

   286

        """

   287

        # Cancel if DebugViewer is not visible on screen

   288

        if self and self.IsShown():

   289

   290

            # Try to acquire common refresh lock

   291

            if DEBUG_REFRESH_LOCK.acquire(False):

   292

                self.StartRefreshing()

   293

   294

            # Restart last refresh timer if common refresh lock acquired failed

   295

            else:

   296

                self.StartLastRefreshTimer()

   297

   298

    def StartRefreshing(self):

   299

        """

   300

        Called to initiate a refresh of DebugViewer

   301

        All parameters are passed to refresh function

   302

        """

   303

        # Update last refresh time stamp and flag for common refresh

   304

        # lock acquired

   305

        self.AccessLock.acquire()

   306

        self.HasAcquiredLock = True

   307

        self.LastRefreshTime = gettime()

   308

        self.AccessLock.release()

   309

   310

        # Inhibit data consumer value update

   311

        self.Inhibit(True)

   312

   313

        # Initiate DebugViewer refresh

   314

        wx.CallAfter(self.RefreshNewData)

   315

   316

    def StartLastRefreshTimer(self):

   317

        """

   318

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

   319

        refresh

   320

        All parameters are passed to refresh function

   321

        """

   322

        self.TimerAccessLock.acquire()

   323

        self.LastRefreshTimer = Timer(

   324

            REFRESH_PERIOD, self.ShouldRefresh)

   325

        self.LastRefreshTimer.start()

   326

        self.TimerAccessLock.release()

   327

   328

    def RefreshNewData(self):

   329

        """

   330

        Called to refresh DebugViewer according to values received by data

   331

        consumers

   332

        May be overridden by inherited classes

   333

        Can receive any parameters depending on what is needed by inherited

   334

        class

   335

        """

   336

        if self:

   337

            # Activate data consumer value update

   338

            self.Inhibit(False)

   339

   340

            # Release common refresh lock if acquired and update

   341

            # last refresh time

   342

            self.AccessLock.acquire()

   343

            if self.HasAcquiredLock:

   344

                DEBUG_REFRESH_LOCK.release()

   345

                self.HasAcquiredLock = False

   346

            if gettime() - self.LastRefreshTime > REFRESH_PERIOD:

   347

                self.LastRefreshTime = gettime()

   348

            self.AccessLock.release()