SensorLogger.idl

#include <Sensor.idl>
#include <PeripheralDeviceSlot.idl>
#include <UserEvent.idl>

module sensors {

    interface Logger_2_1_5 {

        structure Settings {
            boolean isEnabled;                  
            int samplePeriod;                   
            int samplesPerRecord;               
            int oldestRecId;                    
            int newestRecId;                    
            int logCapacity;                    
        };

        structure SensorSet {
            vector<sensors.Sensor_4_0_2> sensors;
            vector<peripheral.DeviceSlot_2_0_2> slots;
        };

        valueobject SettingsChangedEvent extends event.UserEvent {
            Settings oldSettings;               
            Settings newSettings;               
        };

        valueobject LoggedSensorsChangedEvent extends event.UserEvent {
            SensorSet oldSensors;               
            SensorSet newSensors;               
        };

        Settings getSettings();

        int setSettings(in boolean isEnabled, in int samplesPerRecord);

        constant int STATE_UNAVAILABLE = 0;             
        constant int STATE_OPEN = 1;                    
        constant int STATE_CLOSE = 2;                   
        constant int STATE_BELOW_LOWER_CRITICAL = 3;    
        constant int STATE_BELOW_LOWER_WARNING = 4;     
        constant int STATE_NORMAL = 5;                  
        constant int STATE_ABOVE_UPPER_WARNING = 6;     
        constant int STATE_ABOVE_UPPER_CRITICAL = 7;    
        constant int STATE_ON = 8;                      
        constant int STATE_OFF = 9;                     
        constant int STATE_ALARMED = 10;                
        constant int STATE_OK = 11;                     
        constant int STATE_MARGINAL = 12;               
        constant int STATE_FAIL = 13;                   
        constant int STATE_YES = 14;                    
        constant int STATE_NO = 15;                     
        constant int STATE_STANDBY = 16;                
        constant int STATE_ONE = 17;                    
        constant int STATE_TWO = 18;                    
        constant int STATE_IN_SYNC = 19;                
        constant int STATE_OUT_OF_SYNC = 20;            
        constant int STATE_FAULT = 21;                  
        constant int STATE_SELF_TEST = 22;              
        constant int STATE_I1_OPEN_FAULT = 23;          
        constant int STATE_I1_SHORT_FAULT = 24;         
        constant int STATE_I2_OPEN_FAULT = 25;          
        constant int STATE_I2_SHORT_FAULT = 26;         
        constant int STATE_WARNING = 27;                
        constant int STATE_CRITICAL = 28;               
        constant int STATE_NON_REDUNDANT = 29;          

        int getTimeStamps(out vector<time> timestamps,
                          in int recid, in int count);

        structure Record {
            boolean available;                  
            int takenValidSamples;              
            int state;                          
            double minValue;                    
            double avgValue;                    
            double maxValue;                    
        };

        int getSensorRecords(out vector<Record> recs, in sensors.Sensor_4_0_2 sensor,
                             in int recid, in int count);

        int getPeripheralDeviceRecords(out vector<Record> recs,
                                       in peripheral.DeviceSlot_2_0_2 slot,
                                       in int recid, in int count);

        structure TimedRecord {
            time timestamp;                     
            Record record;                      
        };

        int getSensorTimedRecords(out vector<TimedRecord> recs, in sensors.Sensor_4_0_2 sensor,
                            in int recid, in int count);

        int getPeripheralDeviceTimedRecords(out vector<TimedRecord> recs,
                                            in peripheral.DeviceSlot_2_0_2 slot,
                                            in int recid, in int count);
        
        SensorSet getLoggedSensors();

        int setLoggedSensors(in SensorSet sensors);

        int enableSensors(in SensorSet sensors);

        int disableSensors(in SensorSet sensors);

        boolean isSensorEnabled(in sensors.Sensor_4_0_2 sensor);

        boolean isSlotEnabled(in peripheral.DeviceSlot_2_0_2 slot);

        void enableAllSensors();

        void disableAllSensors();

        time getSensorSetTimestamp();

        structure LogRow {
            time sensorSetTimestamp;
            time timestamp;
            vector<Record> sensorRecords;
            vector<Record> peripheralDeviceRecords;
        };

        int getLogRow(out LogRow row, in int recid);

    };

}