Skip to content
GitLab
Explore
Sign in
Register
Primary navigation
Search or go to…
Project
S
SimulatedMotor
Manage
Activity
Members
Labels
Plan
Issues
Issue boards
Milestones
Iterations
Wiki
Requirements
Code
Merge requests
Repository
Branches
Commits
Tags
Repository graph
Compare revisions
Snippets
Locked files
Build
Pipelines
Jobs
Pipeline schedules
Test cases
Artifacts
Deploy
Releases
Package registry
Container registry
Model registry
Operate
Environments
Terraform modules
Monitor
Incidents
Analyze
Value stream analytics
Contributor analytics
CI/CD analytics
Repository analytics
Code review analytics
Issue analytics
Insights
Model experiments
Help
Help
Support
GitLab documentation
Compare GitLab plans
GitLab community forum
Contribute to GitLab
Provide feedback
Keyboard shortcuts
?
Snippets
Groups
Projects
Show more breadcrumbs
Software Control System
Tango devices
Simulators
SimulatedMotor
Commits
c376bfe8
Commit
c376bfe8
authored
5 months ago
by
Florent Langlois
Browse files
Options
Downloads
Patches
Plain Diff
remove Utils lib
parent
5d76f99a
No related branches found
No related tags found
No related merge requests found
Changes
4
Show whitespace changes
Inline
Side-by-side
Showing
4 changed files
CMakeLists.txt
+0
-2
0 additions, 2 deletions
CMakeLists.txt
conanfile.py
+1
-2
1 addition, 2 deletions
conanfile.py
src/SimulatedMotor.cpp
+7
-20
7 additions, 20 deletions
src/SimulatedMotor.cpp
src/SimulatedMotor.cpp.bak
+0
-812
0 additions, 812 deletions
src/SimulatedMotor.cpp.bak
with
8 additions
and
836 deletions
CMakeLists.txt
+
0
−
2
View file @
c376bfe8
...
...
@@ -2,7 +2,6 @@ cmake_minimum_required(VERSION 3.15)
project
(
${
PROJECT_NAME
}
CXX
)
find_package
(
yat4tango CONFIG REQUIRED
)
find_package
(
utils CONFIG REQUIRED
)
if
(
NOT CMAKE_SYSTEM_NAME STREQUAL
"Windows"
)
find_package
(
crashreporting2 CONFIG
)
endif
()
...
...
@@ -21,7 +20,6 @@ set(includedirs
add_executable
(
${
EXECUTABLE_NAME
}
${
sources
}
)
target_include_directories
(
${
EXECUTABLE_NAME
}
PRIVATE
${
includedirs
}
)
target_link_libraries
(
${
EXECUTABLE_NAME
}
PRIVATE yat4tango::yat4tango
)
target_link_libraries
(
${
EXECUTABLE_NAME
}
PRIVATE utils::utils
)
if
(
NOT CMAKE_SYSTEM_NAME STREQUAL
"Windows"
)
target_link_libraries
(
${
EXECUTABLE_NAME
}
PRIVATE crashreporting2::crashreporting2
)
endif
()
...
...
This diff is collapsed.
Click to expand it.
conanfile.py
+
1
−
2
View file @
c376bfe8
...
...
@@ -3,7 +3,7 @@ from conan import ConanFile
class
SimulatedMotorRecipe
(
ConanFile
):
name
=
"
simulatedmotor
"
executable
=
"
ds_SimulatedMotor
"
version
=
"
2.0.
2
"
version
=
"
2.0.
3
"
package_type
=
"
application
"
user
=
"
soleil
"
python_requires
=
"
base/[>=1.0]@soleil/stable
"
...
...
@@ -22,6 +22,5 @@ class SimulatedMotorRecipe(ConanFile):
def
requirements
(
self
):
self
.
requires
(
"
yat4tango/[>=1.0]@soleil/stable
"
)
self
.
requires
(
"
utils/[>=1.0]@soleil/stable
"
)
if
self
.
settings
.
os
==
"
Linux
"
:
self
.
requires
(
"
crashreporting2/[>=1.0]@soleil/stable
"
)
This diff is collapsed.
Click to expand it.
src/SimulatedMotor.cpp
+
7
−
20
View file @
c376bfe8
...
...
@@ -61,7 +61,6 @@ static const char *RcsId = "$Id: $";
#include
<tango.h>
#include
"PogoHelper.h"
#include
"Tools.h"
#include
<SimulatedMotor.h>
#include
<SimulatedMotorClass.h>
#include
<float.h>
...
...
@@ -593,8 +592,6 @@ void SimulatedMotor::write_accuracy(Tango::WAttribute &attr)
INFO_STREAM
<<
"accuracy <- "
<<
attr_accuracy_write
;
}
//+------------------------------------------------------------------
/**
* method: SimulatedMotor::forward
...
...
@@ -608,9 +605,7 @@ void SimulatedMotor::write_accuracy(Tango::WAttribute &attr)
//+------------------------------------------------------------------
void
SimulatedMotor
::
forward
()
{
DEBUG_STREAM
<<
"SimulatedMotor::forward(): entering... !"
<<
endl
;
INFO_STREAM
<<
"Command called: forward"
;
INFO_STREAM
<<
"SimulatedMotor::forward(): entering... !"
<<
endl
;
if
(
*
attr_positionLocked_read
==
true
)
{
...
...
@@ -635,9 +630,7 @@ void SimulatedMotor::forward()
//+------------------------------------------------------------------
void
SimulatedMotor
::
backward
()
{
DEBUG_STREAM
<<
"SimulatedMotor::backward(): entering... !"
<<
endl
;
INFO_STREAM
<<
"Command called: backward"
;
INFO_STREAM
<<
"SimulatedMotor::backward(): entering... !"
<<
endl
;
if
(
*
attr_positionLocked_read
==
true
)
{
...
...
@@ -661,9 +654,7 @@ void SimulatedMotor::backward()
//+------------------------------------------------------------------
void
SimulatedMotor
::
stop
()
{
DEBUG_STREAM
<<
"SimulatedMotor::stop(): entering... !"
<<
endl
;
INFO_STREAM
<<
"Command called: stop"
;
INFO_STREAM
<<
"SimulatedMotor::stop(): entering... !"
<<
endl
;
yat
::
Message
*
msg
=
new
yat
::
Message
(
MSG_STOP
,
DEFAULT_MSG_PRIORITY
,
true
);
m_task
->
wait_msg_handled
(
msg
);
// handle message synchronously (ensure exiting backward() in STANDBY state)
...
...
@@ -681,9 +672,7 @@ void SimulatedMotor::stop()
//+------------------------------------------------------------------
void
SimulatedMotor
::
motor_on
()
{
DEBUG_STREAM
<<
"SimulatedMotor::motor_on(): entering... !"
<<
endl
;
INFO_STREAM
<<
"Command called: motor_on"
;
INFO_STREAM
<<
"SimulatedMotor::motor_on(): entering... !"
<<
endl
;
if
(
get_state
()
==
Tango
::
STANDBY
)
return
;
...
...
@@ -703,9 +692,7 @@ void SimulatedMotor::motor_on()
//+------------------------------------------------------------------
void
SimulatedMotor
::
motor_off
()
{
DEBUG_STREAM
<<
"SimulatedMotor::motor_off(): entering... !"
<<
endl
;
INFO_STREAM
<<
"Command called: motor_off"
;
INFO_STREAM
<<
"SimulatedMotor::motor_off(): entering... !"
<<
endl
;
yat
::
Message
*
msg
=
new
yat
::
Message
(
MSG_OFF
);
m_task
->
post
(
msg
);
...
...
@@ -762,7 +749,7 @@ Tango::DevState SimulatedMotor::dev_state()
default
:
{
device_status
<<
GetDeviceState
(
device_state
)
;
device_status
<<
Tango
::
DevStateName
[
device_state
]
;
}
}
...
...
@@ -787,7 +774,7 @@ Tango::DevState SimulatedMotor::dev_state()
//+------------------------------------------------------------------
void
SimulatedMotor
::
force_state
(
Tango
::
DevString
argin
)
{
DEBUG
_STREAM
<<
"SimulatedMotor::force_state(): entering... !"
<<
endl
;
INFO
_STREAM
<<
"SimulatedMotor::force_state(): entering... !"
<<
endl
;
// Find the index of the given string
yat
::
String
state_in
=
argin
;
...
...
This diff is collapsed.
Click to expand it.
src/SimulatedMotor.cpp.bak
deleted
100755 → 0
+
0
−
812
View file @
5d76f99a
static const char *RcsId = "$Id: $";
//+=============================================================================
//
// file : SimulatedMotor.cpp
//
// description : C++ source for the SimulatedMotor and its commands.
// The class is derived from Device. It represents the
// CORBA servant object which will be accessed from the
// network. All commands which can be executed on the
// SimulatedMotor are implemented in this file.
//
// project : TANGO Device Server
//
// $Author: $
//
// $Revision: $
//
// $Revision: $
// $Date: $
//
// SVN only:
// $HeadURL: $
//
// CVS only:
// $Source: $
// $Log: $
//
// copyleft : Synchrotron SOLEIL
// L'Orme des merisiers - Saint Aubin
// BP48 - 91192 Gif sur Yvette
// FRANCE
//
//-=============================================================================
//
// This file is generated by POGO
// (Program Obviously used to Generate tango Object)
//
// (c) - Software Engineering Group - ESRF
//=============================================================================
//===================================================================
//
// The following table gives the correspondence
// between commands and method name.
//
// Command name| Method name
// ----------------------------------------
// State | dev_state()
// Status | dev_status()
// Forward | forward()
// Backward | backward()
// Stop | stop()
// MotorON | motor_on()
// MotorOFF | motor_off()
// ForceSTATE | force_state()
//
//===================================================================
#include <tango.h>
#include "PogoHelper.h"
#include "Tools.h"
#include <SimulatedMotor.h>
#include <SimulatedMotorClass.h>
#include <float.h>
namespace SimulatedMotor_ns
{
//+----------------------------------------------------------------------------
//
// method : SimulatedMotor::SimulatedMotor(string &s)
//
// description : constructor for simulated SimulatedMotor
//
// in : - cl : Pointer to the DeviceClass object
// - s : Device name
//
//-----------------------------------------------------------------------------
SimulatedMotor::SimulatedMotor(Tango::DeviceClass *cl,string &s)
:Tango::Device_4Impl(cl,s.c_str()), m_is_init_startup(true)
{
init_device();
}
SimulatedMotor::SimulatedMotor(Tango::DeviceClass *cl,const char *s)
:Tango::Device_4Impl(cl,s), m_is_init_startup(true)
{
init_device();
}
SimulatedMotor::SimulatedMotor(Tango::DeviceClass *cl,const char *s,const char *d)
:Tango::Device_4Impl(cl,s,d), m_is_init_startup(true)
{
init_device();
}
//+----------------------------------------------------------------------------
//
// method : SimulatedMotor::delete_device()
//
// description : will be called at device destruction or at init command.
//
//-----------------------------------------------------------------------------
void SimulatedMotor::delete_device()
{
// Delete device allocated objects
DELETE_SCALAR_ATTRIBUTE(attr_position_read);
DELETE_SCALAR_ATTRIBUTE(attr_offset_read);
DELETE_SCALAR_ATTRIBUTE(attr_velocity_read);
DELETE_SCALAR_ATTRIBUTE(attr_accuracy_read);
DELETE_SCALAR_ATTRIBUTE(attr_backlash_read);
DELETE_SCALAR_ATTRIBUTE(attr_acceleration_read);
DELETE_SCALAR_ATTRIBUTE(attr_deceleration_read);
DELETE_SCALAR_ATTRIBUTE(attr_backwardLimitSwitch_read);
DELETE_SCALAR_ATTRIBUTE(attr_forwardLimitSwitch_read);
DELETE_SCALAR_ATTRIBUTE(attr_positionLocked_read);
//- release the inner-appender
INFO_STREAM << "Remove the inner-appender." << endl;
yat4tango::InnerAppender::release(this);
INFO_STREAM << "Remove the log-adapter." << endl;
yat4tango::YatLogAdapter::release();
}
//+----------------------------------------------------------------------------
//
// method : SimulatedMotor::init_device()
//
// description : will be called at device initialization.
//
//-----------------------------------------------------------------------------
void SimulatedMotor::init_device()
{
INFO_STREAM << "SimulatedMotor::init_device() entering ...";
//- instanciate the appender in order ton manage logs
DEBUG_STREAM << "Add the inner-appender." << endl;
try
{
//- specify both the associated device and the log buffer depth
yat4tango::InnerAppender::initialize(this, 1024);
}
catch (Tango::DevFailed& df)
{
ERROR_STREAM << df << endl;
set_state(Tango::INIT);
return;
}
// Initialise variables to default values
//--------------------------------------------
get_device_property();
CREATE_SCALAR_ATTRIBUTE(attr_position_read);
CREATE_SCALAR_ATTRIBUTE(attr_offset_read);
CREATE_SCALAR_ATTRIBUTE(attr_velocity_read);
CREATE_SCALAR_ATTRIBUTE(attr_accuracy_read);
CREATE_SCALAR_ATTRIBUTE(attr_backlash_read);
CREATE_SCALAR_ATTRIBUTE(attr_acceleration_read);
CREATE_SCALAR_ATTRIBUTE(attr_deceleration_read);
CREATE_SCALAR_ATTRIBUTE(attr_backwardLimitSwitch_read);
CREATE_SCALAR_ATTRIBUTE(attr_forwardLimitSwitch_read);
CREATE_SCALAR_ATTRIBUTE(attr_positionLocked_read);
m_statuses.push_back("ON");
m_statuses.push_back("OFF");
m_statuses.push_back("CLOSE");
m_statuses.push_back("OPEN");
m_statuses.push_back("INSERT");
m_statuses.push_back("EXTRACT");
m_statuses.push_back("MOVING");
m_statuses.push_back("STANDBY");
m_statuses.push_back("FAULT");
m_statuses.push_back("INIT");
m_statuses.push_back("RUNNING");
m_statuses.push_back("ALARM");
m_statuses.push_back("DISABLE");
m_statuses.push_back("UNKNOWN");
// Log
yat4tango::YatLogAdapter::initialize(this);
m_previous_state = Tango::INIT;
set_state(Tango::INIT);
// Create and start the task
m_task.reset(new SimulatedMotorTask(this), TaskExiter());
yat::Message* msg = yat::Message::allocate(yat::TASK_INIT, INIT_MSG_PRIORITY, true);
m_task->go(msg);
// Init default values
if (m_is_init_startup)
{
m_is_init_startup = false;
attr_velocity_write = 10.0;
Tango::WAttribute &init_velocity = dev_attr->get_w_attr_by_name("velocity");
init_velocity.set_write_value(attr_velocity_write);
write_velocity(init_velocity);
}
attr_positionLocked_write = false;
Tango::WAttribute &init_positionLocked = dev_attr->get_w_attr_by_name("positionLocked");
init_positionLocked.set_write_value(attr_positionLocked_write);
write_positionLocked(init_positionLocked);
m_is_write_at_init = true;
INFO_STREAM << "SimulatedMotor::init_device() exiting ...\n";
}
//+----------------------------------------------------------------------------
//
// method : SimulatedMotor::get_device_property()
//
// description : Read the device properties from database.
//
//-----------------------------------------------------------------------------
void SimulatedMotor::get_device_property()
{
// Initialize your default values here (if not done with POGO).
}
//+----------------------------------------------------------------------------
//
// method : SimulatedMotor::always_executed_hook()
//
// description : method always executed before any command is executed
//
//-----------------------------------------------------------------------------
void SimulatedMotor::always_executed_hook()
{
try
{
dev_state();
}
catch (Tango::DevFailed& df)
{
ERROR_STREAM << df << endl;
RETHROW_DEVFAILED( df, "TANGO_DEVICE_ERROR", string(df.errors[0].desc).c_str(), "SimulatedMotor::always_executed_hook" );
}
}
//+----------------------------------------------------------------------------
//
// method : SimulatedMotor::read_attr_hardware
//
// description : Hardware acquisition for attributes.
//
//-----------------------------------------------------------------------------
void SimulatedMotor::read_attr_hardware(vector<long> &attr_list)
{
DEBUG_STREAM << "SimulatedMotor::read_attr_hardware(vector<long> &attr_list) entering... "<< endl;
// Add your own code here
}
//+----------------------------------------------------------------------------
//
// method : SimulatedMotor::read_positionLocked
//
// description : Extract real attribute values for positionLocked acquisition result.
//
//-----------------------------------------------------------------------------
void SimulatedMotor::read_positionLocked(Tango::Attribute &attr)
{
DEBUG_STREAM << "SimulatedMotor::read_positionLocked(Tango::Attribute &attr) entering... "<< endl;
attr.set_value(attr_positionLocked_read);
}
//+----------------------------------------------------------------------------
//
// method : SimulatedMotor::write_positionLocked
//
// description : Write positionLocked attribute values to hardware.
//
//-----------------------------------------------------------------------------
void SimulatedMotor::write_positionLocked(Tango::WAttribute &attr)
{
DEBUG_STREAM << "SimulatedMotor::write_positionLocked(Tango::WAttribute &attr) entering... "<< endl;
attr.get_write_value(attr_positionLocked_write);
*attr_positionLocked_read = attr_positionLocked_write;
INFO_STREAM << "positionLocked <- " << attr_positionLocked_write;
}
//+----------------------------------------------------------------------------
//
// method : SimulatedMotor::read_backwardLimitSwitch
//
// description : Extract real attribute values for backwardLimitSwitch acquisition result.
//
//-----------------------------------------------------------------------------
void SimulatedMotor::read_backwardLimitSwitch(Tango::Attribute &attr)
{
DEBUG_STREAM << "SimulatedMotor::read_backwardLimitSwitch(Tango::Attribute &attr) entering... "<< endl;
attr.set_value(attr_backwardLimitSwitch_read);
}
//+----------------------------------------------------------------------------
//
// method : SimulatedMotor::write_backwardLimitSwitch
//
// description : Write backwardLimitSwitch attribute values to hardware.
//
//-----------------------------------------------------------------------------
void SimulatedMotor::write_backwardLimitSwitch(Tango::WAttribute &attr)
{
DEBUG_STREAM << "SimulatedMotor::write_backwardLimitSwitch(Tango::WAttribute &attr) entering... "<< endl;
attr.get_write_value(attr_backwardLimitSwitch_write);
*attr_backwardLimitSwitch_read = attr_backwardLimitSwitch_write;
INFO_STREAM << "backwardLimitSwitch <- " << attr_backwardLimitSwitch_write;
}
//+----------------------------------------------------------------------------
//
// method : SimulatedMotor::read_forwardLimitSwitch
//
// description : Extract real attribute values for forwardLimitSwitch acquisition result.
//
//-----------------------------------------------------------------------------
void SimulatedMotor::read_forwardLimitSwitch(Tango::Attribute &attr)
{
DEBUG_STREAM << "SimulatedMotor::read_forwardLimitSwitch(Tango::Attribute &attr) entering... "<< endl;
attr.set_value(attr_forwardLimitSwitch_read);
}
//+----------------------------------------------------------------------------
//
// method : SimulatedMotor::write_forwardLimitSwitch
//
// description : Write forwardLimitSwitch attribute values to hardware.
//
//-----------------------------------------------------------------------------
void SimulatedMotor::write_forwardLimitSwitch(Tango::WAttribute &attr)
{
DEBUG_STREAM << "SimulatedMotor::write_forwardLimitSwitch(Tango::WAttribute &attr) entering... "<< endl;
attr.get_write_value(attr_forwardLimitSwitch_write);
*attr_forwardLimitSwitch_read = attr_forwardLimitSwitch_write;
INFO_STREAM << "forwardLimitSwitch <- " << attr_forwardLimitSwitch_write;
}
//+----------------------------------------------------------------------------
//
// method : SimulatedMotor::read_backlash
//
// description : Extract real attribute values for backlash acquisition result.
//
//-----------------------------------------------------------------------------
void SimulatedMotor::read_backlash(Tango::Attribute &attr)
{
DEBUG_STREAM << "SimulatedMotor::read_backlash(Tango::Attribute &attr) entering... "<< endl;
attr.set_value(attr_backlash_read);
}
//+----------------------------------------------------------------------------
//
// method : SimulatedMotor::write_backlash
//
// description : Write backlash attribute values to hardware.
//
//-----------------------------------------------------------------------------
void SimulatedMotor::write_backlash(Tango::WAttribute &attr)
{
DEBUG_STREAM << "SimulatedMotor::write_backlash(Tango::WAttribute &attr) entering... "<< endl;
attr.get_write_value(attr_backlash_write);
*attr_backlash_read = attr_backlash_write;
INFO_STREAM << "backlash <- " << attr_backlash_write;
}
//+----------------------------------------------------------------------------
//
// method : SimulatedMotor::read_acceleration
//
// description : Extract real attribute values for acceleration acquisition result.
//
//-----------------------------------------------------------------------------
void SimulatedMotor::read_acceleration(Tango::Attribute &attr)
{
DEBUG_STREAM << "SimulatedMotor::read_acceleration(Tango::Attribute &attr) entering... "<< endl;
attr.set_value(attr_acceleration_read);
}
//+----------------------------------------------------------------------------
//
// method : SimulatedMotor::write_acceleration
//
// description : Write acceleration attribute values to hardware.
//
//-----------------------------------------------------------------------------
void SimulatedMotor::write_acceleration(Tango::WAttribute &attr)
{
DEBUG_STREAM << "SimulatedMotor::write_acceleration(Tango::WAttribute &attr) entering... "<< endl;
attr.get_write_value(attr_acceleration_write);
*attr_acceleration_read = attr_acceleration_write;
INFO_STREAM << "acceleration <- " << attr_acceleration_write;
}
//+----------------------------------------------------------------------------
//
// method : SimulatedMotor::read_deceleration
//
// description : Extract real attribute values for deceleration acquisition result.
//
//-----------------------------------------------------------------------------
void SimulatedMotor::read_deceleration(Tango::Attribute &attr)
{
DEBUG_STREAM << "SimulatedMotor::read_deceleration(Tango::Attribute &attr) entering... "<< endl;
attr.set_value(attr_deceleration_read);
}
//+----------------------------------------------------------------------------
//
// method : SimulatedMotor::write_deceleration
//
// description : Write deceleration attribute values to hardware.
//
//-----------------------------------------------------------------------------
void SimulatedMotor::write_deceleration(Tango::WAttribute &attr)
{
DEBUG_STREAM << "SimulatedMotor::write_deceleration(Tango::WAttribute &attr) entering... "<< endl;
attr.get_write_value(attr_deceleration_write);
*attr_deceleration_read = attr_deceleration_write;
INFO_STREAM << "deceleration <- " << attr_deceleration_write;
}
//+----------------------------------------------------------------------------
//
// method : SimulatedMotor::read_position
//
// description : Extract real attribute values for position acquisition result.
//
//-----------------------------------------------------------------------------
void SimulatedMotor::read_position(Tango::Attribute &attr)
{
DEBUG_STREAM << "SimulatedMotor::read_position(Tango::Attribute &attr) entering... "<< endl;
*attr_position_read = m_task->get_position() + (*attr_offset_read);
attr.set_value(attr_position_read);
}
//+----------------------------------------------------------------------------
//
// method : SimulatedMotor::write_position
//
// description : Write position attribute values to hardware.
//
//-----------------------------------------------------------------------------
void SimulatedMotor::write_position(Tango::WAttribute &attr)
{
DEBUG_STREAM << "SimulatedMotor::write_position(Tango::WAttribute &attr) entering... "<< endl;
if (*attr_positionLocked_read == true)
{
Tango::Except::throw_exception("TANGO_DEVICE_ERROR","Position is locked.", "SimulatedMotor::write_position");
}
attr.get_write_value(attr_position_write);
INFO_STREAM << "position <- " << attr_position_write;
// Init position in task at init
if (m_is_write_at_init)
{
m_is_write_at_init = false;
yat::Message * msg = new yat::Message(MSG_INITPOSITION);
msg->attach_data(attr_position_write);
m_task->post(msg);
}
else
// Move only if displacement is greater than accuracy
if ( fabs(attr_position_write - *attr_position_read) > *attr_accuracy_read)
{
yat::Message * msg = new yat::Message(MSG_SETPOSITION);
msg->attach_data(attr_position_write);
m_task->post(msg);
}
}
//+----------------------------------------------------------------------------
//
// method : SimulatedMotor::read_offset
//
// description : Extract real attribute values for offset acquisition result.
//
//-----------------------------------------------------------------------------
void SimulatedMotor::read_offset(Tango::Attribute &attr)
{
DEBUG_STREAM << "SimulatedMotor::read_offset(Tango::Attribute &attr) entering... "<< endl;
attr.set_value(attr_offset_read);
}
//+----------------------------------------------------------------------------
//
// method : SimulatedMotor::write_offset
//
// description : Write offset attribute values to hardware.
//
//-----------------------------------------------------------------------------
void SimulatedMotor::write_offset(Tango::WAttribute &attr)
{
DEBUG_STREAM << "SimulatedMotor::write_offset(Tango::WAttribute &attr) entering... "<< endl;
attr.get_write_value(attr_offset_write);
*attr_offset_read = attr_offset_write;
INFO_STREAM << "offset <- " << attr_offset_write;
}
//+----------------------------------------------------------------------------
//
// method : SimulatedMotor::read_velocity
//
// description : Extract real attribute values for velocity acquisition result.
//
//-----------------------------------------------------------------------------
void SimulatedMotor::read_velocity(Tango::Attribute &attr)
{
DEBUG_STREAM << "SimulatedMotor::read_velocity(Tango::Attribute &attr) entering... "<< endl;
attr.set_value(attr_velocity_read);
}
//+----------------------------------------------------------------------------
//
// method : SimulatedMotor::write_velocity
//
// description : Write velocity attribute values to hardware.
//
//-----------------------------------------------------------------------------
void SimulatedMotor::write_velocity(Tango::WAttribute &attr)
{
DEBUG_STREAM << "SimulatedMotor::write_velocity(Tango::WAttribute &attr) entering... "<< endl;
attr.get_write_value(attr_velocity_write);
INFO_STREAM << "velocity <- " << attr_velocity_write;
*attr_velocity_read = attr_velocity_write;
yat::Message * msg = new yat::Message(MSG_SETVELOCITY);
msg->attach_data(attr_velocity_write);
m_task->post(msg);
}
//+----------------------------------------------------------------------------
//
// method : SimulatedMotor::read_accuracy
//
// description : Extract real attribute values for accuracy acquisition result.
//
//-----------------------------------------------------------------------------
void SimulatedMotor::read_accuracy(Tango::Attribute &attr)
{
DEBUG_STREAM << "SimulatedMotor::read_accuracy(Tango::Attribute &attr) entering... "<< endl;
attr.set_value(attr_accuracy_read);
}
//+----------------------------------------------------------------------------
//
// method : SimulatedMotor::write_accuracy
//
// description : Write accuracy attribute values to hardware.
//
//-----------------------------------------------------------------------------
void SimulatedMotor::write_accuracy(Tango::WAttribute &attr)
{
DEBUG_STREAM << "SimulatedMotor::write_accuracy(Tango::WAttribute &attr) entering... "<< endl;
attr.get_write_value(attr_accuracy_write);
*attr_accuracy_read = attr_accuracy_write;
INFO_STREAM << "accuracy <- " << attr_accuracy_write;
}
//+------------------------------------------------------------------
/**
* method: SimulatedMotor::forward
*
* description: method to execute "Forward"
* Increment in a continuous way the position attribute value of the device.<BR>
* Each increment is equal to StepSize.
*
*
*/
//+------------------------------------------------------------------
void SimulatedMotor::forward()
{
DEBUG_STREAM << "SimulatedMotor::forward(): entering... !" << endl;
INFO_STREAM << "Command called: forward";
if (*attr_positionLocked_read == true)
{
Tango::Except::throw_exception("TANGO_DEVICE_ERROR","Position is locked.", "SimulatedMotor::forward");
}
yat::Message * msg = new yat::Message(MSG_SETPOSITION);
msg->attach_data(DBL_MAX);
m_task->post(msg);
}
//+------------------------------------------------------------------
/**
* method: SimulatedMotor::backward
*
* description: method to execute "Backward"
* decrement in a continuous way the position attribute value of the device.<BR>
* Each increment is equal to StepSize.
*
*
*/
//+------------------------------------------------------------------
void SimulatedMotor::backward()
{
DEBUG_STREAM << "SimulatedMotor::backward(): entering... !" << endl;
INFO_STREAM << "Command called: backward";
if (*attr_positionLocked_read == true)
{
Tango::Except::throw_exception("TANGO_DEVICE_ERROR","Position is locked.", "SimulatedMotor::backward");
}
yat::Message * msg = new yat::Message(MSG_SETPOSITION);
msg->attach_data(-DBL_MAX);
m_task->post(msg);
}
//+------------------------------------------------------------------
/**
* method: SimulatedMotor::stop
*
* description: method to execute "Stop"
* Stop the current movement of the device.
*
*
*/
//+------------------------------------------------------------------
void SimulatedMotor::stop()
{
DEBUG_STREAM << "SimulatedMotor::stop(): entering... !" << endl;
INFO_STREAM << "Command called: stop";
yat::Message * msg = new yat::Message(MSG_STOP);
msg->attach_data(-DBL_MAX);
m_task->post(msg);
}
//+------------------------------------------------------------------
/**
* method: SimulatedMotor::motor_on
*
* description: method to execute "MotorON"
* Switch the power of the motor to On. State is switched to Standby.
*
*
*/
//+------------------------------------------------------------------
void SimulatedMotor::motor_on()
{
DEBUG_STREAM << "SimulatedMotor::motor_on(): entering... !" << endl;
INFO_STREAM << "Command called: motor_on";
if (get_state() == Tango::STANDBY) return;
yat::Message * msg = new yat::Message(MSG_ON);
m_task->post(msg);
}
//+------------------------------------------------------------------
/**
* method: SimulatedMotor::motor_off
*
* description: method to execute "MotorOFF"
* Switch the power of the motor to Off. State is switched to Off.
*
*
*/
//+------------------------------------------------------------------
void SimulatedMotor::motor_off()
{
DEBUG_STREAM << "SimulatedMotor::motor_off(): entering... !" << endl;
INFO_STREAM << "Command called: motor_off";
yat::Message * msg = new yat::Message(MSG_OFF);
m_task->post(msg);
}
//+------------------------------------------------------------------
/**
* method: SimulatedMotor::dev_state
*
* description: method to execute "State"
* This command gets the device state (stored in its <i>device_state</i> data member) and returns it to the caller.
*
* @return State Code
*
*/
//+------------------------------------------------------------------
Tango::DevState SimulatedMotor::dev_state()
{
DEBUG_STREAM << "SimulatedMotor::dev_state(): entering... !" << endl;
// Add your own code to control device here
stringstream device_status;
device_status << "";
Tango::DevState device_state = m_task->get_state();
set_state(device_state);
switch (device_state)
{
case Tango::STANDBY:
{
if (*attr_positionLocked_read)
{
device_status << "axis position locked [STANDBY]";
}
else
{
device_status << "axis up and ready [STANDBY]";
}
break;
}
case Tango::MOVING:
{
device_status << "axis is MOVING";
break;
}
case Tango::OFF:
{
device_status << "axis off [motor is OFF]";
break;
}
default:
{
device_status << GetDeviceState(device_state);
}
}
set_status(device_status.str());
return device_state;
}
//+------------------------------------------------------------------
/**
* method: SimulatedMotor::force_state
*
* description: method to execute "ForceSTATE"
* This command allows forcing the state of the device for tests purposes.
*
* @param argin A tango devstate name (FAULT, INIT ...)
*
*/
//+------------------------------------------------------------------
void SimulatedMotor::force_state(Tango::DevString argin)
{
DEBUG_STREAM << "SimulatedMotor::force_state(): entering... !" << endl;
// Find the index of the given string
yat::String state_in = argin;
state_in.to_upper();
vector<string>::const_iterator it = find(m_statuses.begin(), m_statuses.end(), state_in);
if (it!=m_statuses.end())
{
Tango::DevState state = Tango::DevState(it - m_statuses.begin());
yat::Message * msg = new yat::Message(MSG_FORCESTATE);
msg->attach_data(state);
m_task->post(msg);
}
else
{
yat::String msg = "Possible states are:\n";
for (unsigned int i=0; i<m_statuses.size(); i++) msg.printf("%s%s\n", msg.c_str(), m_statuses.at(i).c_str() );
Tango::Except::throw_exception("TANGO_DEVICE_ERROR", msg.c_str(), "SimulatedMotor::force_state");
}
}
} // namespace
This diff is collapsed.
Click to expand it.
Preview
0%
Loading
Try again
or
attach a new file
.
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Save comment
Cancel
Please
register
or
sign in
to comment