Contents

• 1 Introduction
  • 1 Introduction to device server
  • 2 Device server history
  
  
• 2 Getting Started
  • 1 A Java TANGO client
  • 2 A C++ TANGO client
  • 3 A TANGO device server
    • 1 The commands and attributes code in C++
    • 2 The commands and attributes code in java
  
  
• 3 The TANGO device server model
  • 1 Introduction to CORBA
  • 2 The model
  • 3 The device
    • 1 The commands
    • 2 The TANGO attributes
    • 3 Command or attributes ?
    • 4 The CORBA attributes
    • 5 The remaining CORBA operations
    • 6 The special case of the device state and status
    • 7 The device polling
  • 4 The server
  • 5 The Tango Logging Service
  • 6 The database
  • 7 The controlled access
  • 8 The Application Programmers Interfaces
    • 1 Rules of the API
    • 2 Communication between client and server using the API
    • 3 Tango events
  
  
• 4 Writing a TANGO client using TANGO APIs
  • 1 Introduction
  • 2 Getting Started
  • 3 Basic Philosophy
  • 4 Data types
  • 5 Request model
    • 1 Synchronous model
    • 2 Asynchronous model
  • 6 Events
    • 1 Introduction
    • 2 Event definition
    • 3 Event types
    • 4 Event filtering (Removed in Tango release 8 and above)
    • 5 Application Programmer's Interface
  • 7 Group
    • 1 Getting started with Tango group
    • 2 Forward or not forward?
    • 3 Executing a command
    • 4 Reading attribute(s)
    • 5 Writing an attribute
  • 8 Device locking
  • 9 Reconnection and exception
  • 10 Thread safety
  • 11 Compiling and linking a Tango client
  
  
• 5 TANGO Java API
  • 1 Introduction
    • 1 Description
    • 2 Basic Philosophy
    • 3 Classes
    • 4 Reporting errors
    • 5 Compiling a Java client
  • 2 Reference manual
  
  
• 6 The TANGO C++ Application Programmer Interface
  • 1 Tango::DeviceProxy()
    • 1 Constructors
    • 2 Miscellaneous methods
    • 3 Synchronous command oriented methods
    • 4 Synchronous attribute related methods
    • 5 Asynchronous command oriented methods
    • 6 Asynchronous attribute related methods
    • 7 Miscellaneous asynchronous related methods
    • 8 Polling related methods
    • 9 Event related methods
    • 10 Property related methods
    • 11 Logging related methods
    • 12 Locking related methods
  • 2 Tango::DeviceData
    • 1 Constructors, assignement operators and C++11
    • 2 Operators
    • 3 bool DeviceData::is_empty()
    • 4 int DeviceData::get_type()
    • 5 void DeviceData::exceptions(bitset<DeviceData::numFlags> )
    • 6 bitset<DeviceData::numFlags> exceptions()
    • 7 void DeviceData::reset_exceptions(DeviceData::except_flags fl)
    • 8 void DeviceData::set_exceptions(DeviceData::except_flags fl)
    • 9 ostream &operator<<(ostream &, DeviceData &)
  • 3 Tango::DeviceDataHistory
    • 1 bool DeviceDataHistory::has_failed()
    • 2 TimeVal &DeviceDataHistory::get_date()
    • 3 const DevErrorList &DeviceDataHistory::get_err_stack()
    • 4 ostream &operator<<(ostream &, DeviceDataHistory &)
  • 4 Tango::DeviceAttribute
    • 1 Constructors, assignement operators
    • 2 Data Extraction and Insertion : Operators and Methods
    • 3 bool DeviceAttribute::is_empty()
    • 4 void DeviceAttribute::exceptions(bitset<DeviceAttribute::numFlags>)
    • 5 bitset<DeviceAttribute::numFlags> exceptions()
    • 6 void DeviceAttribute::reset_exceptions(DeviceAttribute::except_flags fl)
    • 7 void DeviceAttribute::set_exceptions(DeviceAttribute::except_flags fl)
    • 8 bool DeviceAttribute::has_failed()
    • 9 const DevErrorList &DeviceAttribute::get_err_stack()
    • 10 string &DeviceAttribute::get_name()
    • 11 void DeviceAttribute::set_name(string &)
    • 12 void DeviceAttribute::set_name(const char *)
    • 13 AttrQuality &DeviceAttribute::get_quality()
    • 14 int DeviceAttribute::get_dim_x()
    • 15 int DeviceAttribute::get_dim_y()
    • 16 int DeviceAttribute::get_written_dim_x()
    • 17 int DeviceAttribute::get_written_dim_y()
    • 18 AttributeDimension DeviceAttribute::get_r_dimension()
    • 19 AttributeDimension DeviceAttribute::get_w_dimension()
    • 20 long DeviceAttribute::get_nb_read()
    • 21 long DeviceAttribute::get_nb_written()
    • 22 TimeVal &DeviceAttribute::get_date()
    • 23 int DeviceAttribute::get_type()
    • 24 AttrDataFormat DeviceAttribute::get_data_format()
    • 25 ostream &operator<<(ostream &, DeviceAttribute &)
  • 5 Tango::DeviceAttributeHistory
    • 1 ostream &operator<<(ostream &, DeviceAttributeHistory &)
  • 6 Tango::AttributeProxy()
    • 1 Constructors
    • 2 Miscellaneous methods
    • 3 Synchronous related methods
    • 4 Asynchronous methods
    • 5 Polling related methods
    • 6 Event related methods
    • 7 Property related methods
  • 7 Tango::ApiUtil
    • 1 static ApiUtil *ApiUtil::instance()
    • 2 static void ApiUtil::cleanup()
    • 3 long ApiUtil::pending_asynch_call(asyn_req_type req)
    • 4 void ApiUtil::get_asynch_replies()
    • 5 void ApiUtil::get_asynch_replies(long timeout)
    • 6 void ApiUtil::set_asynch_cb_sub_model(cb_sub_model model)
    • 7 cb_sub_model ApiUtil::get_asynch_cb_sub_model()
    • 8 static int ApiUtil::get_env_var(const char *name,string &value)
    • 9 void set_event_buffer_hwm(DevLong val)
  • 8 Asynchronous callback related classes
    • 1 Tango::CallBack
    • 2 Tango::CmdDoneEvent
    • 3 Tango::AttrReadEvent
    • 4 Tango::AttrWrittenEvent
    • 5 Tango::EventData
    • 6 Tango::AttrConfEventData
    • 7 Tango::DataReadyEventData
  • 9 Tango::Group
    • 1 Constructor and Destructor
    • 2 Group Management Related Methods
    • 3 A la DeviceProxy Methods
  • 10 Tango::Database
    • 1 Database::Database()
    • 2 string Database::get_info()
    • 3 void Database::add_device(DbDevInfo&)
    • 4 void Database::delete_device(string)
    • 5 DbDevImportInfo Database::import_device(string &)
    • 6 void Database::export_device(DbDevExportInfo&)
    • 7 void Database::unexport_device(string)
    • 8 void Database::add_server(string &, DbDevInfos&)
    • 9 void Database::delete_server(string &)
    • 10 void Database::export_server( DbDevExportInfos &)
    • 11 void Database::unexport_server(string &)
    • 12 DbDatum Database::get_services(string &servicename,string &instname)
    • 13 void Database::register_service(string &servicename,string &instname,string &devname)
    • 14 void Database::unregister_service(string &servicename,string &instname)
    • 15 DbDatum Database::get_host_list()
    • 16 DbDatum Database::get_host_list(string &wildcard)
    • 17 DbDatum Database::get_server_class_list(string &server)
    • 18 DbDatum Database::get_server_name_list()
    • 19 DbDatum Database::get_instance_name_list(string &servername)
    • 20 DbDatum Database::get_server_list()
    • 21 DbDatum Database::get_server_list(string &wildcard)
    • 22 DbDatum Database::get_host_server_list(string &hostname)
    • 23 DbServerInfo Database::get_server_info(string &server)
    • 24 void Database::put_server_info(DbServerInfo &info)
    • 25 void Database::delete_server_info(string &server)
    • 26 DbDatum Database::get_device_name(string &, string &)
    • 27 DbDatum Database::get_device_exported(string &)
    • 28 DbDatum Database::get_device_domain(string &)
    • 29 DbDatum Database::get_device_family(string &)
    • 30 DbDatum Database::get_device_member(string &)
    • 31 DbDatum Database::get_device_class_list(string &server)
    • 32 string Database::get_class_for_device(string &devname)
    • 33 DbDatum Database::get_class_inheritance_for_device(string &devname)
    • 34 DbDatum Database::get_device_exported_for_class(string &classname)
    • 35 DbDatum Database::get_object_list(string &wildcard)
    • 36 DbDatum Database::get_object_property_list(string &objectname,string &wildcard)
    • 37 void Database::get_property(string, DbData&)
    • 38 void Database::put_property(string, DbData&)
    • 39 void Database::delete_property(string, DbData&)
    • 40 vector<DbHistory> Database::get_property_history(string &objname, string &propname)
    • 41 void Database::get_device_property(string, DbData&)
    • 42 void Database::put_device_property(string, DbData&)
    • 43 void Database::delete_device_property(string, DbData&)
    • 44 vector<DbHistory> Database::get_device_property_history(string &devname, string &propname)
    • 45 void Database::get_device_attribute_property(string, DbData&)
    • 46 void Database::put_device_attribute_property(string, DbData&)
    • 47 void Database::delete_device_attribute_property(string, DbData&)
    • 48 vector<DbHistory> Database::get_device_attribute_property_history(string &devname, string &attname, string &propname)
    • 49 DbDatum Database::get_class_list(string &wildcard)
    • 50 DbDatum Database::get_class_property_list(string &classname)
    • 51 void Database::get_class_property(string, DbData&)
    • 52 void Database::put_class_property(string, DbData&)
    • 53 void Database::delete_class_property(string, DbData&)
    • 54 vector<DbHistory> Database::get_class_property_history(string &classname, string &propname)
    • 55 DbDatum Database::get_class_attribute_list(string &classname,string &wildcard)
    • 56 void Database::get_class_attribute_property(string, DbData&)
    • 57 void Database::put_class_attribute_property(string, DbData&)
    • 58 void Database::delete_class_attribute_property(string, DbData&)
    • 59 vector<DbHistory> Database::get_class_attribute_property_history(string &devname, string &attname, string &propname)
    • 60 void Database::get_alias(string dev_name, string &dev_alias)
    • 61 void Database::get_device_alias(string dev_alias, string &dev_name)
    • 62 void Database::get_attribute_alias(string attr_alias, string &attr_name)
    • 63 void Database::put_attribute_alias(string &att_name, string &alias_name)
    • 64 void Database::delete_attribute_alias(string &alias_name)
    • 65 DbDatum Database::get_device_alias_list(string &filter)
    • 66 DbDatum Database::get_attribute_alias_list(string &filter)
    • 67 void Database::put_device_alias(string &dev_name,string &alias_name)
    • 68 void Database::delete_device_alias(string &alias_name)
  • 11 Tango::DbDevice
    • 1 DbDevice::DbDevice(string &)
    • 2 DbDevice::DbDevice(string &, Database *)
    • 3 DbDevImportInfo DbDevice::import_device()
    • 4 void DbDevice::export_device(DbDevExportInfo&)
    • 5 void DbDevice::add_device(DbDevInfo&)
    • 6 void DbDevice::delete_device()
    • 7 void DbDevice::get_property(DbData&)
    • 8 void DbDevice::put_property(DbData&)
    • 9 void DbDevice::delete_property(DbData&)
    • 10 void DbDevice::get_attribute_property(DbData&)
    • 11 void DbDevice::put_attribute_property(DbData&)
    • 12 void DbDevice::delete_attribute_property(DbData&)
  • 12 Tango::DbClass
    • 1 DbClass::DbClass(string)
    • 2 DbClass::DbClass(string, Database *)
    • 3 void DbClass::get_property(DbData&)
    • 4 void DbClass::put_property(DbData&)
    • 5 void DbClass::delete_property(DbData&)
    • 6 void DbClass::get_attribute_property(DbData&)
    • 7 void DbClass::put_attribute_property(DbData&)
    • 8 void DbClass::delete_attribute_property(DbData&)
  • 13 Tango::DbServer
    • 1 DbServer::DbServer(string)
    • 2 DbServer::DbServer(string, Database *)
    • 3 void DbServer::add_server(DbDevInfos &)
    • 4 void DbServer::delete_server()
    • 5 void DbServer::export_server(DbDevExportInfos &)
    • 6 void DbServer::unexport_server()
  • 14 Tango::DbDatum
    • 1 Operators
    • 2 bool DbDatum::is_empty()
    • 3 void DbDatum::exceptions(bitset<DbDatum::numFlags>)
    • 4 bitset<DbDatum::numFlags> exceptions()
    • 5 void DbDatum::reset_exceptions(DbDatum::except_flags fl)
    • 6 void DbDatum::set_exceptions(DbDatum::except_flags fl)
  • 15 Tango::DbData
  • 16 Exception
    • 1 The ConnectionFailed exception
    • 2 The CommunicationFailed exception
    • 3 The WrongNameSyntax exception
    • 4 The NonDbDevice exception
    • 5 The WrongData exception
    • 6 The NonSupportedFeature exception
    • 7 The AsynCall exception
    • 8 The AsynReplyNotArrived exception
    • 9 The EventSystemFailed exception
    • 10 The NamedDevFailedList exception
    • 11 The DeviceUnlocked exception
  • 17 Reconnection and exception
  
  
• 7 TangoATK Programmer's Guide
  • 1 Introduction
    • 1 Assumptions
  • 2 The key concepts of TangoATK
    • 1 Minimize development time
    • 2 Minimize bugs in applications
    • 3 Attributes and commands from different devices
    • 4 Avoid code duplication
  • 3 The real getting started
    • 1 Single device applications
    • 2 Multi device applications
    • 3 More on displaying attributes
    • 4 A short note on the relationship between models and viewers
  • 4 The key objects of TangoATK
    • 1 The Refreshers
    • 2 The DeviceFactory
    • 3 The AttributeFactory and the CommandFactory
    • 4 The AttributeList and the CommandList
    • 5 The Attributes
    • 6 The Commands
  
  
• 8 Writing a TANGO device server
  • 1 The device server framework
    • 1 Naming convention and programming language
    • 2 The device pattern
    • 3 Startup of a device pattern
    • 4 Command execution sequence
    • 5 The automatically added commands
    • 6 Reading/Writing attributes
    • 7 The device server framework
  • 2 Exchanging data between client and server
    • 1 Command / Attribute data types
    • 2 Passing data between client and server
    • 3 C++ memory management
    • 4 Reporting errors
  • 3 The Tango Logging Service
    • 1 Logging Targets
    • 2 Logging Levels
    • 3 Sending TANGO Logging Messages
  • 4 Writing a device server
    • 1 Understanding the device
    • 2 Defining device commands
    • 3 Choosing device state
    • 4 Device server utilities to ease coding/debugging
    • 5 Avoiding name conflicts
    • 6 The device server main function
    • 7 The DServer::class_factory method (C++ specific)
    • 8 Writing the StepperMotorClass class
    • 9 The DevReadPositionCmd class
    • 10 The PositionAttr class
    • 11 The StepperMotor class
  • 5 Device server under Windows
    • 1 The Tango device server graphical interface
    • 2 MFC device server
    • 3 Win32 application
    • 4 Device server as NT service
  • 6 Compiling, linking and executing a TANGO device server process
    • 1 Compiling and linking a C++ device server
    • 2 Running a C++ device server
    • 3 Compiling a Java device server
    • 4 Running a Java device server
  • 7 Advanced programming techniques
    • 1 Receiving signal (C++ specific)
    • 2 Inheriting
    • 3 Using another device pattern implementation within the same server
  
  
• 9 Advanced features
  • 1 Attribute alarms
    • 1 The level alarms
    • 2 The Read Different than Set (RDS) alarm
  • 2 Device polling
    • 1 Introduction
    • 2 Configuring the polling system
    • 3 Reading data from the polling buffer
    • 4 Retrieving command/attribute result history
    • 5 Externally triggered polling (only for C++ device server)
    • 6 Filling polling buffer (only for C++ device server)
    • 7 Setting and tuning the polling in a Tango class
  • 3 Threading
    • 1 C++ device server process
    • 2 C++ client process
  • 4 Generating events in a device server
  • 5 Memorized attribute
  • 6 Transfering images
  • 7 Device server with user defined event loop
  • 8 Device server using file as database
  • 9 Device server without database
    • 1 Example of device server started without database usage
    • 2 Connecting client to device within a device server started without database
  • 10 Multiple database servers within a Tango control system
  • 11 The Tango controlled access system
    • 1 User rights definition
    • 2 Running a Tango control system with the controlled access
  
  
• A. Reference part
  • 1 Device parameter
    • 1 The device black box
    • 2 The device description field
    • 3 The device state and status
    • 4 The device polling
    • 5 The device logging
  • 2 Device attribute
    • 1 Hard-coded device attribute parameters
    • 2 Modifiable attribute parameters
    • 3 Setting modifiable attribute parameters
    • 4 Resetting modifiable attribute parameters
  • 3 Device class parameter
  • 4 The device black box
  • 5 Automatically added commands
    • 1 The State command
    • 2 The Status command
    • 3 The Init command
  • 6 DServer class device commands
    • 1 The State command
    • 2 The Status command
    • 3 The DevRestart command
    • 4 The RestartServer command
    • 5 The QueryClass command
    • 6 The QueryDevice command
    • 7 The Kill command
    • 8 The QueryWizardClassProperty command
    • 9 The QueryWizardDevProperty command
    • 10 The QuerySubDevice command
    • 11 The StartPolling command
    • 12 The StopPolling command
    • 13 The AddObjPolling command
    • 14 The RemObjPolling command
    • 15 The UpdObjPollingPeriod command
    • 16 The PolledDevice command
    • 17 The DevPollStatus command
    • 18 The LockDevice command
    • 19 The UnLockDevice command
    • 20 The ReLockDevices command
    • 21 The DevLockStatus command
    • 22 The EventSubscriptionChange command (C++ server only)
    • 23 The ZmqEventSubscriptionChange command (C++ server only)
    • 24 The AddLoggingTarget command
    • 25 The RemoveLoggingTarget command
    • 26 The GetLoggingTarget command
    • 27 The GetLoggingLevel command
    • 28 The SetLoggingLevel command
    • 29 The StopLogging command
    • 30 The StartLogging command
  • 7 DServer class device properties
  • 8 Tango log consumer
    • 1 The available Log Consumer
    • 2 The Log Consumer interface
  • 9 Control system specific
    • 1 The device class documentation default value
    • 2 The services definition
    • 3 Tuning the event system buffers (HWM)
    • 4 Allowing NaN when writing attributes (floating point)
    • 5 Summary of CtrlSystem free object properties
  • 10 C++ specific
    • 1 The Tango master include file (tango.h)
    • 2 Tango specific pre-processor define
    • 3 Tango specific types
    • 4 Tango device state code
    • 5 Tango data type
    • 6 Tango command display level
  • 11 Java specific
    • 1 Packages
  • 12 Device server process option and environment variables
    • 1 Classical device server
    • 2 Device server process as Windows service
    • 3 Environment variables
  
  
• B. The TANGO IDL file : Module Tango
  • 1 Aliases
  • 2 Enums
  • 3 Structs
  • 4 Unions
  • 5 Exceptions
  • 6 Interface Tango::Device
    • 1 Attributes
    • 2 Operations
  • 7 Interface Tango::Device_2
    • 1 Operations
  • 8 Interface Tango::Device_3
    • 1 Operations
  • 9 Interface Tango::Device_4
    • 1 Operations
  
  
• C. Tango object naming (device, attribute and property)
  • 1 Device name
  • 2 Full object name
    • 1 Some examples
  • 3 Device and attribute name alias
  • 4 Reserved words and characters, limitations
  
  
• D. Starting a Tango control system
  • 1 Without database
  • 2 With database
  • 3 With database and event
    • 1 For Tango releases lower than 8
    • 2 For release 8 and above
  • 4 With file used as database
  • 5 With file used as database and event
    • 1 For Tango releases lower than 8
    • 2 For release 8 and above
  • 6 With the controlled access
  
  
• E. The notifd2db utility
  • 1 The notifd2db utility usage (For Tango releases lower than 8)
  
  
• F. The property file syntax
  • 1 Property file usage
  • 2 Property file syntax
  
  
• Bibliography
• Index