16

from PLCControler import LOCATION_CONFNODE, LOCATION_MODULE, LOCATION_GROUP, \

    17

    LOCATION_VAR_INPUT, LOCATION_VAR_OUTPUT, LOCATION_VAR_MEMORY

    23

#HSAHN 2015.07.26

    24

#remove NODE_VARIABLES's optional items.

    25

#As for now, optional items will be added dynamicaly.

    27

    ("ControlWord", 0x6040, 0x00, "UINT", "Q"),

    28

    ("ModesOfOperation", 0x6060, 0x00, "SINT", "Q"),

    29

    ("StatusWord", 0x6041, 0x00, "UINT", "I"),

    33

#HSAHN 2015.07.26

    34

#reference variable

    35

ADD_NODE_VARIABLES = ({'name':"TargetPosition"   , 'index':0x607a, 'sub-index':0x00, 'type':"DINT", 'direction':"Q"},

    36

                      {'name':"TargetVelocity"   , 'index':0x60ff, 'sub-index':0x00, 'type':"DINT", 'direction':"Q"},

    37

                      {'name':"TargetTorque"     , 'index':0x6071, 'sub-index':0x00, 'type':"INT",  'direction':"Q"},

    38

                      {'name':"ActualPosition"   , 'index':0x6064, 'sub-index':0x00, 'type':"DINT", 'direction':"I"},

    39

                      {'name':"ActualVelocity"   , 'index':0x606c, 'sub-index':0x00, 'type':"DINT", 'direction':"I"},

    40

                      {'name':"ActualTorque"     , 'index':0x6077, 'sub-index':0x00, 'type':"INT",  'direction':"I"})

    41

    42

DEFAULT_RETRIEVE = "    __CIA402Node_%(location)s.axis->%(name)s = *(__CIA402Node_%(location)s.%(name)s);"

    43

DEFAULT_PUBLISH = "    *(__CIA402Node_%(location)s.%(name)s) = __CIA402Node_%(location)s.axis->%(name)s;"

    44

    56

    67

        {"description": ("DigitalOutputs", 0x60FE, 0x01, "UDINT", "I"),

    68

         "publish": None}

    88

BLOCK_INPUT_TEMPLATE = "    __SET_VAR(%(blockname)s->,%(input_name)s, %(input_value)s);"

    89

BLOCK_OUTPUT_TEMPLATE = "    __SET_VAR(data__->,%(output_name)s, __GET_VAR(%(blockname)s->%(output_name)s));"

    90

    91

BLOCK_FUNCTION_TEMPLATE = """

    92

extern void ETHERLAB%(ucase_blocktype)s_body__(ETHERLAB%(ucase_blocktype)s* data__);

    93

void __%(blocktype)s_%(location)s(MC_%(ucase_blocktype)s *data__) {

    94

__DECLARE_GLOBAL_PROTOTYPE(ETHERLAB%(ucase_blocktype)s, %(blockname)s);

    95

ETHERLAB%(ucase_blocktype)s* %(blockname)s = __GET_GLOBAL_%(blockname)s();

    96

__SET_VAR(%(blockname)s->, POS, AxsPub.axis->NetworkPosition);

    97

%(extract_inputs)s

    98

ETHERLAB%(ucase_blocktype)s_body__(%(blockname)s);

    99

%(return_outputs)s

   100

}

   101

"""

   102

   103

BLOCK_FUNTION_DEFINITION_TEMPLATE = "        __CIA402Node_%(location)s.axis->__mcl_func_MC_%(blocktype)s = __%(blocktype)s_%(location)s;"

   104

   116

# add jblee

   117

MODEOFOP_HOMING_METHOD_TEMPLATE = """

   118

	if(*(AxsPub.ModesOfOperation) == 0x06){

   119

		IEC_BOOL homing = AxsPub.axis->HomingOperationStart;

   120

		if(power){

   121

			if (homing)

   122

				CW |= Homing_OperationStart_Origin;

   123

			else

   124

				CW &= ~(Homing_OperationStart_Origin);

   125

		}

   126

		else{

   127

			if (homing)

   128

				CW |= Homing_OperationStart_Edit;

   129

			else

   130

				CW &= ~(EnableOperation);

   131

		}

   132

   133

	}

   134

"""

   135

   136

MODEOFOP_COMPUTATION_MODE_TEMPLATE = """

   137

	switch (AxsPub.axis->AxisMotionMode) {

   138

		//ssh_add

   139

		case mc_mode_hm:

   140

			*(AxsPub.ModesOfOperation) = 0x06;

   141

			break;

   142

		case mc_mode_cst:

   143

			*(AxsPub.ModesOfOperation) = 0x0a;

   144

			break;

   145

		case mc_mode_csv:

   146

			*(AxsPub.ModesOfOperation) = 0x09;

   147

			break;

   148

		default:

   149

			*(AxsPub.ModesOfOperation) = 0x08;

   150

			break;

   151

	}

   152

"""

   153

   196

        #HSAHN

   197

        # Select PDO Mapping

   198

        self.SelectedPDOIndex = []

   199

        self.SelectedRxPDOIndex = []

   200

        self.SelectedTxPDOIndex = []

   201

        #HSAHN END

   202

   258

   259

    # add jblee

   260

    """

   261

    def LoadPDOSelectData(self):

   262

        ReadData = []

   263

        files = os.listdir(self.CTNPath())

   264

        filepath = os.path.join(self.CTNPath(), "DataForPDO.txt")

   265

        if os.path.isfile(filepath):

   266

            PDODataRead = open(filepath, 'r')

   267

            ReadData = PDODataRead.readlines()

   268

            PDODataRead.close()

   269

   270

        if len(ReadData) > 1:

   271

            for data in ReadData[0].split() :

   272

                if data == "RxPDO":

   273

                    continue

   274

                self.SelectedRxPDOIndex.append(int(data, 0))

   275

   276

            for data in ReadData[1].split() :

   277

                if data == "TxPDO":

   278

                    continue

   279

                self.SelectedTxPDOIndex.append(int(data, 0))

   280

    """

   281

   282

    def LoadPDOSelectData(self):

   283

        RxPDOData = self.BaseParams.getRxPDO()

   284

        RxPDOs = []

   285

        if RxPDOData != "None":

   286

            RxPDOs = RxPDOData.split()

   287

        if RxPDOs :

   288

            for RxPDO in RxPDOs :

   289

                self.SelectedRxPDOIndex.append(int(RxPDO, 0))

   290

   291

        TxPDOData = self.BaseParams.getTxPDO()

   292

        TxPDOs = []

   293

        if TxPDOData != "None":

   294

            TxPDOs = TxPDOData.split()

   295

        if TxPDOs :

   296

            for TxPDO in TxPDOs :

   297

                self.SelectedTxPDOIndex.append(int(TxPDO, 0))

   298

   299

    def LoadDefaultPDOSet(self):

   300

        ReturnData = []

   301

        rx_pdo_entries = self.CommonMethod.GetRxPDOCategory()

   302

        if len(rx_pdo_entries):

   303

            for i in range(len(rx_pdo_entries)):

   304

                if rx_pdo_entries[i]['sm'] is not None:

   305

                    ReturnData.append(rx_pdo_entries[i]['pdo_index'])

   306

   307

        tx_pdo_entries = self.CommonMethod.GetTxPDOCategory()

   308

        if len(tx_pdo_entries):

   309

            for i in range(len(tx_pdo_entries)):

   310

                if tx_pdo_entries[i]['sm'] is not None:

   311

                    ReturnData.append(tx_pdo_entries[i]['pdo_index'])

   312

   313

        if ReturnData :

   314

            return ReturnData

   315

        else :

   316

            return [5632, 6656]

   322

   323

        plc_cia402node_filepath = os.path.join(os.path.split(__file__)[0], "plc_cia402node.c")

   327

        # HSAHN 150726

   328

        # add "default_variables_retrieve": [], "default_variables_publish": [],

   329

		# As PDO mapping object, it will add auto-complete code.

   330

        # add "modeofop_homing_method", "modeofop_computation_mode" by jblee

   331

        str_completion = {

   332

            "slave_pos": self.GetSlavePos(),

   333

            "location": location_str,

   334

            "MCL_headers": Headers,

   335

            "extern_located_variables_declaration": [],

   336

            "fieldbus_interface_declaration": [],

   337

            "fieldbus_interface_definition": [],

   338

            "entry_variables": [],

   339

            "init_axis_params": [],

   340

            "init_entry_variables": [],

   341

            "default_variables_retrieve": [],

   342

            "default_variables_publish": [],

   343

            "extra_variables_retrieve": [],

   344

            "extra_variables_publish": [],

   345

            "modeofop_homing_method": [],

   346

            "modeofop_computation_mode": []

   347

        }

   348

   350

            texts = {

   351

                "blocktype": blocktype_infos["blocktype"],

   352

                "ucase_blocktype": blocktype_infos["blocktype"].upper(),

   353

                "location": "_".join(map(str, current_location))

   354

            }

   355

            texts["blockname"] = "%(ucase_blocktype)s_%(location)s" % texts

   357

            inputs = [{"input_name": "POS", "input_value": str(self.GetSlavePos())},

   358

                      {"input_name": "EXECUTE", "input_value": "__GET_VAR(data__->EXECUTE)"}] +\

   359

                     [{"input_name": input["name"].upper(), 

   360

                       "input_value": "__GET_VAR(data__->%s)" % input["name"].upper()}

   361

                      for input in blocktype_infos["inputs"]]

   362

            input_texts = []

   363

            for input_infos in inputs:

   364

                input_infos.update(texts)

   365

                input_texts.append(BLOCK_INPUT_TEMPLATE % input_infos)

   366

            texts["extract_inputs"] = "\n".join(input_texts)

   368

            outputs = [{"output_name": output} for output in ["DONE", "BUSY", "ERROR"]] + \

   369

                      [{"output_name": output["name"].upper()} for output in blocktype_infos["outputs"]]

   370

            output_texts = []

   371

            for output_infos in outputs:

   372

                output_infos.update(texts)

   373

                output_texts.append(BLOCK_OUTPUT_TEMPLATE % output_infos)

   374

            texts["return_outputs"] = "\n".join(output_texts)

   376

            str_completion["fieldbus_interface_declaration"].append(

   377

                    BLOCK_FUNCTION_TEMPLATE % texts)

   378

   379

            str_completion["fieldbus_interface_definition"].append(

   380

                    BLOCK_FUNTION_DEFINITION_TEMPLATE % texts)

   381

   382

        variables = NODE_VARIABLES[:]

   383

   384

#HSAHN

   385

#2015. 7. 24 PDO Variable

   386

        #if PDO is not selected, use 1st PDO set

   387

        self.LoadPDOSelectData()

   388

        if not self.SelectedRxPDOIndex and not self.SelectedTxPDOIndex :

   389

            self.SelectedPDOIndex = self.LoadDefaultPDOSet()

   390

        else :

   391

            self.SelectedPDOIndex = self.SelectedRxPDOIndex + self.SelectedTxPDOIndex

   392

   393

        add_idx = []

   394

        for i in range(len(ADD_NODE_VARIABLES)):

   395

            add_idx.append(ADD_NODE_VARIABLES[i]['index'])

   396

   397

        self.CommonMethod.RequestPDOInfo()

   398

        pdo_info = self.CommonMethod.GetRxPDOCategory() + self.CommonMethod.GetTxPDOCategory()

   399

        pdo_entry = self.CommonMethod.GetRxPDOInfo() + self.CommonMethod.GetTxPDOInfo()

   400

        list_index = 0

   401

        ModeOfOpFlag = False

   402

        ModeOfOpDisplayFlag = False

   403

        for i in range(len(pdo_info)):

   404

            #if pdo_index is in the SelectedPDOIndex: put the PDO mapping information intto the "used" object

   405

            if pdo_info[i]['pdo_index'] in self.SelectedPDOIndex:

   406

                used = pdo_entry[list_index:list_index + pdo_info[i]['number_of_entry']]

   407

                for used_data in used:

   408

                    # 24672 -> 0x6060, Mode of Operation

   409

                    if used_data['entry_index'] == 24672:

   410

                        ModeOfOpFlag = True

   411

                    # 24673 -> 0x6061, Mode of Operation Display

   412

                    elif used_data["entry_index"] == 24673:

   413

                        ModeOfOpDisplayFlag = True

   414

   415

                    if used_data['entry_index'] in add_idx:

   416

                        idx = add_idx.index(used_data['entry_index'])

   417

                        adder = list([ADD_NODE_VARIABLES[idx]['name'], ADD_NODE_VARIABLES[idx]['index'], \

   418

                                     ADD_NODE_VARIABLES[idx]['sub-index'], ADD_NODE_VARIABLES[idx]['type'], \

   419

                                     ADD_NODE_VARIABLES[idx]['direction']])

   420

                        variables.append(adder)

   421

                        if ADD_NODE_VARIABLES[idx]['direction'] == "Q":                           

   422

                            parsed_string = ADD_NODE_VARIABLES[idx]['name'].replace("Target", "")

   423

                            # add jblee

   424

                            check_q_data = "    *(AxsPub.Target%s) = AxsPub.axis->Raw%sSetPoint;" %(parsed_string, parsed_string)

   425

                            if check_q_data not in str_completion["default_variables_publish"]:

   426

                                str_completion["default_variables_publish"].append(check_q_data)

   427

                        elif ADD_NODE_VARIABLES[idx]['direction'] == "I":

   428

                            parsed_string = ADD_NODE_VARIABLES[idx]['name'].replace("Actual", "")

   429

                            # add jblee

   430

                            check_i_data = "    AxsPub.axis->ActualRaw%s = *(AxsPub.Actual%s);" %(parsed_string, parsed_string)

   431

                            if check_i_data not in str_completion["default_variables_retrieve"]:

   432

                                str_completion["default_variables_retrieve"].append(check_i_data)

   433

            list_index += pdo_info[i]['number_of_entry']

   434

#HSAHN END

   435

   436

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

   437

        for param in params["children"]:

   438

            if param["name"] in EXTRA_NODE_VARIABLES_DICT:

   439

                if param["value"]:

   440

                    extra_variables = EXTRA_NODE_VARIABLES_DICT.get(param["name"])

   441

                    for variable_infos in extra_variables:

   442

                        var_infos = {

   443

                            "location": location_str,

   444

                            "name": variable_infos["description"][0]

   445

                        }

   446

                        variables.append(variable_infos["description"])

   447

                        retrieve_template = variable_infos.get("retrieve", DEFAULT_RETRIEVE)

   448

                        publish_template = variable_infos.get("publish", DEFAULT_PUBLISH)

   450

                        if retrieve_template is not None:

   451

                            str_completion["extra_variables_retrieve"].append(

   452

                                retrieve_template % var_infos)

   453

                        if publish_template is not None:

   454

                            str_completion["extra_variables_publish"].append(

   455

                                publish_template % var_infos)

   456

   457

            #elif param["value"] is not None:

   459

                param_infos = {

   460

                    "location": location_str,

   461

                    "param_name": param["name"],

   462

                }

   463

                if param["type"] == "boolean":

   464

                    param_infos["param_value"] = {True: "1", False: "0"}[param["value"]]

   465

                    param_infos["param_name"] = param["name"].replace("Enable", "") + "Enabled"

   466

                    if param["value"] == False:

   467

                        continue

   468

                else:

   469

                    param_infos["param_value"] = str(param["value"])

   470

                # param_name = param_name.replace("Enable", "") + "Enabled"

   471

                str_completion["init_axis_params"].append(

   472

                    "        __CIA402Node_%(location)s.axis->%(param_name)s = %(param_value)s;" % param_infos)

   473

   474

        check_variable = []

   475

        for variable in variables:

   476

            # add jblee

   477

            if variable in check_variable:

   478

                continue

   479

   480

            var_infos = dict(zip(["name", "index", "subindex", "var_type", "dir"], variable))

   481

            var_infos["location"] = location_str

   482

            var_infos["var_size"] = self.GetSizeOfType(var_infos["var_type"])

   483

            var_infos["var_name"] = "__%(dir)s%(var_size)s%(location)s_%(index)d_%(subindex)d" % var_infos

   484

   485

            # add jblee

   486

            if var_infos["index"] in [24672] and ModeOfOpFlag:

   487

                str_completion["modeofop_homing_method"].append(MODEOFOP_HOMING_METHOD_TEMPLATE)

   488

                str_completion["modeofop_computation_mode"].append(MODEOFOP_COMPUTATION_MODE_TEMPLATE)

   489

   490

            # add jblee

   491

            if var_infos["index"] in [24672, 24673] and (not ModeOfOpFlag or not ModeOfOpDisplayFlag):

   492

                continue

   493

   494

            str_completion["extern_located_variables_declaration"].append(

   495

                    "IEC_%(var_type)s *%(var_name)s;" % var_infos)

   496

            str_completion["entry_variables"].append(

   497

                    "    IEC_%(var_type)s *%(name)s;" % var_infos)

   498

            str_completion["init_entry_variables"].append(