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