1

import os, sys

     2

base_folder = os.path.split(sys.path[0])[0]

     3

CanFestivalPath = os.path.join(base_folder, "CanFestival-3")

     4

sys.path.append(os.path.join(CanFestivalPath, "objdictgen"))

     5

     6

from nodelist import NodeList

     7

from nodemanager import NodeManager

     8

import config_utils, gen_cfile

     9

from networkedit import networkedit

    10

from objdictedit import objdictedit

    11

import canfestival_config

    12

from plugger import PlugTemplate

    13

    14

from gnosis.xml.pickle import *

    15

from gnosis.xml.pickle.util import setParanoia

    16

setParanoia(0)

    17

    18

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

    19

#                    SLAVE

    20

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

    21

    22

class _SlavePlug(NodeManager):

    23

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

    24

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

    26

        <xsd:complexType>

    27

          <xsd:attribute name="CAN_Device" type="xsd:string" use="required"/>

    28

          <xsd:attribute name="CAN_Baudrate" type="xsd:string" use="required"/>

    29

          <xsd:attribute name="NodeId" type="xsd:string" use="required"/>

    30

        </xsd:complexType>

    31

      </xsd:element>

    32

    </xsd:schema>

    33

    """

    34

    35

    def GetSlaveODPath(self):

    37

    38

    def __init__(self):

    39

        # TODO change netname when name change

    40

        NodeManager.__init__(self)

    41

        odfilepath = self.GetSlaveODPath()

    42

        if(os.path.isfile(odfilepath)):

    43

            self.OpenFileInCurrent(odfilepath)

    44

        else:

    45

            self.CreateNewNode("SlaveNode",  # Name - will be changed at build time

    46

                               0x00,         # NodeID - will be changed at build time

    47

                               "slave",      # Type

    48

                               "",           # description 

    49

                               "None",       # profile

    50

                               "",           # prfile filepath

    51

                               "heartbeat",  # NMT

    52

                               [])           # options

    53

    54

    _View = None

    55

    def _OpenView(self, logger):

    56

        if not self._View:

    57

            def _onclose():

    58

                self._View = None

    59

            def _onsave():

    60

                self.GetPlugRoot().SaveProject()

    62

            # TODO redefine BusId when IEC channel change

    63

            self._View.SetBusId(self.GetCurrentLocation())

    64

            self._View._onclose = _onclose

    65

            self._View._onsave = _onsave

    66

            self._View.Show()

    67

    68

    PluginMethods = [

    69

        {"bitmap" : os.path.join("images", "NetworkEdit"),

    72

         "method" : "_OpenView"},

    73

    ]

    74

    75

    def OnPlugClose(self):

    76

        if self._View:

    77

            self._View.Close()

    78

    79

    def PlugTestModified(self):

    81

    82

    def OnPlugSave(self):

    84

    85

    def PlugGenerate_C(self, buildpath, locations, logger):

    86

        """

    87

        Generate C code

    88

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

    89

        @param locations: List of complete variables locations \

    90

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

    91

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

    92

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

    93

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

    94

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

    95

            }, ...]

    96

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

    97

        """

    98

        current_location = self.GetCurrentLocation()

    99

        # define a unique name for the generated C file

   101

        Gen_OD_path = os.path.join(buildpath, "OD_%s.c"%prefix )

   108

        if res :

   109

            raise Exception, res

   111

        return [(Gen_OD_path,canfestival_config.getCFLAGS(CanFestivalPath))],"",False

   112

   113

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

   114

#                    MASTER

   115

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

   116

   117

class _NodeListPlug(NodeList):

   118

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

   119

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

   120

      <xsd:element name="CanFestivalNode">

   121

        <xsd:complexType>

   122

          <xsd:attribute name="CAN_Device" type="xsd:string" use="required"/>

   123

          <xsd:attribute name="CAN_Baudrate" type="xsd:string" use="required"/>

   124

          <xsd:attribute name="NodeId" type="xsd:string" use="required"/>

   125

          <xsd:attribute name="Sync_TPDOs" type="xsd:boolean" use="optional" default="true"/>

   126

        </xsd:complexType>

   127

      </xsd:element>

   128

    </xsd:schema>

   129

    """

   130

   131

    def __init__(self):

   132

        manager = NodeManager()

   133

        # TODO change netname when name change

   134

        NodeList.__init__(self, manager, self.BaseParams.getName())

   135

        self.LoadProject(self.PlugPath())

   136

   137

    _View = None

   138

    def _OpenView(self, logger):

   139

        if not self._View:

   140

            def _onclose():

   141

                self._View = None

   142

            def _onsave():

   143

                self.GetPlugRoot().SaveProject()

   145

            # TODO redefine BusId when IEC channel change

   146

            self._View.SetBusId(self.GetCurrentLocation())

   147

            self._View._onclose = _onclose

   148

            self._View._onsave = _onsave

   149

            self._View.Show()

   150

   151

    def _ShowMasterGenerated(self, logger):

   152

        buildpath = self._getBuildPath()

   153

        # Eventually create build dir

   154

        if not os.path.exists(buildpath):

   155

            logger.write_error("Error: No PLC built\n")

   156

            return

   157

   158

        masterpath = os.path.join(buildpath, "MasterGenerated.od")

   159

        if not os.path.exists(masterpath):

   160

            logger.write_error("Error: No Master generated\n")

   161

            return

   162

   163

        new_dialog = objdictedit(None, [masterpath])

   164

        new_dialog.Show()

   165

   166

    PluginMethods = [

   167

        {"bitmap" : os.path.join("images", "NetworkEdit"),

   168

         "name" : "Edit network", 

   169

         "tooltip" : "Edit CanOpen Network with NetworkEdit",

   170

         "method" : "_OpenView"},

   171

        {"name" : "Show Master", 

   172

         "tooltip" : "Show Master generated by config_utils",

   173

         "method" : "_ShowMasterGenerated"}

   174

    ]

   175

   176

    def OnPlugClose(self):

   177

        if self._View:

   178

            self._View.Close()

   179

   180

    def PlugTestModified(self):

   181

        return self.ChangesToSave or self.HasChanged()

   182

   183

    def OnPlugSave(self):

   184

        self.SetRoot(self.PlugPath())

   186

   187

    def PlugGenerate_C(self, buildpath, locations, logger):

   188

        """

   189

        Generate C code

   190

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

   191

        @param locations: List of complete variables locations \

   192

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

   193

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

   194

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

   195

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

   196

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

   197

            }, ...]

   198

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

   199

        """

   200

        current_location = self.GetCurrentLocation()

   201

        # define a unique name for the generated C file

   203

        Gen_OD_path = os.path.join(buildpath, "OD_%s.c"%prefix )

   204

        # Create a new copy of the model with DCF loaded with PDO mappings for desired location

   205

        master, pointers = config_utils.GenerateConciseDCF(locations, current_location, self, self.CanFestivalNode.getSync_TPDOs(),"OD_%s"%prefix)

   209

        res = gen_cfile.GenerateFile(Gen_OD_path, master, pointers)

   210

        if res :

   211

            raise Exception, res

   212

   213

        file = open(os.path.join(buildpath, "MasterGenerated.od"), "w")

   214

        dump(master, file)

   215

        file.close()

   216

   217

        return [(Gen_OD_path,canfestival_config.getCFLAGS(CanFestivalPath))],"",False

   218

   219

class RootClass:

   220

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

   221

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

   222

      <xsd:element name="CanFestivalInstance">

   223

        <xsd:complexType>

   224

          <xsd:attribute name="CAN_Driver" type="xsd:string" use="required"/>

   225

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

   226

        </xsd:complexType>

   227

      </xsd:element>

   228

    </xsd:schema>

   229

    """

   230

    PlugChildsTypes = [("CanOpenNode",_NodeListPlug, "CanOpen Master"),("CanOpenSlave",_SlavePlug, "CanOpen Slave")]

   231

    def GetParamsAttributes(self, path = None):

   232

        infos = PlugTemplate.GetParamsAttributes(self, path = None)

   233

        for element in infos:

   234

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

   235

                for child in element["children"]:

   236

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

   237

                        DLL_LIST= getattr(canfestival_config,"DLL_LIST",None)

   238

                        if DLL_LIST is not None:

   239

                            child["type"] = DLL_LIST

   240

                        return infos    

   241

        return infos

   242

   243

    def PlugGenerate_C(self, buildpath, locations, logger):

   244

   245

        format_dict = {"locstr" : "_".join(map(str,self.GetCurrentLocation())),

   246

                       "candriver" : self.CanFestivalInstance.getCAN_Driver(),

   247

                       "nodes_includes" : "",

   248

                       "board_decls" : "",

   249

                       "nodes_declare" : "",

   250

                       "nodes_init" : "",

   251

                       "nodes_open" : "",

   252

                       "nodes_close" : "",

   253

                       "nodes_send_sync" : "",

   254

                       "nodes_proceed_sync" : ""}

   255

        for child in self.IECSortedChilds():

   256

            childlocstr = "_".join(map(str,child.GetCurrentLocation()))

   257

            nodename = "OD_%s" % childlocstr

   267

   268

            format_dict["nodes_includes"] += '#include "%s.h"\n'%(nodename)

   269

            format_dict["board_decls"] += 'BOARD_DECL(%s, "%s", "%s")\n'%(

   270

                   nodename,

   273

            format_dict["nodes_declare"] += 'NODE_DECLARE(%s, %s)\n    '%(

   274

                   nodename,

   276

            format_dict["nodes_init"] += 'NODE_INIT(%s, %s)\n    '%(

   277

                   nodename,

   279

            format_dict["nodes_open"] += 'NODE_OPEN(%s)\n    '%(nodename)

   280

            format_dict["nodes_close"] += 'NODE_CLOSE(%s)\n    '%(nodename)

   281

   282

        if sys.platform == 'win32':

   283

            if self.CanFestivalInstance.getDebug_mode() and os.path.isfile(os.path.join("%s"%(format_dict["candriver"] + '_DEBUG.dll'))):

   284

                    format_dict["candriver"] += '_DEBUG.dll'

   285

            else:

   286

                format_dict["candriver"] += '.dll'

   287

   288

        filename = os.path.join(os.path.split(__file__)[0],"cf_runtime.c")

   289

        cf_main = open(filename).read() % format_dict

   290

        cf_main_path = os.path.join(buildpath, "CF_%(locstr)s.c"%format_dict)

   291

        f = open(cf_main_path,'w')

   292

        f.write(cf_main)

   293

        f.close()

   294

   295

        return [(cf_main_path, canfestival_config.getCFLAGS(CanFestivalPath))],canfestival_config.getLDFLAGS(CanFestivalPath), True

   296

   297