1

//---------------------------------------------------------------

     2

//

     3

//  m a i n _ g u i . c p p

     4

//

     5

//  $LastChangedDate$

     6

//  $Author$

     7

//

     8

//---------------------------------------------------------------

     9

    10

#include <stdio.h>

    11

#include <string.h> // memset()

    12

#include <unistd.h> // usleep()

    13

#include <signal.h>

    14

    15

#include <fltk/Window.h>

    16

#include <fltk/Slider.h>

    17

#include <fltk/ValueOutput.h>

    18

#include <fltk/FillSlider.h>

    19

#include <fltk/CheckButton.h>

    20

#include <fltk/run.h>

    21

using namespace fltk;

    22

    23

#include "ec_globals.h"

    24

#include "ec_master.h"

    25

    26

#define SLIDER_UPDATE_CYCLE 0.02

    27

#define VALUES_UPDATE_CYCLE 0.50

    28

    29

//---------------------------------------------------------------

    30

    31

unsigned short int write_value;

    32

signed short int read_value;

    33

unsigned char dig_value;

    34

    35

void write_data(unsigned char *);

    36

void read_data(unsigned char *);

    37

    38

void slider_write_callback(Widget *, void *);

    39

void slider_read_timeout(void *);

    40

void values_timeout(void *);

    41

    42

Window *window;

    43

Slider *slider_read, *slider_write;

    44

ValueOutput *output_cycle, *output_jitter, *output_work, *output_busy, *output_bus;

    45

CheckButton *check1, *check2, *check3, *check4;

    46

EtherCAT_master_t master;

    47

    48

double max_cycle, max_jitter, max_work, max_busy, max_bus;

    49

    50

//---------------------------------------------------------------

    51

    52

#define SLAVE_COUNT 7

    53

    54

EtherCAT_slave_t slaves[SLAVE_COUNT] =

    55

{

    56

  ECAT_INIT_SLAVE(Beckhoff_EK1100),

    57

  ECAT_INIT_SLAVE(Beckhoff_EL4102),

    58

  ECAT_INIT_SLAVE(Beckhoff_EL3162),

    59

  ECAT_INIT_SLAVE(Beckhoff_EL1014),

    60

  ECAT_INIT_SLAVE(Beckhoff_EL5001),

    61

  ECAT_INIT_SLAVE(Beckhoff_EL2004),

    62

  ECAT_INIT_SLAVE(Beckhoff_EL3102)

    63

};

    64

    65

//---------------------------------------------------------------

    66

    67

int main(int argc, char **argv)

    68

{

    69

  //unsigned int i;

    70

  EtherCAT_slave_t *buskoppler, *input, *output, *dig_in, *dig_out;

    71

  struct sched_param sched;

    72

    73

  printf("CatEther-Testprogramm.\n\n");

    74

    75

  //----------

    76

    77

#if 1

    78

  printf("Setting highest task priority...\n");

    79

    80

  sched.sched_priority = sched_get_priority_max(SCHED_RR);

    81

  if (sched_setscheduler(0, SCHED_RR, &sched) == -1)

    82

  {

    83

    fprintf(stderr, "ERROR: Could not set priority: %s\n", strerror(errno)); 

    84

    return -1;

    85

  }

    86

#endif

    87

    88

  //----------

    89

    90

  printf("Initializing master...\n");

    91

  EtherCAT_master_init(&master, "eth1");

    92

    93

  printf("Checking slaves...\n");

    94

  if (EtherCAT_check_slaves(&master, slaves, SLAVE_COUNT) != 0)

    95

  {

    96

    fprintf(stderr, "ERROR while searching for slaves!\n");

    97

    return -1;

    98

  }

    99

   100

  //----------

   101

   102

  // Check for slaves

   103

   104

  buskoppler = &slaves[0];

   105

  output = &slaves[1];

   106

  dig_in = &slaves[3];

   107

  dig_out = &slaves[5];

   108

  input = &slaves[6];

   109

   110

  // Set Mapping addresses

   111

   112

  output->logical_address0 = 0x00000000;

   113

  input->logical_address0 = 0x00000004;

   114

  dig_in->logical_address0 = 0x0000000F;

   115

  dig_out->logical_address0 = 0x0000000E;

   116

   117

  //----------

   118

   119

  printf("Init output slave...\n");

   120

   121

  if (EtherCAT_activate_slave(&master, output) != 0)

   122

  {

   123

    fprintf(stderr, "ERROR: Could not init slave!\n");

   124

    return -1;

   125

  }

   126

   127

  printf("Init input slave...\n");

   128

   129

  if (EtherCAT_activate_slave(&master, input) != 0)

   130

  {

   131

    fprintf(stderr, "ERROR: Could not init slave!\n");

   132

    return -1;

   133

  }

   134

   135

  printf("Init digital input slave...\n");

   136

   137

  if (EtherCAT_activate_slave(&master, dig_in) != 0)

   138

  {

   139

    fprintf(stderr, "ERROR: Could not init slave!\n");

   140

    return -1;

   141

  }

   142

   143

  printf("Init digital output slave...\n");

   144

   145

  if (EtherCAT_activate_slave(&master, dig_out) != 0)

   146

  {

   147

    fprintf(stderr, "ERROR: Could not init slave!\n");

   148

    return -1;

   149

  }

   150

   151

  //----------

   152

   153

  printf("Starting FLTK window...\n");

   154

   155

  window = new Window(300, 300);

   156

  window->begin();

   157

   158

  slider_read = new FillSlider(50, 10, 40, 280);

   159

  slider_read->set_vertical();

   160

  slider_read->buttoncolor(BLUE);

   161

   162

  slider_read->deactivate();

   163

   164

  slider_write = new Slider(110, 10, 40, 280);

   165

  slider_write->set_vertical();

   166

  slider_write->callback(slider_write_callback, NULL);

   167

   168

  output_cycle = new ValueOutput(200, 50, 90, 25, "Cycle time [µs]");

   169

  output_cycle->align(ALIGN_LEFT | ALIGN_TOP);

   170

   171

  output_jitter = new ValueOutput(200, 90, 90, 25, "Jitter [%]");

   172

  output_jitter->align(ALIGN_LEFT | ALIGN_TOP);

   173

   174

  output_work = new ValueOutput(200, 130, 90, 25, "Work time [µs]");

   175

  output_work->align(ALIGN_LEFT | ALIGN_TOP);

   176

   177

  output_busy = new ValueOutput(200, 170, 90, 25, "Busy rate [%]");

   178

  output_busy->align(ALIGN_LEFT | ALIGN_TOP);

   179

   180

  output_bus = new ValueOutput(200, 210, 90, 25, "Bus time [µs]");

   181

  output_bus->align(ALIGN_LEFT | ALIGN_TOP);

   182

   183

  check1 = new CheckButton(200, 240, 30, 25, "1");

   184

  check2 = new CheckButton(250, 240, 30, 25, "2");

   185

  check3 = new CheckButton(200, 270, 30, 25, "3");

   186

  check4 = new CheckButton(250, 270, 30, 25, "4");

   187

   188

  //  output_cycle = new Output(200, 35, 90, 25);

   189

   190

  window->end();

   191

  window->show();

   192

   193

  add_timeout(SLIDER_UPDATE_CYCLE, slider_read_timeout, NULL);

   194

  add_timeout(VALUES_UPDATE_CYCLE, values_timeout, NULL);

   195

   196

  printf("Starting thread...\n");

   197

   198

  if (EtherCAT_start(&master, 20, write_data, read_data, 10000) != 0)

   199

  {

   200

    return -1;

   201

  }

   202

   203

  run(); // Start FLTK loop

   204

   205

  remove_timeout(slider_read_timeout, NULL);

   206

  remove_timeout(values_timeout, NULL);

   207

   208

  printf("Stopping master thread...\n");

   209

  EtherCAT_stop(&master);

   210

   211

  printf("Deactivating slaves...\n");

   212

   213

  EtherCAT_deactivate_slave(&master, dig_out);

   214

  EtherCAT_deactivate_slave(&master, dig_in);

   215

  EtherCAT_deactivate_slave(&master, input);

   216

  EtherCAT_deactivate_slave(&master, output);

   217

  EtherCAT_deactivate_slave(&master, buskoppler);

   218

   219

  EtherCAT_master_clear(&master);

   220

   221

  printf("Finished.\n");

   222

   223

  return 0;

   224

}

   225

   226

//---------------------------------------------------------------

   227

   228

void write_data(unsigned char *data)

   229

{

   230

  data[0] = write_value & 0xFF;

   231

  data[1] = (write_value & 0xFF00) >> 8;

   232

   233

  data[14] = (write_value * 16 / 32767) & 0x0F;

   234

}

   235

   236

//---------------------------------------------------------------

   237

   238

void read_data(unsigned char *data)

   239

{

   240

  read_value = data[5] | data[6] << 8;

   241

  dig_value = data[15];

   242

}

   243

   244

//---------------------------------------------------------------

   245

   246

void slider_read_timeout(void *data)

   247

{

   248

  slider_read->value((double) read_value / 65536 + 0.5);

   249

  slider_read->redraw();

   250

   251

  check1->value(dig_value & 1);

   252

  check2->value(dig_value & 2);

   253

  check3->value(dig_value & 4);

   254

  check4->value(dig_value & 8);

   255

   256

  if (max_cycle < master.last_cycle_time) max_cycle = master.last_cycle_time;

   257

  if (max_jitter < master.last_jitter) max_jitter = master.last_jitter;

   258

  if (max_work < master.last_cycle_work_time) max_work = master.last_cycle_work_time;

   259

  if (max_busy < master.last_cycle_busy_rate) max_busy = master.last_cycle_busy_rate;

   260

  if (max_bus < master.bus_time) max_bus = master.bus_time;

   261

   262

  repeat_timeout(SLIDER_UPDATE_CYCLE, slider_read_timeout, NULL);

   263

}

   264

   265

//---------------------------------------------------------------

   266

   267

void values_timeout(void *data)

   268

{

   269

  output_cycle->value(max_cycle * 1000000.0);

   270

  output_jitter->value(max_jitter);

   271

  output_work->value(max_work * 1000000.0);

   272

  output_busy->value(max_busy);

   273

  output_bus->value(max_bus * 1000000.0);

   274

   275

  max_cycle = max_jitter = max_work = max_busy = max_bus = 0.0;

   276

   277

  repeat_timeout(VALUES_UPDATE_CYCLE, values_timeout, NULL);

   278

}

   279

   280

//---------------------------------------------------------------

   281

   282

void slider_write_callback(Widget *sender, void *data)

   283

{

   284

  write_value = (short unsigned int) (32767 * slider_write->value() + 0.5);

   285

}

   286

   287

//---------------------------------------------------------------