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 //---------------------------------------------------------------