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

from threading import Lock, Timer

    26

from time import time as gettime

    27

    28

import wx

    29

    30

REFRESH_PERIOD = 0.1         # Minimum time between 2 refresh

    31

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

    32

    33

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

    34

#                               Debug Viewer Class

    35

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

    36

    37

    38

class DebugViewer(object):

    39

    """

    40

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

    41

    values

    42

    """

    43

    44

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

    45

        """

    46

        Constructor

    47

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

    48

        consumers

    49

        @param debug: Flag indicating that Viewer is debugging

    50

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

    51

        synchronize

    52

        """

    53

        self.Debug = debug

    54

        self.SubscribeTick = subscribe_tick

    55

    56

        # Flag indicating that consumer value update inhibited

    57

        # (DebugViewer is refreshing)

    58

        self.Inhibited = False

    59

    60

        # List of data consumers subscribed to DataProducer

    61

        self.DataConsumers = {}

    62

    63

        # Time stamp indicating when last refresh have been initiated

    64

        self.LastRefreshTime = gettime()

    65

        # Flag indicating that DebugViewer has acquire common debug lock

    66

        self.HasAcquiredLock = False

    67

        # Lock for access to the two preceding variable

    68

        self.AccessLock = Lock()

    69

    70

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

    71

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

    72

        # after refresh was activated

    73

        self.LastRefreshTimer = None

    74

        # Lock for access to the timer

    75

        self.TimerAccessLock = Lock()

    76

    77

        # Set DataProducer and subscribe tick if needed

    78

        self.SetDataProducer(producer)

    79

    80

    def __del__(self):

    81

        """

    82

        Destructor

    83

        """

    84

        # Unsubscribe all data consumers

    85

        self.UnsubscribeAllDataConsumers()

    86

    87

        # Delete reference to DataProducer

    88

        self.DataProducer = None

    89

    90

        # Stop last refresh timer

    91

        if self.LastRefreshTimer is not None:

    92

            self.LastRefreshTimer.cancel()

    93

    94

        # Release Common debug lock if DebugViewer has acquired it

    95

        if self.HasAcquiredLock:

    96

            DEBUG_REFRESH_LOCK.release()

    97

    98

    def SetDataProducer(self, producer):

    99

        """

   100

        Set Data Producer

   101

        @param producer: Data Producer

   102

        """

   103

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

   104

        # debugging

   105

        if self.SubscribeTick and self.Debug:

   106

   107

            # Subscribe tick to new data producer

   108

            if producer is not None:

   109

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

   110

   111

            # Unsubscribe tick from old data producer

   112

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

   113

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

   114

   115

        # Save new data producer

   116

        self.DataProducer = producer

   117

   118

    def IsDebugging(self):

   119

        """

   120

        Get flag indicating if Debug Viewer is debugging

   121

        @return: Debugging flag

   122

        """

   123

        return self.Debug

   124

   125

    def Inhibit(self, inhibit):

   126

        """

   127

        Set consumer value update inhibit flag

   128

        @param inhibit: Inhibit flag

   129

        """

   130

        # Inhibit every data consumers in list

   131

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

   132

            consumer.Inhibit(inhibit)

   133

   134

        # Save inhibit flag

   135

        self.Inhibited = inhibit

   136

   137

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

   138

        """

   139

        Subscribe data consumer to DataProducer

   140

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

   141

        @param consumer: Data consumer to subscribe

   142

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

   143

        subscription failed)

   144

        """

   145

        # Return immediately if no DataProducer defined

   146

        if self.DataProducer is None:

   147

            return None

   148

   149

        # Subscribe data consumer to DataProducer

   150

        result = self.DataProducer.SubscribeDebugIECVariable(

   152

        if result is not None and consumer != self:

   153

   154

            # Store data consumer if successfully subscribed and inform

   155

            # consumer of variable data type

   156

            self.DataConsumers[consumer] = iec_path

   157

            consumer.SetDataType(self.GetDataType(iec_path))

   158

   159

        return result

   160

   161

    def RemoveDataConsumer(self, consumer):

   162

        """

   163

        Unsubscribe data consumer from DataProducer

   164

        @param consumer: Data consumer to unsubscribe

   165

        """

   166

        # Remove consumer from data consumer list

   167

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

   168

   169

        # Unsubscribe consumer from DataProducer

   170

        if iec_path is not None:

   172

   173

    def SubscribeAllDataConsumers(self):

   174

        """

   175

        Called to Subscribe all data consumers contained in DebugViewer.

   176

        May be overridden by inherited classes.

   177

        """

   178

        # Subscribe tick if needed

   179

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

   180

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

   181

   182

    def UnsubscribeAllDataConsumers(self, tick=True):

   183

        """

   184

        Called to Unsubscribe all data consumers.

   185

        """

   186

        if self.DataProducer is not None:

   187

   188

            # Unscribe tick if needed

   189

            if self.SubscribeTick and tick and self.Debug:

   190

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

   191

   192

            # Unsubscribe all data consumers in list

   193

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

   195

   196

        self.DataConsumers = {}

   197

   198

    def GetDataType(self, iec_path):

   199

        """

   200

        Return variable data type.

   201

        @param iec_path: Path in PLC of variable

   202

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

   203

        """

   204

        if self.DataProducer is not None:

   205

   206

            # Search for variable informations in project compilation files

   207

            data_type = self.DataProducer.GetDebugIECVariableType(

   209

            if data_type is not None:

   210

                return data_type

   211

   212

            # Search for variable informations in project data

   213

            infos = self.DataProducer.GetInstanceInfos(iec_path)

   214

            if infos is not None:

   215

                return infos.type

   216

   217

        return None

   218

   219

    def IsNumType(self, data_type):

   220

        """

   221

        Indicate if data type given is a numeric data type

   222

        @param data_type: Data type to test

   223

        @return: True if data type given is numeric

   224

        """

   225

        if self.DataProducer is not None:

   226

            return self.DataProducer.IsNumType(data_type)

   227

   228

        return False

   229

   230

    def ForceDataValue(self, iec_path, value):

   231

        """

   232

        Force PLC variable value

   233

        @param iec_path: Path in PLC of variable to force

   234

        @param value: Value forced

   235

        """

   236

        if self.DataProducer is not None:

   237

            self.DataProducer.ForceDebugIECVariable(iec_path, value)

   238

   239

    def ReleaseDataValue(self, iec_path):

   240

        """

   241

        Release PLC variable value

   242

        @param iec_path: Path in PLC of variable to release

   243

        """

   244

        if self.DataProducer is not None:

   245

            self.DataProducer.ReleaseDebugIECVariable(iec_path)

   246

   247

    def NewDataAvailable(self, ticks):

   248

        """

   249

        Called by DataProducer for each tick captured

   250

        @param tick: PLC tick captured

   251

        All other parameters are passed to refresh function

   252

        """

   253

        # Stop last refresh timer

   254

        self.TimerAccessLock.acquire()

   255

        if self.LastRefreshTimer is not None:

   256

            self.LastRefreshTimer.cancel()

   257

            self.LastRefreshTimer = None

   258

        self.TimerAccessLock.release()

   259

   260

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

   261

        # already refreshing

   262

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

   263

   264

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

   265

            # two refresh has expired

   266

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

   267

               DEBUG_REFRESH_LOCK.acquire(False):

   268

                self.StartRefreshing()

   269

   270

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

   271

            # refresh timer

   272

            else:

   273

                self.StartLastRefreshTimer()

   274

   275

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

   276

        # acquired common refresh lock, reset DebugViewer

   277

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

   278

            DebugViewer.RefreshNewData(self)

   279

   280

    def ShouldRefresh(self):

   281

        """

   282

        Callback function called when last refresh timer expired

   283

        All parameters are passed to refresh function

   284

        """

   285

        # Cancel if DebugViewer is not visible on screen

   286

        if self and self.IsShown():

   287

   288

            # Try to acquire common refresh lock

   289

            if DEBUG_REFRESH_LOCK.acquire(False):

   290

                self.StartRefreshing()

   291

   292

            # Restart last refresh timer if common refresh lock acquired failed

   293

            else:

   294

                self.StartLastRefreshTimer()

   295

   296

    def StartRefreshing(self):

   297

        """

   298

        Called to initiate a refresh of DebugViewer

   299

        All parameters are passed to refresh function

   300

        """

   301

        # Update last refresh time stamp and flag for common refresh

   302

        # lock acquired

   303

        self.AccessLock.acquire()

   304

        self.HasAcquiredLock = True

   305

        self.LastRefreshTime = gettime()

   306

        self.AccessLock.release()

   307

   308

        # Inhibit data consumer value update

   309

        self.Inhibit(True)

   310

   311

        # Initiate DebugViewer refresh

   312

        wx.CallAfter(self.RefreshNewData)

   313

   314

    def StartLastRefreshTimer(self):

   315

        """

   316

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

   317

        refresh

   318

        All parameters are passed to refresh function

   319

        """

   320

        self.TimerAccessLock.acquire()

   321

        self.LastRefreshTimer = Timer(

   322

            REFRESH_PERIOD, self.ShouldRefresh)

   323

        self.LastRefreshTimer.start()

   324

        self.TimerAccessLock.release()

   325

   326

    def RefreshNewData(self):

   327

        """

   328

        Called to refresh DebugViewer according to values received by data

   329

        consumers

   330

        May be overridden by inherited classes

   331

        Can receive any parameters depending on what is needed by inherited

   332

        class

   333

        """

   334

        if self:

   335

            # Activate data consumer value update

   336

            self.Inhibit(False)

   337

   338

            # Release common refresh lock if acquired and update

   339

            # last refresh time

   340

            self.AccessLock.acquire()

   341

            if self.HasAcquiredLock:

   342

                DEBUG_REFRESH_LOCK.release()

   343

                self.HasAcquiredLock = False

   344

            if gettime() - self.LastRefreshTime > REFRESH_PERIOD:

   345

                self.LastRefreshTime = gettime()

   346

            self.AccessLock.release()