src/PseudoAxis/PseudoAxis.cpp

   1 //===================================================================
   2 //
   3 //      The following table gives the correspondence
   4 //      between commands and method name.
   5 //
   6 //  Command name                 |  Method name
   7 //      ----------------------------------------
   8 //  State                        |  dev_state()
   9 //  Status                       |  dev_status()
  10 //  Stop                         |  stop()
  11 //  MotorOFF                     |  motor_off()
  12 //  MotorON                      |  motor_on()
  13 //  MotorInit                    |  motor_init()
  14 //  ComputeNewOffset             |  compute_new_offset()
  15 //  Backward                     |  backward()
  16 //  Forward                      |  forward()
  17 //  DefinePosition               |  define_position()
  18 //  InitializeReferencePosition  |  initialize_reference_position()
  19 //  GetModeParameters            |  get_mode_parameters()
  20 //  SetModeParameters            |  set_mode_parameters()
  21 //
  22 //===================================================================
  23
  24 #if defined (WIN32)
  25 #include <PseudoAxis.h>
  26 #include <PseudoAxisClass.h>
  27 #include <PogoHelper.h>
  28 #include <tango.h>
  29 #include <TangoExceptionsHelper.h>
  30 #else
  31 #include <tango.h>
  32 #include <TangoExceptionsHelper.h>
  33 #include <PseudoAxis.h>
  34 #include <PseudoAxisClass.h>
  35 #include <PogoHelper.h>
  36 #endif
  37
  38 #include <DeviceProxyHelper.h>
  39
  40 #include <hkl/hkl-pseudoaxis.h>
  41
  42 #include "macros.h"
  43 #include "PseudoAxis.h"
  44 #include "PseudoAxisClass.h"
  45 #include "TangoHKLAdapterFactory.h"
  46
  47 namespace PseudoAxis_ns
  48 {
  49
  50         //+----------------------------------------------------------------------------
  51         //
  52         // method :             PseudoAxis::PseudoAxis(string &s)
  53         //
  54         // description :        constructor for simulated PseudoAxis
  55         //
  56         // in : - cl : Pointer to the DeviceClass object
  57         //      - s : Device name
  58         //
  59         //-----------------------------------------------------------------------------
  60         PseudoAxis::PseudoAxis(Tango::DeviceClass *cl,string &s)
  61                 :Tango::Device_3Impl(cl,s.c_str())
  62                 {
  63                         init_device();
  64                 }
  65
  66         PseudoAxis::PseudoAxis(Tango::DeviceClass *cl,const char *s)
  67                 :Tango::Device_3Impl(cl,s)
  68                 {
  69                         init_device();
  70                 }
  71
  72         PseudoAxis::PseudoAxis(Tango::DeviceClass *cl,const char *s,const char *d)
  73                 :Tango::Device_3Impl(cl,s,d)
  74                 {
  75                         init_device();
  76                 }
  77         //+----------------------------------------------------------------------------
  78         //
  79         // method :             PseudoAxis::delete_device()
  80         //
  81         // description :        will be called at device destruction or at init command.
  82         //
  83         //-----------------------------------------------------------------------------
  84         void PseudoAxis::delete_device()
  85         {
  86                 DEBUG_STREAM << "PseudoAxis::delete_device() entering... " << std::endl;
  87
  88                 DELETE_SCALAR_ATTRIBUTE(attr_position_read);
  89                 DELETE_SCALAR_ATTRIBUTE(attr_IsInitialised_read);
  90                 DELETE_SCALAR_ATTRIBUTE(attr_offset_read);
  91                 DELETE_DEVSTRING_ATTRIBUTE(attr_mode_read);
  92
  93                 _buffer = NULL;
  94                 _hklAdapter = NULL;
  95         }
  96
  97         //+----------------------------------------------------------------------------
  98         //
  99         // method :             PseudoAxis::init_device()
 100         //
 101         // description :        will be called at device initialization.
 102         //
 103         //-----------------------------------------------------------------------------
 104         void PseudoAxis::init_device()
 105         {
 106                 DEBUG_STREAM << "PseudoAxis::init_device() entering... " << std::endl;
 107
 108                 // Initialise variables to default values
 109                 //--------------------------------------------
 110                 this->get_device_property();
 111
 112                 CREATE_SCALAR_ATTRIBUTE(attr_position_read);
 113                 CREATE_SCALAR_ATTRIBUTE(attr_IsInitialised_read);
 114                 CREATE_SCALAR_ATTRIBUTE(attr_offset_read);
 115                 CREATE_DEVSTRING_ATTRIBUTE(attr_mode_read, 1, "");
 116
 117                 _buffer = NULL;
 118                 _hklAdapter = NULL;
 119         }
 120
 121         //+----------------------------------------------------------------------------
 122         //
 123         // method :             PseudoAxis::get_device_property()
 124         //
 125         // description :        Read the device properties from database.
 126         //
 127         //-----------------------------------------------------------------------------
 128         void PseudoAxis::get_device_property()
 129         {
 130                 DEBUG_STREAM << "PseudoAxis::get_device_property() entering... " << std::endl;
 131
 132                 //      Initialize your default values here (if not done with  POGO).
 133                 //------------------------------------------------------------------
 134
 135                 //      Read device properties from database.(Automatic code generation)
 136                 //------------------------------------------------------------------
 137         Tango::DbData   dev_prop;
 138         dev_prop.push_back(Tango::DbDatum("DiffractometerProxy"));
 139         dev_prop.push_back(Tango::DbDatum("PseudoAxisName"));
 140
 141         //      Call database and extract values
 142         //--------------------------------------------
 143         if (Tango::Util::instance()->_UseDb==true)
 144                 get_db_device()->get_property(dev_prop);
 145         Tango::DbDatum  def_prop, cl_prop;
 146         PseudoAxisClass *ds_class =
 147                 (static_cast<PseudoAxisClass *>(get_device_class()));
 148         int     i = -1;
 149
 150         //      Try to initialize DiffractometerProxy from class property
 151         cl_prop = ds_class->get_class_property(dev_prop[++i].name);
 152         if (cl_prop.is_empty()==false)  cl_prop  >>  diffractometerProxy;
 153         else {
 154                 //      Try to initialize DiffractometerProxy from default device value
 155                 def_prop = ds_class->get_default_device_property(dev_prop[i].name);
 156                 if (def_prop.is_empty()==false) def_prop  >>  diffractometerProxy;
 157         }
 158         //      And try to extract DiffractometerProxy value from database
 159         if (dev_prop[i].is_empty()==false)      dev_prop[i]  >>  diffractometerProxy;
 160
 161         //      Try to initialize PseudoAxisName from class property
 162         cl_prop = ds_class->get_class_property(dev_prop[++i].name);
 163         if (cl_prop.is_empty()==false)  cl_prop  >>  pseudoAxisName;
 164         else {
 165                 //      Try to initialize PseudoAxisName from default device value
 166                 def_prop = ds_class->get_default_device_property(dev_prop[i].name);
 167                 if (def_prop.is_empty()==false) def_prop  >>  pseudoAxisName;
 168         }
 169         //      And try to extract PseudoAxisName value from database
 170         if (dev_prop[i].is_empty()==false)      dev_prop[i]  >>  pseudoAxisName;
 171
 172
 173
 174                 //      End of Automatic code generation
 175                 //------------------------------------------------------------------
 176
 177         }
 178
 179
 180         //+------------------------------------------------------------------
 181         /**
 182          *        method: PseudoAxe::dev_state
 183          *
 184          *        description:    method to execute "State"
 185          *        This command gets the device state (stored in its <i>device_state</i> data member) and returns it to the caller.
 186          *
 187          * @return        State Code
 188          *
 189          * TODO to Adapter
 190          *
 191          */
 192         //+------------------------------------------------------------------
 193         Tango::DevState PseudoAxis::dev_state()
 194         {
 195                 DEBUG_STREAM << "PseudoAxis::dev_state(): entering... !" << endl;
 196
 197                 Tango::DevState state;
 198                 std::string status;
 199
 200                 if (!_hklAdapter || !_buffer)
 201                         state = Tango::FAULT;
 202                 else {
 203                         _hklAdapter->update();
 204                         state = _buffer->get_state();
 205                         status = _buffer->get_status();
 206                 }
 207                 this->set_state(state);
 208                 this->set_status(status);
 209                 return this->device_state;
 210         }
 211
 212         //+------------------------------------------------------------------
 213         /**
 214          *        method: PseudoAxe::dev_status
 215          *
 216          *        description:    method to execute "Status"
 217          *        This command gets the device state (stored in its <i>device_state</i> data member) and returns it to the caller.
 218          *
 219          * @return        State Code
 220          *
 221          * TODO to Adapter
 222          *
 223          */
 224         //+------------------------------------------------------------------
 225         Tango::ConstDevString PseudoAxis::dev_status()
 226         {
 227                 DEBUG_STREAM << "PseudoAxis::dev_status(): entering... !" << endl;
 228
 229                 if (!_hklAdapter) {
 230                         this->device_state = Tango::FAULT;
 231                         if (diffractometerProxy == "")
 232                                 this->device_status = "Please set a correct \"diffractometerProxy\" propertie";
 233                         else {
 234                                 this->device_status = "The Diffractometer device " +  diffractometerProxy + " is not ready or do not existe!\n";
 235                                 this->device_status += "Please start the Diffractometer or check the \"diffractometerProxy\" Propertie";
 236                         }
 237                 } else {
 238                         if(!_buffer) {
 239                                 this->device_state = Tango::FAULT;
 240                                 if (pseudoAxisName == "")
 241                                         this->device_status = "Please set a correct \"pseudoAxisName\" : ";
 242                                 else {
 243                                         this->device_status = "Cannot find the pseudoAxe \"" + pseudoAxisName + "\" in the " + diffractometerProxy + " Diffractometer device : ";
 244                                 }
 245                                 this->device_status += "Set \"pseudoAxisName\" propertie with one of these possible values : ";
 246                                 std::vector<std::string> const names = _hklAdapter->pseudo_axis_get_names();
 247                                 std::vector<std::string>::const_iterator iter = names.begin();
 248                                 std::vector<std::string>::const_iterator end = names.end();
 249                                 this->device_status += " " + *iter;
 250                                 ++iter;
 251                                 while(iter != end) {
 252                                         this->device_status += ", " + *iter;
 253                                         ++iter;
 254                                 }
 255                         } else {
 256                                 try
 257                                 {
 258                                         _hklAdapter->update();
 259                                         this->device_state = _buffer->get_state();
 260                                         this->device_status = _buffer->get_status();
 261                                 }
 262                                 catch (...)
 263                                 {
 264                                         this->device_state = Tango::FAULT;
 265                                         this->device_status = " One motor Device does not respond ";
 266                                 }
 267                         }
 268                 }
 269                 return this->device_status.c_str();
 270         }
 271
 272 //+----------------------------------------------------------------------------
 273 //
 274 // method :             PseudoAxis::always_executed_hook()
 275 //
 276 // description :        method always executed before any command is executed
 277 //
 278 //-----------------------------------------------------------------------------
 279 void PseudoAxis::always_executed_hook()
 280 {
 281         DEBUG_STREAM << "PseudoAxis::always_executed_hook() entering... " << std::endl;
 282         // here we are looking for the intance of the related Diffractometer to get the right hkladapter instance.
 283         if(!_hklAdapter)
 284                 _hklAdapter = Diffractometer_ns::TangoHKLAdapterFactory::instance()->get_diffractometer_adapter(diffractometerProxy);
 285
 286         if(_hklAdapter && !_buffer)
 287                 _buffer = _hklAdapter->pseudo_axis_buffer_new(pseudoAxisName.c_str());
 288 }
 289
 290 //+----------------------------------------------------------------------------
 291 //
 292 // method :             PseudoAxis::read_attr_hardware
 293 //
 294 // description :        Hardware acquisition for attributes.
 295 //
 296 //-----------------------------------------------------------------------------
 297 void PseudoAxis::read_attr_hardware(vector<long> &attr_list)
 298 {
 299         DEBUG_STREAM << "PseudoAxis::read_attr_hardware(vector<long> &attr_list) entering... "<< endl;
 300         //      Add your own code here
 301 }
 302 //+----------------------------------------------------------------------------
 303 //
 304 // method :             PseudoAxis::read_mode
 305 //
 306 // description :        Extract real attribute values for mode acquisition result.
 307 //
 308 //-----------------------------------------------------------------------------
 309 void PseudoAxis::read_mode(Tango::Attribute &attr)
 310 {
 311         DEBUG_STREAM << "PseudoAxis::read_mode(Tango::Attribute &attr) entering... "<< endl;
 312
 313         if(_buffer)
 314                 attr.set_value(_buffer->get_mode());
 315 }
 316
 317 //+----------------------------------------------------------------------------
 318 //
 319 // method :             PseudoAxis::write_mode
 320 //
 321 // description :        Write mode attribute values to hardware.
 322 //
 323 //-----------------------------------------------------------------------------
 324 void PseudoAxis::write_mode(Tango::WAttribute &attr)
 325 {
 326         DEBUG_STREAM << "PseudoAxis::write_mode(Tango::WAttribute &attr) entering... "<< endl;
 327         attr.get_write_value(attr_mode_write);
 328         if(_buffer)
 329                 _buffer->set_mode(attr_mode_write);
 330 }
 331
 332 //+----------------------------------------------------------------------------
 333 //
 334 // method :             PseudoAxis::read_modeNames
 335 //
 336 // description :        Extract real attribute values for modeNames acquisition result.
 337 //
 338 //-----------------------------------------------------------------------------
 339 void PseudoAxis::read_modeNames(Tango::Attribute &attr)
 340 {
 341         DEBUG_STREAM << "PseudoAxis::read_modeNames(Tango::Attribute &attr) entering... "<< endl;
 342         if(_buffer){
 343                 Matrix<char *> const & img = _buffer->get_mode_names();
 344                 attr.set_value(img.data, img.xdim);
 345         }
 346 }
 347
 348 //+----------------------------------------------------------------------------
 349 //
 350 // method :             PseudoAxis::write_IsInitialised
 351 //
 352 // description :        Write IsInitialised attribute values to hardware.
 353 //
 354 //-----------------------------------------------------------------------------
 355 void PseudoAxis::write_IsInitialised(Tango::WAttribute &attr)
 356 {
 357         DEBUG_STREAM << "PseudoAxis::write_IsInitialised(Tango::WAttribute &attr) entering... "<< endl;
 358         //      Add your own code here
 359         attr.get_write_value(attr_IsInitialised_write);
 360         if(_buffer)
 361                 _buffer->set_is_initialised(attr_IsInitialised_write);
 362
 363         // need to after the internals before initializing the pseudo
 364         if (_hklAdapter)
 365                 _hklAdapter->update();
 366 }
 367
 368
 369 //+----------------------------------------------------------------------------
 370 //
 371 // method :             PseudoAxis::read_position
 372 //
 373 // description :        Extract real attribute values for position acquisition result.
 374 //
 375 //-----------------------------------------------------------------------------
 376 void PseudoAxis::read_position(Tango::Attribute &attr)
 377 {
 378         DEBUG_STREAM << "PseudoAxis::read_position(Tango::Attribute &attr) entering... "<< endl;
 379         //      Add your own code here
 380
 381         if (_hklAdapter && _buffer) {
 382                 _hklAdapter->update();
 383
 384                 // first the read part
 385                 *attr_position_read = _buffer->get_read();
 386                 *attr_position_read += *attr_offset_read;
 387                 // second the write part
 388                 attr_position_write = _buffer->get_write();
 389                 attr_position_write += *attr_offset_read;
 390                 // now use Tango to aknowledge for the write part.
 391                 Tango::WAttribute & att = dev_attr->get_w_attr_by_name(attr.get_name().c_str());
 392                 att.set_write_value(attr_position_write);
 393         }
 394         attr.set_value(attr_position_read);
 395 }
 396
 397 //+----------------------------------------------------------------------------
 398 //
 399 // method :             PseudoAxis::write_position
 400 //
 401 // description :        Write position attribute values to hardware.
 402 //
 403 //-----------------------------------------------------------------------------
 404 void PseudoAxis::write_position(Tango::WAttribute &attr)
 405 {
 406         DEBUG_STREAM << "PseudoAxis::write_position(Tango::WAttribute &attr) entering... "<< endl;
 407         //      Add your own code here
 408
 409         attr.get_write_value(attr_position_write);
 410         if (_hklAdapter && _buffer)
 411                 _hklAdapter->pseudo_axis_write(_buffer, attr_position_write - *attr_offset_read);
 412 }
 413
 414 //+----------------------------------------------------------------------------
 415 //
 416 // method :             PseudoAxis::read_offset
 417 //
 418 // description :        Extract real attribute values for offset acquisition result.
 419 //
 420 //-----------------------------------------------------------------------------
 421 void PseudoAxis::read_offset(Tango::Attribute &attr)
 422 {
 423         DEBUG_STREAM << "PseudoAxis::read_offset(Tango::Attribute &attr) entering... "<< endl;
 424         //      Add your own code here
 425         attr.set_value(attr_offset_read);
 426 }
 427
 428 //+----------------------------------------------------------------------------
 429 //
 430 // method :             PseudoAxis::write_offset
 431 //
 432 // description :        Write offset attribute values to hardware.
 433 //
 434 //-----------------------------------------------------------------------------
 435 void PseudoAxis::write_offset(Tango::WAttribute &attr)
 436 {
 437         DEBUG_STREAM << "PseudoAxis::write_offset(Tango::WAttribute &attr) entering... "<< endl;
 438         //      Add your own code here
 439         attr.get_write_value(attr_offset_write);
 440         *attr_offset_read = attr_offset_write;
 441 }
 442
 443 //+----------------------------------------------------------------------------
 444 //
 445 // method :             PseudoAxis::read_relativeMove
 446 //
 447 // description :        Extract real attribute values for relativeMove acquisition result.
 448 //
 449 //-----------------------------------------------------------------------------
 450 void PseudoAxis::read_relativeMove(Tango::Attribute &attr)
 451 {
 452         DEBUG_STREAM << "PseudoAxis::read_relativeMove(Tango::Attribute &attr) entering... "<< endl;
 453         //      Add your own code here
 454         attr.set_value(&attr_relativeMove_write);
 455 }
 456
 457 //+----------------------------------------------------------------------------
 458 //
 459 // method :             PseudoAxis::write_relativeMove
 460 //
 461 // description :        Write relativeMove attribute values to hardware.
 462 //
 463 //-----------------------------------------------------------------------------
 464 void PseudoAxis::write_relativeMove(Tango::WAttribute &attr)
 465 {
 466         DEBUG_STREAM << "PseudoAxis::write_relativeMove(Tango::WAttribute &attr) entering... "<< endl;
 467         //      Add your own code here
 468         attr.get_write_value(attr_relativeMove_write);
 469         double new_position = *attr_position_read + attr_relativeMove_write;
 470
 471         // Write to the "position" attribute to move the axe.
 472         Tango::DeviceProxyHelper moi(this->device_name, this);
 473         moi.write_attribute("position", new_position);
 474 }
 475
 476
 477 //+----------------------------------------------------------------------------
 478 //
 479 // method :             PseudoAxis::read_IsInitialised
 480 //
 481 // description :        Extract real attribute values for IsInitialised acquisition result.
 482 //
 483 //-----------------------------------------------------------------------------
 484 void PseudoAxis::read_IsInitialised(Tango::Attribute &attr)
 485 {
 486         DEBUG_STREAM << "PseudoAxis::read_IsInitialised(Tango::Attribute &attr) entering... "<< endl;
 487         //      Add your own code here
 488
 489         if(_buffer)
 490                 *attr_IsInitialised_read = _buffer->get_is_initialised();
 491         attr.set_value(attr_IsInitialised_read);
 492 }
 493
 494 //+------------------------------------------------------------------
 495 /**
 496  *      method: PseudoAxis::motor_off
 497  *
 498  *      description:    method to execute "MotorOFF"
 499  *      Disable the pseudoAxis.
 500  *
 501  *
 502  */
 503 //+------------------------------------------------------------------
 504 void PseudoAxis::motor_off()
 505 {
 506         DEBUG_STREAM << "PseudoAxis::motor_off(): entering... !" << endl;
 507
 508         //      Add your own code to control device here
 509 }
 510
 511 //+------------------------------------------------------------------
 512 /**
 513  *      method: PseudoAxis::motor_on
 514  *
 515  *      description:    method to execute "MotorON"
 516  *      Activate the pseudoAxis
 517  *
 518  *
 519  */
 520 //+------------------------------------------------------------------
 521 void PseudoAxis::motor_on()
 522 {
 523         DEBUG_STREAM << "PseudoAxis::motor_on(): entering... !" << endl;
 524
 525         //      Add your own code to control device here
 526         if(_buffer)
 527                 _buffer->on();
 528 }
 529
 530 //+------------------------------------------------------------------
 531 /**
 532  *      method: PseudoAxis::compute_new_offset
 533  *
 534  *      description:    method to execute "ComputeNewOffset"
 535  *      The so smart program computes the offset to goal the user position.
 536  *
 537  * @param       argin   The new user position
 538  *
 539  */
 540 //+------------------------------------------------------------------
 541 void PseudoAxis::compute_new_offset(Tango::DevDouble argin)
 542 {
 543         DEBUG_STREAM << "PseudoAxis::compute_new_offset(): entering... !" << endl;
 544
 545         //      Add your own code to control device here
 546         if (_hklAdapter && _buffer) {
 547                 _hklAdapter->update();
 548                 Tango::DeviceProxyHelper moi(this->device_name, this);
 549                 moi.write_attribute("offset", argin - _buffer->get_read());
 550         }
 551 }
 552
 553 //+------------------------------------------------------------------
 554 /**
 555  *      method: PseudoAxis::stop
 556  *
 557  *      description:    method to execute "Stop"
 558  *      Stop the pseudoAxes and all related axes.
 559  *
 560  *
 561  */
 562 //+------------------------------------------------------------------
 563 void PseudoAxis::stop()
 564 {
 565         DEBUG_STREAM << "PseudoAxis::stop(): entering... !" << endl;
 566
 567         //      Add your own code to control device here
 568         // FRED here use the _pseudoAxe->relatedAxes to stop the right axes.
 569         _hklAdapter->stop_all_axis();
 570
 571 }
 572
 573 //+------------------------------------------------------------------
 574 /**
 575  *      method: PseudoAxis::motor_init
 576  *
 577  *      description:    method to execute "MotorInit"
 578  *      Some pseudoAxis must be initialized before we can used them.
 579  *
 580  *
 581  */
 582 //+------------------------------------------------------------------
 583 void PseudoAxis::motor_init()
 584 {
 585         DEBUG_STREAM << "PseudoAxis::motor_init(): entering... !" << endl;
 586
 587         // DEPRECATED
 588         //      Add your own code to control device here
 589         if (_buffer)
 590                 _buffer->set_is_initialised(true);
 591         if(_hklAdapter)
 592                 _hklAdapter->update();
 593 }
 594
 595 //+------------------------------------------------------------------
 596 /**
 597  *      method: PseudoAxis::backward
 598  *
 599  *      description:    method to execute "Backward"
 600  *      dummy command for V2 interface
 601  *
 602  *
 603  */
 604 //+------------------------------------------------------------------
 605 void PseudoAxis::backward()
 606 {
 607         DEBUG_STREAM << "PseudoAxis::backward(): entering... !" << endl;
 608
 609         //      Add your own code to control device here
 610
 611 }
 612
 613 //+------------------------------------------------------------------
 614 /**
 615  *      method: PseudoAxis::forward
 616  *
 617  *      description:    method to execute "Forward"
 618  *      dummy command for V2 interface
 619  *
 620  *
 621  */
 622 //+------------------------------------------------------------------
 623 void PseudoAxis::forward()
 624 {
 625         DEBUG_STREAM << "PseudoAxis::forward(): entering... !" << endl;
 626
 627         //      Add your own code to control device here
 628
 629 }
 630
 631 //+------------------------------------------------------------------
 632 /**
 633  *      method: PseudoAxis::define_position
 634  *
 635  *      description:    method to execute "DefinePosition"
 636  *      dummy command for V2 interface
 637  *
 638  * @param       argin
 639  *
 640  */
 641 //+------------------------------------------------------------------
 642 void PseudoAxis::define_position(Tango::DevDouble argin)
 643 {
 644         DEBUG_STREAM << "PseudoAxis::define_position(): entering... !" << endl;
 645
 646         //      Add your own code to control device here
 647
 648 }
 649
 650 //+------------------------------------------------------------------
 651 /**
 652  *      method: PseudoAxis::initialize_reference_position
 653  *
 654  *      description:    method to execute "InitializeReferencePosition"
 655  *      dummy command for V2 interface
 656  *
 657  *
 658  */
 659 //+------------------------------------------------------------------
 660 void PseudoAxis::initialize_reference_position()
 661 {
 662         DEBUG_STREAM << "PseudoAxis::initialize_reference_position(): entering... !" << endl;
 663
 664         //      Add your own code to control device here
 665
 666 }
 667
 668
 669 //+------------------------------------------------------------------
 670 /**
 671  *      method: PseudoAxis::get_mode_parameters
 672  *
 673  *      description:    method to execute "GetModeParameters"
 674  *      this command return for the current mode, its parameters.
 675  *
 676  * @return      parameters names and values
 677  *
 678  */
 679 //+------------------------------------------------------------------
 680 Tango::DevVarDoubleStringArray *PseudoAxis::get_mode_parameters()
 681 {
 682         //      POGO has generated a method core with argout allocation.
 683         //      If you would like to use a static reference without copying,
 684         //      See "TANGO Device Server Programmer's Manual"
 685         //              (chapter : Writing a TANGO DS / Exchanging data)
 686         //------------------------------------------------------------
 687         Tango::DevVarDoubleStringArray  *argout  = new Tango::DevVarDoubleStringArray();
 688         argout->dvalue.length(1);
 689         argout->dvalue[0] = 0.0;
 690         argout->svalue.length(1);
 691         argout->svalue[0] = CORBA::string_dup("dummy");
 692         DEBUG_STREAM << "PseudoAxis::get_mode_parameters(): entering... !" << endl;
 693
 694         //      Add your own code to control device here
 695         if(_buffer)
 696                 _buffer->get_mode_parameters(argout);
 697
 698         return argout;
 699 }
 700
 701 //+------------------------------------------------------------------
 702 /**
 703  *      method: PseudoAxis::set_mode_parameters
 704  *
 705  *      description:    method to execute "SetModeParameters"
 706  *
 707  * @param       argin   The parameters to set
 708  *
 709  */
 710 //+------------------------------------------------------------------
 711 void PseudoAxis::set_mode_parameters(const Tango::DevVarDoubleStringArray *argin)
 712 {
 713         DEBUG_STREAM << "PseudoAxis::set_mode_parameters(): entering... !" << endl;
 714
 715         //      Add your own code to control device here
 716         if(_buffer)
 717                 _buffer->set_mode_parameters(argin);
 718
 719 }
 720
 721 }       //      namespace