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         attr.set_value(_buffer->get_mode());
 314 }
 315
 316 //+----------------------------------------------------------------------------
 317 //
 318 // method :             PseudoAxis::write_mode
 319 //
 320 // description :        Write mode attribute values to hardware.
 321 //
 322 //-----------------------------------------------------------------------------
 323 void PseudoAxis::write_mode(Tango::WAttribute &attr)
 324 {
 325         DEBUG_STREAM << "PseudoAxis::write_mode(Tango::WAttribute &attr) entering... "<< endl;
 326         attr.get_write_value(attr_mode_write);
 327         if(_buffer)
 328                 _buffer->set_mode(attr_mode_write);
 329 }
 330
 331 //+----------------------------------------------------------------------------
 332 //
 333 // method :             PseudoAxis::read_modeNames
 334 //
 335 // description :        Extract real attribute values for modeNames acquisition result.
 336 //
 337 //-----------------------------------------------------------------------------
 338 void PseudoAxis::read_modeNames(Tango::Attribute &attr)
 339 {
 340         DEBUG_STREAM << "PseudoAxis::read_modeNames(Tango::Attribute &attr) entering... "<< endl;
 341         if(_buffer){
 342                 Matrix<char *> const & img = _buffer->get_mode_names();
 343                 attr.set_value(img.data, img.xdim);
 344         }
 345 }
 346
 347 //+----------------------------------------------------------------------------
 348 //
 349 // method :             PseudoAxis::write_IsInitialised
 350 //
 351 // description :        Write IsInitialised attribute values to hardware.
 352 //
 353 //-----------------------------------------------------------------------------
 354 void PseudoAxis::write_IsInitialised(Tango::WAttribute &attr)
 355 {
 356         DEBUG_STREAM << "PseudoAxis::write_IsInitialised(Tango::WAttribute &attr) entering... "<< endl;
 357         //      Add your own code here
 358         attr.get_write_value(attr_IsInitialised_write);
 359
 360         // need to update the internals before initializing the pseudo
 361         if (_hklAdapter)
 362                 _hklAdapter->update();
 363         if (_buffer){
 364                 _hklAdapter->pseudo_axis_init(_buffer, attr_IsInitialised_write);
 365                 _hklAdapter->update();
 366         }
 367 }
 368
 369
 370 //+----------------------------------------------------------------------------
 371 //
 372 // method :             PseudoAxis::read_position
 373 //
 374 // description :        Extract real attribute values for position acquisition result.
 375 //
 376 //-----------------------------------------------------------------------------
 377 void PseudoAxis::read_position(Tango::Attribute &attr)
 378 {
 379         DEBUG_STREAM << "PseudoAxis::read_position(Tango::Attribute &attr) entering... "<< endl;
 380         //      Add your own code here
 381
 382         if (_hklAdapter && _buffer) {
 383                 _hklAdapter->update();
 384
 385                 // first the read part
 386                 *attr_position_read = _buffer->get_read();
 387                 *attr_position_read += *attr_offset_read;
 388                 // second the write part
 389                 attr_position_write = _buffer->get_write();
 390                 attr_position_write += *attr_offset_read;
 391                 // now use Tango to aknowledge for the write part.
 392                 Tango::WAttribute & att = dev_attr->get_w_attr_by_name(attr.get_name().c_str());
 393                 att.set_write_value(attr_position_write);
 394         }
 395         attr.set_value(attr_position_read);
 396 }
 397
 398 //+----------------------------------------------------------------------------
 399 //
 400 // method :             PseudoAxis::write_position
 401 //
 402 // description :        Write position attribute values to hardware.
 403 //
 404 //-----------------------------------------------------------------------------
 405 void PseudoAxis::write_position(Tango::WAttribute &attr)
 406 {
 407         DEBUG_STREAM << "PseudoAxis::write_position(Tango::WAttribute &attr) entering... "<< endl;
 408         //      Add your own code here
 409
 410         attr.get_write_value(attr_position_write);
 411         if (_hklAdapter && _buffer)
 412                 _hklAdapter->pseudo_axis_write(_buffer, attr_position_write - *attr_offset_read);
 413 }
 414
 415 //+----------------------------------------------------------------------------
 416 //
 417 // method :             PseudoAxis::read_offset
 418 //
 419 // description :        Extract real attribute values for offset acquisition result.
 420 //
 421 //-----------------------------------------------------------------------------
 422 void PseudoAxis::read_offset(Tango::Attribute &attr)
 423 {
 424         DEBUG_STREAM << "PseudoAxis::read_offset(Tango::Attribute &attr) entering... "<< endl;
 425         //      Add your own code here
 426         attr.set_value(attr_offset_read);
 427 }
 428
 429 //+----------------------------------------------------------------------------
 430 //
 431 // method :             PseudoAxis::write_offset
 432 //
 433 // description :        Write offset attribute values to hardware.
 434 //
 435 //-----------------------------------------------------------------------------
 436 void PseudoAxis::write_offset(Tango::WAttribute &attr)
 437 {
 438         DEBUG_STREAM << "PseudoAxis::write_offset(Tango::WAttribute &attr) entering... "<< endl;
 439         //      Add your own code here
 440         attr.get_write_value(attr_offset_write);
 441         *attr_offset_read = attr_offset_write;
 442 }
 443
 444 //+----------------------------------------------------------------------------
 445 //
 446 // method :             PseudoAxis::read_relativeMove
 447 //
 448 // description :        Extract real attribute values for relativeMove acquisition result.
 449 //
 450 //-----------------------------------------------------------------------------
 451 void PseudoAxis::read_relativeMove(Tango::Attribute &attr)
 452 {
 453         DEBUG_STREAM << "PseudoAxis::read_relativeMove(Tango::Attribute &attr) entering... "<< endl;
 454         //      Add your own code here
 455         attr.set_value(&attr_relativeMove_write);
 456 }
 457
 458 //+----------------------------------------------------------------------------
 459 //
 460 // method :             PseudoAxis::write_relativeMove
 461 //
 462 // description :        Write relativeMove attribute values to hardware.
 463 //
 464 //-----------------------------------------------------------------------------
 465 void PseudoAxis::write_relativeMove(Tango::WAttribute &attr)
 466 {
 467         DEBUG_STREAM << "PseudoAxis::write_relativeMove(Tango::WAttribute &attr) entering... "<< endl;
 468         //      Add your own code here
 469         attr.get_write_value(attr_relativeMove_write);
 470         double new_position = *attr_position_read + attr_relativeMove_write;
 471
 472         // Write to the "position" attribute to move the axe.
 473         Tango::DeviceProxyHelper moi(this->device_name, this);
 474         moi.write_attribute("position", new_position);
 475 }
 476
 477
 478 //+----------------------------------------------------------------------------
 479 //
 480 // method :             PseudoAxis::read_IsInitialised
 481 //
 482 // description :        Extract real attribute values for IsInitialised acquisition result.
 483 //
 484 //-----------------------------------------------------------------------------
 485 void PseudoAxis::read_IsInitialised(Tango::Attribute &attr)
 486 {
 487         DEBUG_STREAM << "PseudoAxis::read_IsInitialised(Tango::Attribute &attr) entering... "<< endl;
 488         //      Add your own code here
 489
 490         attr.set_value(attr_IsInitialised_read);
 491 }
 492
 493 //+------------------------------------------------------------------
 494 /**
 495  *      method: PseudoAxis::motor_off
 496  *
 497  *      description:    method to execute "MotorOFF"
 498  *      Disable the pseudoAxis.
 499  *
 500  *
 501  */
 502 //+------------------------------------------------------------------
 503 void PseudoAxis::motor_off()
 504 {
 505         DEBUG_STREAM << "PseudoAxis::motor_off(): entering... !" << endl;
 506
 507         //      Add your own code to control device here
 508 }
 509
 510 //+------------------------------------------------------------------
 511 /**
 512  *      method: PseudoAxis::motor_on
 513  *
 514  *      description:    method to execute "MotorON"
 515  *      Activate the pseudoAxis
 516  *
 517  *
 518  */
 519 //+------------------------------------------------------------------
 520 void PseudoAxis::motor_on()
 521 {
 522         DEBUG_STREAM << "PseudoAxis::motor_on(): entering... !" << endl;
 523
 524         //      Add your own code to control device here
 525         if (_hklAdapter)
 526                 _hklAdapter->update();
 527         if (_buffer){
 528                 _hklAdapter->pseudo_axis_init(_buffer, true);
 529                 // idem initialize
 530                 _hklAdapter->update();
 531         }
 532 }
 533
 534 //+------------------------------------------------------------------
 535 /**
 536  *      method: PseudoAxis::compute_new_offset
 537  *
 538  *      description:    method to execute "ComputeNewOffset"
 539  *      The so smart program computes the offset to goal the user position.
 540  *
 541  * @param       argin   The new user position
 542  *
 543  */
 544 //+------------------------------------------------------------------
 545 void PseudoAxis::compute_new_offset(Tango::DevDouble argin)
 546 {
 547         DEBUG_STREAM << "PseudoAxis::compute_new_offset(): entering... !" << endl;
 548
 549         //      Add your own code to control device here
 550         if (_hklAdapter && _buffer) {
 551                 _hklAdapter->update();
 552                 Tango::DeviceProxyHelper moi(this->device_name, this);
 553                 moi.write_attribute("offset", argin - _buffer->get_read());
 554         }
 555 }
 556
 557 //+------------------------------------------------------------------
 558 /**
 559  *      method: PseudoAxis::stop
 560  *
 561  *      description:    method to execute "Stop"
 562  *      Stop the pseudoAxes and all related axes.
 563  *
 564  *
 565  */
 566 //+------------------------------------------------------------------
 567 void PseudoAxis::stop()
 568 {
 569         DEBUG_STREAM << "PseudoAxis::stop(): entering... !" << endl;
 570
 571         //      Add your own code to control device here
 572         // FRED here use the _pseudoAxe->relatedAxes to stop the right axes.
 573         _hklAdapter->stop_all_axis();
 574
 575 }
 576
 577 //+------------------------------------------------------------------
 578 /**
 579  *      method: PseudoAxis::motor_init
 580  *
 581  *      description:    method to execute "MotorInit"
 582  *      Some pseudoAxis must be initialized before we can used them.
 583  *
 584  *
 585  */
 586 //+------------------------------------------------------------------
 587 void PseudoAxis::motor_init()
 588 {
 589         DEBUG_STREAM << "PseudoAxis::motor_init(): entering... !" << endl;
 590
 591         //      Add your own code to control device here
 592         if (_hklAdapter)
 593                 _hklAdapter->update();
 594
 595         if (_buffer) {
 596                 _hklAdapter->pseudo_axis_init(_buffer, true);
 597                 _hklAdapter->update();
 598         }
 599
 600 }
 601
 602 //+------------------------------------------------------------------
 603 /**
 604  *      method: PseudoAxis::backward
 605  *
 606  *      description:    method to execute "Backward"
 607  *      dummy command for V2 interface
 608  *
 609  *
 610  */
 611 //+------------------------------------------------------------------
 612 void PseudoAxis::backward()
 613 {
 614         DEBUG_STREAM << "PseudoAxis::backward(): entering... !" << endl;
 615
 616         //      Add your own code to control device here
 617
 618 }
 619
 620 //+------------------------------------------------------------------
 621 /**
 622  *      method: PseudoAxis::forward
 623  *
 624  *      description:    method to execute "Forward"
 625  *      dummy command for V2 interface
 626  *
 627  *
 628  */
 629 //+------------------------------------------------------------------
 630 void PseudoAxis::forward()
 631 {
 632         DEBUG_STREAM << "PseudoAxis::forward(): entering... !" << endl;
 633
 634         //      Add your own code to control device here
 635
 636 }
 637
 638 //+------------------------------------------------------------------
 639 /**
 640  *      method: PseudoAxis::define_position
 641  *
 642  *      description:    method to execute "DefinePosition"
 643  *      dummy command for V2 interface
 644  *
 645  * @param       argin
 646  *
 647  */
 648 //+------------------------------------------------------------------
 649 void PseudoAxis::define_position(Tango::DevDouble argin)
 650 {
 651         DEBUG_STREAM << "PseudoAxis::define_position(): entering... !" << endl;
 652
 653         //      Add your own code to control device here
 654
 655 }
 656
 657 //+------------------------------------------------------------------
 658 /**
 659  *      method: PseudoAxis::initialize_reference_position
 660  *
 661  *      description:    method to execute "InitializeReferencePosition"
 662  *      dummy command for V2 interface
 663  *
 664  *
 665  */
 666 //+------------------------------------------------------------------
 667 void PseudoAxis::initialize_reference_position()
 668 {
 669         DEBUG_STREAM << "PseudoAxis::initialize_reference_position(): entering... !" << endl;
 670
 671         //      Add your own code to control device here
 672
 673 }
 674
 675
 676 //+------------------------------------------------------------------
 677 /**
 678  *      method: PseudoAxis::get_mode_parameters
 679  *
 680  *      description:    method to execute "GetModeParameters"
 681  *      this command return for the current mode, its parameters.
 682  *
 683  * @return      parameters names and values
 684  *
 685  */
 686 //+------------------------------------------------------------------
 687 Tango::DevVarDoubleStringArray *PseudoAxis::get_mode_parameters()
 688 {
 689         //      POGO has generated a method core with argout allocation.
 690         //      If you would like to use a static reference without copying,
 691         //      See "TANGO Device Server Programmer's Manual"
 692         //              (chapter : Writing a TANGO DS / Exchanging data)
 693         //------------------------------------------------------------
 694         Tango::DevVarDoubleStringArray  *argout  = new Tango::DevVarDoubleStringArray();
 695         argout->dvalue.length(1);
 696         argout->dvalue[0] = 0.0;
 697         argout->svalue.length(1);
 698         argout->svalue[0] = CORBA::string_dup("dummy");
 699         DEBUG_STREAM << "PseudoAxis::get_mode_parameters(): entering... !" << endl;
 700
 701         //      Add your own code to control device here
 702         if(_buffer)
 703                 _buffer->get_mode_parameters(argout);
 704
 705         return argout;
 706 }
 707
 708 //+------------------------------------------------------------------
 709 /**
 710  *      method: PseudoAxis::set_mode_parameters
 711  *
 712  *      description:    method to execute "SetModeParameters"
 713  *
 714  * @param       argin   The parameters to set
 715  *
 716  */
 717 //+------------------------------------------------------------------
 718 void PseudoAxis::set_mode_parameters(const Tango::DevVarDoubleStringArray *argin)
 719 {
 720         DEBUG_STREAM << "PseudoAxis::set_mode_parameters(): entering... !" << endl;
 721
 722         //      Add your own code to control device here
 723         if(_buffer)
 724                 _buffer->set_mode_parameters(argin);
 725
 726 }
 727
 728 }       //      namespace