1

/*

     2

 * (c) 2007 Mario de Sousa, Laurent Bessard

     3

 *

     4

 * Offered to the public under the terms of the GNU General Public License

     5

 * as published by the Free Software Foundation; either version 2 of the

     6

 * License, or (at your option) any later version.

     7

 *

     8

 * This program is distributed in the hope that it will be useful, but

     9

 * WITHOUT ANY WARRANTY; without even the implied warranty of

    10

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General

    11

 * Public License for more details.

    12

 *

    13

 * This code is made available on the understanding that it will not be

    14

 * used in safety-critical situations without a full and competent review.

    15

 */

    16

    17

/*

    18

 * An IEC 61131-3 IL and ST compiler.

    19

 *

    20

 * Based on the

    21

 * FINAL DRAFT - IEC 61131-3, 2nd Ed. (2001-12-10)

    22

 *

    23

 */

    24

    25

    26

/*

    27

 * Conversion of sfc networks (i.e. SFC code).

    28

 *

    29

 * This is part of the 4th stage that generates

    30

 * a c++ source program equivalent to the SFC, IL and ST

    31

 * code.

    32

 */

    33

    34

    35

    36

/***********************************************************************/

    37

/***********************************************************************/

    38

/***********************************************************************/

    39

/***********************************************************************/

    40

    41

class generate_cc_sfc_transitiontest_c: public generate_cc_base_c {

    42

    43

  private:

    44

    generate_cc_il_c *generate_cc_il;

    45

    generate_cc_st_c *generate_cc_st;

    46

    47

  public:

    48

    generate_cc_sfc_transitiontest_c(stage4out_c *s4o_ptr, symbol_c *scope, const char *variable_prefix = NULL)

    49

    : generate_cc_base_c(s4o_ptr) {

    50

      generate_cc_il = new generate_cc_il_c(s4o_ptr, scope, variable_prefix);

    51

      generate_cc_st = new generate_cc_st_c(s4o_ptr, scope, variable_prefix);

    52

      this->set_variable_prefix(variable_prefix);

    53

    }

    54

    55

    ~generate_cc_sfc_transitiontest_c(void) {

    56

      delete generate_cc_il;

    57

      delete generate_cc_st;

    58

    }

    59

    60

    void print_step_argument(symbol_c *step_name, const char* argument) {

    61

      print_variable_prefix();

    62

      s4o.print("step_list[");

    63

      step_name->accept(*this);

    64

      s4o.print("].");

    65

      s4o.print(argument);

    66

    }

    67

    68

    void print_reset_step(symbol_c *step_name) {

    69

      s4o.print(s4o.indent_spaces);

    70

      print_step_argument(step_name, "state");

    71

      s4o.print(" = 0;\n" + s4o.indent_spaces + "if (");

    72

      print_step_argument(step_name, "pulse");

    73

      s4o.print(" != 1 {\n");

    74

      s4o.indent_right();

    75

      s4o.print(s4o.indent_spaces);

    76

      print_step_argument(step_name, "pulse");

    77

      s4o.print(" = 2;\n");

    78

      s4o.indent_left();

    79

      s4o.print(s4o.indent_spaces + "}\n" + s4o.indent_spaces + "else {\n");

    80

      s4o.indent_right();

    81

      s4o.print(s4o.indent_spaces);

    82

      print_step_argument(step_name, "pulse");

    83

      s4o.print(" = 0;\n");

    84

      s4o.indent_left();

    85

      s4o.print(s4o.indent_spaces + "}\n" + s4o.indent_spaces);

    86

      print_step_argument(step_name, "elapsed_time");

    87

      s4o.print(" = __time_to_timespec(1, 0, 0, 0, 0, 0);");

    88

    }

    89

    90

    void print_set_step(symbol_c *step_name) {

    91

      s4o.print(s4o.indent_spaces);

    92

      print_step_argument(step_name, "state");

    93

      s4o.print(" = 1;\n" + s4o.indent_spaces);

    94

      print_step_argument(step_name, "pulse");

    95

      s4o.print(" = 1;");

    96

    } 

    97

    98

    void print_steps_state_test(steps_c *symbol) {

    99

      if (symbol->step_name != NULL) {

   100

        print_step_argument(symbol->step_name, "state");

   101

      }

   102

      if (symbol->step_name_list != NULL) {

   103

        for(int i = 0; i < ((list_c*)symbol->step_name_list)->n; i++) {

   104

          print_step_argument(((list_c*)symbol->step_name_list)->elements[i], "state");

   105

          if (i < ((list_c*)symbol->step_name_list)->n - 1) {

   106

            s4o.print(" && ");

   107

          }

   108

        }

   109

      }

   110

    }

   111

   112

    void print_reset_steps(steps_c *symbol) {

   113

      if (symbol->step_name != NULL) {

   114

        print_reset_step(symbol->step_name);

   115

        s4o.print("\n");

   116

      }

   117

      if (symbol->step_name_list != NULL) {

   118

        for(int i = 0; i < ((list_c*)symbol->step_name_list)->n; i++) {

   119

          print_reset_step(((list_c*)symbol->step_name_list)->elements[i]);

   120

          s4o.print("\n");

   121

        }

   122

      }

   123

    }

   124

   125

    void print_set_steps(steps_c *symbol) {

   126

      if (symbol->step_name != NULL) {

   127

        print_set_step(symbol->step_name);

   128

        s4o.print("\n");

   129

      }

   130

      if (symbol->step_name_list != NULL) {

   131

        for(int i = 0; i < ((list_c*)symbol->step_name_list)->n; i++) {

   132

          print_set_step(((list_c*)symbol->step_name_list)->elements[i]);

   133

          s4o.print("\n");

   134

        }

   135

      }

   136

    }

   137

   138

/*********************************************/

   139

/* B.1.6  Sequential function chart elements */

   140

/*********************************************/

   141

   142

    void *visit(initial_step_c *symbol) {return NULL;}

   143

   144

    void *visit(step_c *symbol) {return NULL;}

   145

   146

    void *visit(transition_c *symbol) {

   147

      s4o.print(s4o.indent_spaces + "if (");

   148

      print_steps_state_test((steps_c *)symbol->from_steps);

   149

      s4o.print(") {\n");

   150

      s4o.indent_right();

   151

   152

      // Calculate transition value

   153

      if (symbol->transition_condition_il != NULL) {

   154

        generate_cc_il->declare_backup_variable();

   155

        s4o.print(s4o.indent_spaces);

   156

        symbol->transition_condition_il->accept(*generate_cc_il);

   157

        s4o.print("if (");

   158

        generate_cc_il->print_backup_variable();

   159

        s4o.print(") {\n");

   160

      }

   161

      if (symbol->transition_condition_st != NULL) {

   162

        s4o.print(s4o.indent_spaces + "if (");

   163

        symbol->transition_condition_st->accept(*generate_cc_st);

   164

        s4o.print(") {\n");

   165

      }

   166

   167

      s4o.indent_right();      

   168

      print_reset_steps((steps_c *)symbol->from_steps);

   169

      print_set_steps((steps_c *)symbol->to_steps);      

   170

      s4o.indent_left();

   171

   172

      s4o.print(s4o.indent_spaces + "}\n");

   173

      s4o.indent_left();

   174

      s4o.print(s4o.indent_spaces + "}\n\n");

   175

      return NULL;

   176

    }

   177

   178

    void *visit(action_c *symbol) {return NULL;}

   179

   180

}; /* generate_cc_sfc_transitiontest_c */

   181

   182

   183

   184

   185

/***********************************************************************/

   186

/***********************************************************************/

   187

/***********************************************************************/

   188

/***********************************************************************/

   189

   190

class generate_cc_sfc_stepassociation_c: public generate_cc_base_c {

   191

   192

  private:

   193

    symbol_c *current_step;

   194

    symbol_c *current_action;

   195

   196

  public:

   197

    generate_cc_sfc_stepassociation_c(stage4out_c *s4o_ptr, symbol_c *scope, const char *variable_prefix = NULL)

   198

    : generate_cc_base_c(s4o_ptr) {

   199

      this->set_variable_prefix(variable_prefix);

   200

    }

   201

   202

    void print_step_argument(symbol_c *step_name, const char* argument) {

   203

      print_variable_prefix();

   204

      s4o.print("step_list[");

   205

      step_name->accept(*this);

   206

      s4o.print("].");

   207

      s4o.print(argument);

   208

    }

   209

   210

    void print_action_argument(symbol_c *action_name, const char* argument) {

   211

      print_variable_prefix();

   212

      s4o.print("action_list[");

   213

      action_name->accept(*this);

   214

      s4o.print("].");

   215

      s4o.print(argument);

   216

    }

   217

   218

/*********************************************/

   219

/* B.1.6  Sequential function chart elements */

   220

/*********************************************/

   221

   222

    void *visit(initial_step_c *symbol) {

   223

      s4o.print(s4o.indent_spaces + "// ");

   224

      symbol->step_name->accept(*this);

   225

      s4o.print(" action associations\n");

   226

      current_step = symbol->step_name;

   227

      symbol->action_association_list->accept(*this);

   228

      return NULL;

   229

    }

   230

   231

    void *visit(step_c *symbol) {

   232

      s4o.print(s4o.indent_spaces + "// ");

   233

      symbol->step_name->accept(*this);

   234

      s4o.print(" action associations\n");

   235

      current_step = symbol->step_name;

   236

      symbol->action_association_list->accept(*this);

   237

      return NULL;

   238

    }

   239

   240

    void *visit(transition_c *symbol) {return NULL;}

   241

   242

    void *visit(action_c *symbol) {return NULL;}

   243

   244

    void *visit(action_association_list_c* symbol) {

   245

      print_list(symbol, "", "\n", "\n\n");

   246

      return NULL;

   247

    }

   248

   249

    void *visit(action_association_c *symbol) {

   250

      if (symbol->action_qualifier != NULL) {

   251

        current_action = symbol->action_name;

   252

        symbol->action_qualifier->accept(*this);

   253

      }

   254

      else {

   255

        s4o.print(s4o.indent_spaces + "if (");

   256

        print_step_argument(current_step, "state");

   257

        s4o.print(") {\n");

   258

        s4o.indent_right();

   259

        s4o.print(s4o.indent_spaces);

   260

        print_action_argument(symbol->action_name, "state");

   261

        s4o.print(" = 1;\n");

   262

        s4o.indent_left();

   263

        s4o.print(s4o.indent_spaces + "}");

   264

      }

   265

      return NULL;

   266

    }

   267

   268

    void *visit(action_qualifier_c *symbol) {

   269

      char *qualifier = (char *)symbol->action_qualifier->accept(*this);

   270

   271

      s4o.print(s4o.indent_spaces + "if (");

   272

      if (strcmp(qualifier, "N") == 0) {

   273

        print_step_argument(current_step, "state");

   274

      }

   275

      if (strcmp(qualifier, "P") == 0 || strcmp(qualifier, "SD") == 0 || 

   276

          strcmp(qualifier, "DS") == 0 || strcmp(qualifier, "SL") == 0) {

   277

        print_step_argument(current_step, "pulse");

   278

        s4o.print(" == 1");

   279

      }

   280

      if (strcmp(qualifier, "D") == 0 || strcmp(qualifier, "L") == 0) {

   281

        print_step_argument(current_step, "state");

   282

        s4o.print(" && ");

   283

        print_step_argument(current_step, "elapsed_time");

   284

        if (strcmp(qualifier, "D") == 0) {

   285

          s4o.print(" >= ");

   286

        }

   287

        else {

   288

          s4o.print(" < ");

   289

        }

   290

        symbol->action_time->accept(*this);  

   291

      }

   292

      s4o.print(") {\n");

   293

      s4o.indent_right();

   294

      s4o.print(s4o.indent_spaces);

   295

      if (strcmp(qualifier, "N") == 0 || strcmp(qualifier, "P") == 0 ||

   296

          strcmp(qualifier, "D") == 0 || strcmp(qualifier, "L") == 0) {

   297

        print_action_argument(current_action, "state");

   298

        s4o.print(" = 1;\n");  

   299

      }

   300

      if (strcmp(qualifier, "SD") == 0 || strcmp(qualifier, "DS") == 0 || 

   301

          strcmp(qualifier, "SL") == 0) {

   302

        if (strcmp(qualifier, "SL") == 0) {

   303

          print_action_argument(current_action, "reset_remaining_time");  

   304

        }

   305

        else {

   306

          print_action_argument(current_action, "set_remaining_time");

   307

        }

   308

        s4o.print(" = ");

   309

        symbol->action_time->accept(*this);

   310

        s4o.print(";\n");

   311

      }

   312

      s4o.indent_left();

   313

      s4o.print(s4o.indent_spaces + "}");

   314

      if (strcmp(qualifier, "DS") == 0) {

   315

        print_step_argument(current_step, "pulse");

   316

        s4o.print(" == 2) {\n");

   317

        s4o.indent_right();

   318

        s4o.print(s4o.indent_spaces);

   319

        print_action_argument(current_action, "set_remaining_time");

   320

        s4o.print(" = __time_to_timespec(1, 0, 0, 0, 0, 0);\n");

   321

      }

   322

      return NULL;

   323

    }

   324

   325

    void *visit(qualifier_c *symbol) {

   326

      return (void *)symbol->value;

   327

    }

   328

   329

    void *visit(timed_qualifier_c *symbol) {

   330

      return (void *)symbol->value;

   331

    }

   332

   333

}; /* generate_cc_sfc_actiondecl_c */

   334

   335

   336

   337

   338

/***********************************************************************/

   339

/***********************************************************************/

   340

/***********************************************************************/

   341

/***********************************************************************/

   342

   343

class generate_cc_sfc_actionexecution_c: public generate_cc_base_c {

   344

   345

  private:

   346

    generate_cc_SFC_IL_ST_c *generate_cc_code;

   347

   348

  public:

   349

    generate_cc_sfc_actionexecution_c(stage4out_c *s4o_ptr, symbol_c *scope, const char *variable_prefix = NULL)

   350

    : generate_cc_base_c(s4o_ptr) {

   351

      generate_cc_code = new generate_cc_SFC_IL_ST_c(s4o_ptr, scope, variable_prefix);

   352

      this->set_variable_prefix(variable_prefix);

   353

    }

   354

   355

    ~generate_cc_sfc_actionexecution_c(void) {

   356

      delete generate_cc_code;

   357

    }

   358

   359

/*********************************************/

   360

/* B.1.6  Sequential function chart elements */

   361

/*********************************************/

   362

   363

    void *visit(initial_step_c *symbol) {return NULL;}

   364

   365

    void *visit(step_c *symbol) {return NULL;}

   366

   367

    void *visit(transition_c *symbol) {return NULL;}

   368

   369

    void *visit(action_c *symbol) {

   370

      s4o.print(s4o.indent_spaces + "if(");

   371

      print_variable_prefix();

   372

      s4o.print("action_list[");

   373

      symbol->action_name->accept(*this);

   374

      s4o.print("].state) {");

   375

      s4o.indent_right();

   376

   377

      // generate action code

   378

      symbol->function_block_body->accept(*generate_cc_code);

   379

   380

      s4o.indent_left();

   381

      s4o.print(s4o.indent_spaces + "}\n\n");

   382

      return NULL;

   383

    }

   384

   385

}; /* generate_cc_sfc_actiondecl_c */

   386

   387

   388

   389

/***********************************************************************/

   390

/***********************************************************************/

   391

/***********************************************************************/

   392

/***********************************************************************/

   393

   394

class generate_cc_sfc_c: public generate_cc_typedecl_c {

   395

   396

  private:

   397

    generate_cc_sfc_transitiontest_c *generate_cc_sfc_transitiontest;

   398

    generate_cc_sfc_stepassociation_c *generate_cc_sfc_stepassociation;

   399

    generate_cc_sfc_actionexecution_c *generate_cc_sfc_actionexecution;

   400

   401

  public:

   402

    generate_cc_sfc_c(stage4out_c *s4o_ptr, symbol_c *scope, const char *variable_prefix = NULL)

   403

    : generate_cc_typedecl_c(s4o_ptr) {

   404

      generate_cc_sfc_transitiontest = new generate_cc_sfc_transitiontest_c(s4o_ptr, scope, variable_prefix);

   405

      generate_cc_sfc_stepassociation = new generate_cc_sfc_stepassociation_c(s4o_ptr, scope, variable_prefix);

   406

      generate_cc_sfc_actionexecution = new generate_cc_sfc_actionexecution_c(s4o_ptr, scope, variable_prefix);

   407

      this->set_variable_prefix(variable_prefix);

   408

    }

   409

   410

    virtual ~generate_cc_sfc_c(void) {

   411

      delete generate_cc_sfc_transitiontest;

   412

      delete generate_cc_sfc_stepassociation;

   413

      delete generate_cc_sfc_actionexecution;

   414

    }

   415

   416

/*********************************************/

   417

/* B.1.6  Sequential function chart elements */

   418

/*********************************************/

   419

   420

    void *visit(sfc_network_c *symbol) {

   421

      s4o.print(s4o.indent_spaces +"INT i;\n\n");

   422

      s4o.print(s4o.indent_spaces +"BOOL transition;\n\n");

   423

   424

      /* generate step initilizations */

   425

      s4o.print(s4o.indent_spaces + "// Steps initialisation\n");

   426

      s4o.print(s4o.indent_spaces + "for (i = 0; i < ");

   427

      print_variable_prefix();

   428

      s4o.print("nb_steps; i++) {\n");

   429

      s4o.indent_right();

   430

      s4o.print(s4o.indent_spaces);

   431

      print_variable_prefix();

   432

      s4o.print("step_list[i].pulse = 0;\n");

   433

      s4o.print(s4o.indent_spaces + "if (");

   434

      print_variable_prefix();

   435

      s4o.print("step_list[i].state) {\n");

   436

      s4o.indent_right();

   437

      s4o.print(s4o.indent_spaces);

   438

      print_variable_prefix();

   439

      s4o.print("step_list[i].elapsed_time = __add_timespec(");

   440

      print_variable_prefix();

   441

      s4o.print("step_list[i].elapsed_time, PERIOD);\n");

   442

      s4o.indent_left();

   443

      s4o.print(s4o.indent_spaces + "}\n");

   444

      s4o.indent_left();

   445

      s4o.print(s4o.indent_spaces + "}\n");

   446

   447

      /* generate action initilizations */

   448

      s4o.print(s4o.indent_spaces + "// Actions initialisation\n");

   449

      s4o.print(s4o.indent_spaces + "for (i = 0; i < ");

   450

      print_variable_prefix();

   451

      s4o.print("nb_actions; i++) {\n");

   452

      s4o.indent_right();

   453

      s4o.print(s4o.indent_spaces);

   454

      print_variable_prefix();

   455

      s4o.print("action_list[i].state = 0;\n");

   456

      s4o.print(s4o.indent_spaces);

   457

      print_variable_prefix();

   458

      s4o.print("action_list[i].set = 0;\n");

   459

      s4o.print(s4o.indent_spaces);

   460

      print_variable_prefix();

   461

      s4o.print("action_list[i].reset = 0;\n");

   462

      s4o.print(s4o.indent_spaces + "if (");

   463

      print_variable_prefix();

   464

      s4o.print("__compare_timespec(>, action_list[i].set_remaining_time, __time_to_timespec(1, 0, 0, 0, 0, 0)) {\n");

   465

      s4o.indent_right();

   466

      s4o.print(s4o.indent_spaces);

   467

      print_variable_prefix();

   468

      s4o.print("action_list[i].set_remaining_time = __sub_timespec(");

   469

      print_variable_prefix();

   470

      s4o.print("action_list[i].set_remaining_time, PERIOD);\n");

   471

      s4o.print(s4o.indent_spaces + "if (");

   472

      print_variable_prefix();

   473

      s4o.print("__compare_timespec(<=, action_list[i].set_remaining_time, __time_to_timespec(1, 0, 0, 0, 0, 0)) {\n");

   474

      s4o.indent_right();

   475

      s4o.print(s4o.indent_spaces);

   476

      print_variable_prefix();

   477

      s4o.print("action_list[i].set_remaining_time = __time_to_timespec(1, 0, 0, 0, 0, 0);\n");

   478

      s4o.print(s4o.indent_spaces);

   479

      print_variable_prefix();

   480

      s4o.print("action_list[i].set = 1;\n");

   481

      s4o.indent_left();

   482

      s4o.print(s4o.indent_spaces + "}\n");

   483

      s4o.indent_left();

   484

      s4o.print(s4o.indent_spaces + "}\n");

   485

      s4o.print(s4o.indent_spaces + "if (");

   486

      print_variable_prefix();

   487

      s4o.print("__compare_timespec(>, action_list[i].reset_remaining_time, __time_to_timespec(1, 0, 0, 0, 0, 0)) {\n");

   488

      s4o.indent_right();

   489

      s4o.print(s4o.indent_spaces);

   490

      print_variable_prefix();

   491

      s4o.print("action_list[i].reset_remaining_time = __sub_timespec(");

   492

      print_variable_prefix();

   493

      s4o.print("action_list[i].reset_remaining_time, PERIOD);\n");

   494

      s4o.print(s4o.indent_spaces + "if (");

   495

      print_variable_prefix();

   496

      s4o.print("__compare_timespec(<=, action_list[i].reset_remaining_time, __time_to_timespec(1, 0, 0, 0, 0, 0)) {\n");

   497

      s4o.indent_right();

   498

      s4o.print(s4o.indent_spaces);

   499

      print_variable_prefix();

   500

      s4o.print("action_list[i].reset_remaining_time = __time_to_timespec(1, 0, 0, 0, 0, 0);\n");

   501

      s4o.print(s4o.indent_spaces);

   502

      print_variable_prefix();

   503

      s4o.print("action_list[i].reset = 1;\n");

   504

      s4o.indent_left();

   505

      s4o.print(s4o.indent_spaces + "}\n");

   506

      s4o.indent_left();

   507

      s4o.print(s4o.indent_spaces + "}\n");

   508

      s4o.indent_left();

   509

      s4o.print(s4o.indent_spaces + "}\n\n");

   510

   511

      /* generate transition tests */

   512

      s4o.print(s4o.indent_spaces + "// Transitions fire test\n");

   513

      symbol->accept(*generate_cc_sfc_transitiontest);

   514

      s4o.print("\n");

   515

   516

       /* generate step association */

   517

      s4o.print(s4o.indent_spaces + "// Steps association\n");

   518

      symbol->accept(*generate_cc_sfc_stepassociation);

   519

      s4o.print("\n");

   520

   521

      /* generate action state evaluation */

   522

      s4o.print(s4o.indent_spaces + "// Actions state evaluation\n");

   523

      s4o.print(s4o.indent_spaces + "for (i = 0; i < ");

   524

      print_variable_prefix();

   525

      s4o.print("nb_actions; i++) {\n");

   526

      s4o.indent_right();

   527

      s4o.print(s4o.indent_spaces + "if (");

   528

      print_variable_prefix();

   529

      s4o.print("action_list[i].set) {\n");

   530

      s4o.indent_right();