1

#!/usr/bin/env python

     2

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

     3

     4

# This file is part of Beremiz

     5

#

     6

# Copyright (C) 2011-2014: Laurent BESSARD, Edouard TISSERANT

     7

#                          RTES Lab : CRKim, JBLee, youcu

     8

#                          Higen Motor : Donggu Kang

     9

#

    10

# See COPYING file for copyrights details.

    11

    13

from ConfigTreeNode import ConfigTreeNode

    14

    15

from ConfigEditor import NodeEditor

    16

    17

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

    18

from CommonEtherCATFunction import _CommonSlave

    19

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

    20

    21

    22

TYPECONVERSION = {"BOOL": "X", "SINT": "B", "INT": "W", "DINT": "D", "LINT": "L",

    23

                  "USINT": "B", "UINT": "W", "UDINT": "D", "ULINT": "L",

    24

                  "BYTE": "B", "WORD": "W", "DWORD": "D", "LWORD": "L"}

    25

    26

DATATYPECONVERSION = {"BOOL": "BIT", "SINT": "S8", "INT": "S16", "DINT": "S32", "LINT": "S64",

    27

                      "USINT": "U8", "UINT": "U16", "UDINT": "U32", "ULINT": "U64",

    28

                      "BYTE": "U8", "WORD": "U16", "DWORD": "U32", "LWORD": "U64"}

    29

    30

VARCLASSCONVERSION = {"T": LOCATION_VAR_INPUT, "R": LOCATION_VAR_OUTPUT, "RT": LOCATION_VAR_MEMORY}

    31

    32

    33

def ExtractHexDecValue(value):

    34

    try:

    35

        return int(value)

    36

    except Exception:

    37

        pass

    38

    try:

    39

        return int(value.replace("#", "0"), 16)

    40

    except Exception:

    41

        raise ValueError("Invalid value for HexDecValue \"%s\"" % value)

    42

    43

    44

def GenerateHexDecValue(value, base=10):

    45

    if base == 10:

    46

        return str(value)

    47

    elif base == 16:

    48

        return "#x%.8x" % value

    49

    else:

    50

        raise ValueError("Not supported base")

    51

    52

    53

def ExtractName(names, default=None):

    54

    if len(names) == 1:

    55

        return names[0].getcontent()

    56

    else:

    57

        for name in names:

    58

            if name.getLcId() == 1033:

    59

                return name.getcontent()

    60

    return default

    61

    62

    63

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

    64

#                    Ethercat Node

    65

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

    66

    67

class _EthercatSlaveCTN:

    68

    NODE_PROFILE = None

    69

    EditorType = NodeEditor

    70

    71

    def __init__(self):

    72

        # ----------- call ethercat mng. function --------------

    73

        self.CommonMethod = _CommonSlave(self)

    74

    75

    def GetIconName(self):

    76

        return "Slave"

    77

    78

    def ExtractHexDecValue(self, value):

    79

        return ExtractHexDecValue(value)

    80

    81

    def GetSizeOfType(self, type):

    82

        return TYPECONVERSION.get(self.GetCTRoot().GetBaseType(type), None)

    83

    84

    def GetSlavePos(self):

    85

        return self.BaseParams.getIEC_Channel()

    86

    87

    def GetParamsAttributes(self, path=None):

    88

        if path:

    89

            parts = path.split(".", 1)

    90

            if self.MandatoryParams and parts[0] == self.MandatoryParams[0]:

    91

                return self.MandatoryParams[1].getElementInfos(parts[0], parts[1])

    92

            elif self.CTNParams and parts[0] == self.CTNParams[0]:

    93

                return self.CTNParams[1].getElementInfos(parts[0], parts[1])

    94

        else:

    95

            params = []

    96

            if self.CTNParams:

    97

                params.append(self.CTNParams[1].getElementInfos(self.CTNParams[0]))

    98

            else:

    99

                params.append({

   100

                    'use': 'required',

   101

                    'type': 'element',

   102

                    'name': 'SlaveParams',

   103

                    'value': None,

   104

                    'children': []

   105

                })

   106

   107

            slave_type = self.CTNParent.GetSlaveType(self.GetSlavePos())

   108

            params[0]['children'].insert(

   109

                0,

   110

                {

   111

                    'use': 'optional',

   112

                    'type': self.CTNParent.GetSlaveTypesLibrary(self.NODE_PROFILE),

   113

                    'name': 'Type',

   114

                    'value': (slave_type["device_type"], slave_type)

   115

                })

   116

            params[0]['children'].insert(

   117

                1,

   118

                {

   119

                    'use': 'optional',

   120

                    'type': 'unsignedLong',

   121

                    'name': 'Alias',

   122

                    'value': self.CTNParent.GetSlaveAlias(self.GetSlavePos())

   123

                })

   124

            return params

   125

   126

    def SetParamsAttribute(self, path, value):

   127

        self.GetSlaveInfos()

   128

        position = self.BaseParams.getIEC_Channel()

   129

   130

        if path == "SlaveParams.Type":

   131

            self.CTNParent.SetSlaveType(position, value)

   132

            slave_type = self.CTNParent.GetSlaveType(self.GetSlavePos())

   133

            value = (slave_type["device_type"], slave_type)

   134

            # if self._View is not None:

   135

            #     wx.CallAfter(self._View.EtherCATManagementTreebook.SlaveStatePanel.RefreshSlaveInfos())

   136

            #     self._View.EtherCATManagementTreebook.SlaveStatePanel.RefreshSlaveInfos()

   137

            #     self._View.EtherCATManagementTreebook.PDOMonitoringPanel.PDOInfoUpdate()

   138

            #     self._View.EtherCATManagementTreebook.SmartView.Create_SmartView()

   139

            return value, True

   140

        elif path == "SlaveParams.Alias":

   141

            self.CTNParent.SetSlaveAlias(position, value)

   142

            return value, True

   143

   144

        value, refresh = ConfigTreeNode.SetParamsAttribute(self, path, value)

   145

   146

        # Filter IEC_Channel, Slave_Type and Alias that have specific behavior

   147

        if path == "BaseParams.IEC_Channel" and value != position:

   148

            self.CTNParent.SetSlavePosition(position, value)

   149

   150

        return value, refresh

   151

   152

    def GetSlaveInfos(self):

   153

        return self.CTNParent.GetSlaveInfos(self.GetSlavePos())

   154

   155

    def GetSlaveVariables(self, limits):

   156

        return self.CTNParent.GetSlaveVariables(self.GetSlavePos(), limits)

   157

   158

    def GetVariableLocationTree(self):

   159

        return {

   160

            "name": self.BaseParams.getName(),

   161

            "type": LOCATION_CONFNODE,

   162

            "location": self.GetFullIEC_Channel(),

   163

            "children": self.CTNParent.GetDeviceLocationTree(self.GetSlavePos(), self.GetCurrentLocation(), self.BaseParams.getName())

   164

        }

   165

   166

    def CTNGenerate_C(self, buildpath, locations):

   167

        return [], "", False