ignore resets for now because every z/Z key press would trigger a call to NOAA. We...

[flightgear.git] / src / Systems / electrical.hxx

diff --git a/src/Systems/electrical.hxx b/src/Systems/electrical.hxx
index 04c71f3e7c318ced2f9b1d6a330c4cca154fae3f..1a04342227caebe4485ccbc14c215707b5e88ae4 100644 (file)
--- a/src/Systems/electrical.hxx
+++ b/src/Systems/electrical.hxx
@@ -38,8 +38,12 @@
 SG_USING_STD(string);
 SG_USING_STD(vector);
 
-#include <simgear/misc/props.hxx>
-#include <Main/fgfs.hxx>
+#include <simgear/props/props.hxx>
+#include <simgear/structure/subsystem_mgr.hxx>
+
+
+// Forward declaration
+class FGElectricalSystem;
 
 
 #define FG_UNKNOWN  -1
@@ -51,48 +55,84 @@ SG_USING_STD(vector);
 // Base class for other electrical components
 class FGElectricalComponent {
 
+protected:
+
     typedef vector<FGElectricalComponent *> comp_list;
     typedef vector<string> string_list;
 
+    int kind;
+    string name;
+    float volts;
+    float load_amps;
+
+    comp_list inputs;
+    comp_list outputs;
+    string_list props;
+
 public:
 
-    FGElectricalComponent() {}
+    FGElectricalComponent();
     virtual ~FGElectricalComponent() {}
 
-    virtual string get_name() { return ""; }
+    inline string get_name() { return name; }
+
+    inline int get_kind() const { return kind; }
+
+    inline float get_volts() const { return volts; }
+    inline void set_volts( float val ) { volts = val; }
+
+    inline float get_load_amps() const { return load_amps; }
+    inline void set_load_amps( float val ) { load_amps = val; }
+
+    inline int get_num_inputs() const { return outputs.size(); }
+    inline FGElectricalComponent *get_input( const int i ) {
+        return inputs[i];
+    }
+    inline void add_input( FGElectricalComponent *c ) {
+        inputs.push_back( c );
+    }
+
+    inline int get_num_outputs() const { return outputs.size(); }
+    inline FGElectricalComponent *get_output( const int i ) {
+        return outputs[i];
+    }
+    inline void add_output( FGElectricalComponent *c ) {
+        outputs.push_back( c );
+    }
+
+    inline int get_num_props() const { return props.size(); }
+    inline string get_prop( const int i ) {
+        return props[i];
+    }
+    inline void add_prop( const string &s ) {
+        props.push_back( s );
+    }
 
-    int kind;
-    inline int get_kind() { return kind; }
 };
 
 
 // Electrical supplier
 class FGElectricalSupplier : public FGElectricalComponent {
 
+    SGPropertyNode_ptr _rpm_node;
+
     enum FGSupplierType {
         FG_BATTERY = 0,
         FG_ALTERNATOR = 1,
         FG_EXTERNAL = 2
     };
 
-    string name;
+    string rpm_src;
     int model;
     double volts;
     double amps;
 
-    comp_list outputs;
-
 public:
 
-    FGElectricalSupplier ( string _name, string _model,
-                           double _volts, double _amps );
+    FGElectricalSupplier ( SGPropertyNode *node );
     ~FGElectricalSupplier () {}
 
-    void add_output( FGElectricalComponent *c ) {
-        outputs.push_back( c );
-    }
-
-    string get_name() const { return name; }
+    double get_output();
 };
 
 
@@ -100,24 +140,10 @@ public:
 // outputs)
 class FGElectricalBus : public FGElectricalComponent {
 
-    string name;
-    comp_list inputs;
-    comp_list outputs;
-
 public:
 
-    FGElectricalBus ( string _name );
+    FGElectricalBus ( SGPropertyNode *node );
     ~FGElectricalBus () {}
-
-    void add_input( FGElectricalComponent *c ) {
-        inputs.push_back( c );
-    }
-
-    void add_output( FGElectricalComponent *c ) {
-        outputs.push_back( c );
-    }
-
-    string get_name() const { return name; }
 };
 
 
@@ -125,19 +151,39 @@ public:
 // flexibility
 class FGElectricalOutput : public FGElectricalComponent {
 
-    string name;
-    comp_list inputs;
+private:
+
+    // number of amps drawn by this output
+    float output_amps;
 
 public:
 
-    FGElectricalOutput ( string _name );
+    FGElectricalOutput ( SGPropertyNode *node );
     ~FGElectricalOutput () {}
 
-    void add_input( FGElectricalComponent *c ) {
-        inputs.push_back( c );
-    }
+    inline float get_output_amps() const { return output_amps; }
+    inline void set_output_amps( float val ) { output_amps = val; }
+};
+
+
+// Model an electrical switch.  If the rating_amps > 0 then this
+// becomes a circuit breaker type switch that can trip
+class FGElectricalSwitch {
+
+private:
+
+    SGPropertyNode *switch_node;
+    float rating_amps;
+    bool circuit_breaker;
 
-    string get_name() const { return name; }
+public:
+
+    FGElectricalSwitch( SGPropertyNode *node );
+
+    ~FGElectricalSwitch() { };
+
+    inline bool get_state() const { return switch_node->getBoolValue(); }
+    void set_state( bool val ) { switch_node->setBoolValue( val ); }
 };
 
 
@@ -147,43 +193,31 @@ class FGElectricalConnector : public FGElectricalComponent {
 
     comp_list inputs;
     comp_list outputs;
-    string_list switches;
+    typedef vector< FGElectricalSwitch> switch_list;
+    switch_list switches;
 
 public:
 
-    FGElectricalConnector ();
+    FGElectricalConnector ( SGPropertyNode *node, FGElectricalSystem *es );
     ~FGElectricalConnector () {}
 
-    void add_input( FGElectricalComponent *c ) {
-        inputs.push_back( c );
-    }
-
-    void add_output( FGElectricalComponent *c ) {
-        outputs.push_back( c );
-    }
-
-    void add_switch( const string &s ) {
+    void add_switch( FGElectricalSwitch s ) {
         switches.push_back( s );
     }
 
-    string get_name() const { return ""; }
+    // set all switches to the specified state
+    void set_switches( bool state );
+
+    bool get_state();
 };
 
 
 /**
- * Model an electrical system.  This is a simple system with the
- * alternator hardwired to engine[0]/rpm
- *
- * Input properties:
- *
- * /engines/engine[0]/rpm
- *
- * Output properties:
- *
+ * Model an electrical system.  This is a fairly simplistic system
  * 
  */
 
-class FGElectricalSystem : public FGSubsystem
+class FGElectricalSystem : public SGSubsystem
 {
 
 public:
@@ -197,21 +231,26 @@ public:
     virtual void update (double dt);
 
     bool build ();
+    float propagate( FGElectricalComponent *node, double val, string s = "" );
     FGElectricalComponent *find ( const string &name );
 
+protected:
+
+    typedef vector<FGElectricalComponent *> comp_list;
+
 private:
 
     SGPropertyNode *config_props;
-    // SGPropertyNode_ptr _serviceable_node;
 
     bool enabled;
 
-    typedef vector<FGElectricalComponent *> comp_list;
-
     comp_list suppliers;
     comp_list buses;
     comp_list outputs;
     comp_list connectors;
+
+    SGPropertyNode *_volts_out;
+    SGPropertyNode *_amps_out;
 };