- Se agregan mas comentarios a las clases

 - Se agrega Union. Aun tiene un pequeño bug donde no actualiza bien su propio
	 flujo actual, pero si se actualiza bien el flujo de sus entradas
 - Se agrega una union al ejemplo, ahora se modela algo como :
   +---+      +---+
	 | B |      | B |
	 +---+      +---+
	   \         /
	cond\       /cond
			 \-----/
			  | U  |
				+---+
				  |
					|cond
					|
	B=bomba
	U=union
	cond=conducto

diff --git a/Model/include/bomb.h b/Model/include/bomb.h
index 468bbb56b955f26dfb6d2731d94fe99df47de70d..ebba1275bc72cb3fbf473114cd51db697edc8aa9 100644 (file)
--- a/Model/include/bomb.h
+++ b/Model/include/bomb.h
@@ -8,10 +8,27 @@ namespace PlaQui {
 
 namespace Model {
 
 
 namespace Model {
 

+/** Bomba hidráulica
+ *
+ *  La bomba es un elemento que toma líquido de alguna fuente
+ *  misteriosa y lo envía por su salida. La cantidad de fluido que
+ *  envía va a depender exclusivamente del sistema al cual está conectado.
+ *  La bomba es "inteligente", y es capaz de reducir el flujo que envía
+ *  dependiendo de las condiciones que le ponga el sistema, reduciendo
+ *  así el flujo de manera automática para evitar sobrecargas.
+ *
+ *  La bomba tiene 2 interruptores, uno manual y otro automático.
+ *  Si el manual está apagado, la bomba se considera apagada e ignora
+ *  todo mensage del interruptor automático. En esta condición envía
+ *  0 cuando se le consulta por su flojo máximo.
+ *
+ */

 class Bomb:public Source {
 public:
 class Bomb:public Source {
 public:

+       /// Constructor

        Bomb(const std::string &_name);
        Bomb(const std::string &_name);

-       ~Bomb();
+       /// Destructor
+       virtual ~Bomb();

 
        virtual void update();
        virtual void simulate();
 
        virtual void update();
        virtual void simulate();


@@ -20,7 +37,9 @@ public:
 
        virtual void recieve_msg(int msg, IConector *who, void *data);
 
 
        virtual void recieve_msg(int msg, IConector *who, void *data);
 

+       /// Activa la bomba

        void activate() { active = true; }
        void activate() { active = true; }

+       /// Desactiva la bomba

        void deactivate() { active = false; }
 protected:
        /** Define si la bomba esta abierta o no. Esto lo maneja la logica de
        void deactivate() { active = false; }
 protected:
        /** Define si la bomba esta abierta o no. Esto lo maneja la logica de

diff --git a/Model/include/conduct.h b/Model/include/conduct.h
index 811ea26ac79ee2d63d0f7af0b8b841d2721f7c8c..41921bac79f6461199bd3953a9be00f89b3e4560 100644 (file)
--- a/Model/include/conduct.h
+++ b/Model/include/conduct.h
@@ -8,16 +8,22 @@
 namespace PlaQui {
 
 namespace Model {
 namespace PlaQui {
 
 namespace Model {

-                               
+
+/** Conducto de transporte de fluido
+ *
+ *  Un conducto puede modelar tanto a un caño recto como a un
+ *  codo. Su principal objetivo es saber que flujo puede pasar por
+ *  el y consultar que flujo pasará en cada iteración
+ */

 class Conduct:public Transport {
 public:
 class Conduct:public Transport {
 public:

+       /// Constructor

        Conduct(const std::string &_name);
        Conduct(const std::string &_name);

+       /// Destructor

        virtual ~Conduct();
 
        virtual void recieve_msg(int msg, IConector *who, void *data);
        virtual ~Conduct();
 
        virtual void recieve_msg(int msg, IConector *who, void *data);

-       /// Hace que los elementos de la plata actualicen su flujo en esta etapa

        virtual void update();
        virtual void update();

-       /// Hace la simulación de esta iteración

        virtual void simulate();
 
 protected:
        virtual void simulate();
 
 protected:

diff --git a/Model/include/control.h b/Model/include/control.h
index 00c56faec470d60a31bab2aba796b3419839e18e..442962780870e3ef5f5f1de0b232ce5fd588e1e7 100644 (file)
--- a/Model/include/control.h
+++ b/Model/include/control.h
@@ -11,9 +11,12 @@ namespace Model {
 /** Elementos que pueden ser automatizados */
 class Control:public PlantItem {
 public:
 /** Elementos que pueden ser automatizados */
 class Control:public PlantItem {
 public:

+       /// Constructor

        Control(const std::string &_name);
        Control(const std::string &_name);

+       /// Destructor

        virtual ~Control();
 
        virtual ~Control();
 

+       /// Retorna un estado booleano dependiendo de su estado actual

        virtual bool get_output() = 0;
 protected:
        /*
        virtual bool get_output() = 0;
 protected:
        /*


@@ -29,3 +32,4 @@ private:
 }
 
 #endif // _CONTROL_H_
 }
 
 #endif // _CONTROL_H_

+

diff --git a/Model/include/iconector.h b/Model/include/iconector.h
index eae2175e480432a8e85b493aad1f04f6f9d39587..889e0980fb8e3facc151d069b008b4bb3d74a9b0 100644 (file)
--- a/Model/include/iconector.h
+++ b/Model/include/iconector.h
@@ -12,14 +12,18 @@ namespace Model {
  */
 class IConector {
 public:
  */
 class IConector {
 public:

-       /// Constructor
+       /** Constructor
+        *
+        *  \param in Cantidad de entradas
+        *  \param out Cantidad de salidas
+        */

        IConector(unsigned in, unsigned out);
        /// Destructor
        virtual ~IConector();
 
        /** Envía un mensage a los elementos conectados
         *
        IConector(unsigned in, unsigned out);
        /// Destructor
        virtual ~IConector();
 
        /** Envía un mensage a los elementos conectados
         *

-        *  Esvía un mensage a los elementos conectados a la entrada o
+        *  Envía un mensage a los elementos conectados a la entrada o

         *  a la salida.
         *  \param where Donde enviar el mensage, IConector::IN o IConector::OUT
         *  \param msg Mensage a enviar
         *  a la salida.
         *  \param where Donde enviar el mensage, IConector::IN o IConector::OUT
         *  \param msg Mensage a enviar

diff --git a/Model/include/plantitem.h b/Model/include/plantitem.h
index 1e28b0bc0fb6adbf824d7c338f97a3d2fb67462e..b07816f9f827a4cf40f1a56416e737270ee4fecb 100644 (file)
--- a/Model/include/plantitem.h
+++ b/Model/include/plantitem.h
@@ -10,21 +10,40 @@
 namespace PlaQui {
 
 namespace Model {
 namespace PlaQui {
 
 namespace Model {

-                               
+
+/** Elementos simulables en una planta
+ *
+ *  Todo elemento que pueda ser simulado en la planta debe
+ *  descender de esta clase.
+ */

 class PlantItem:public IConector {
 public:
 class PlantItem:public IConector {
 public:

-       /// Constructor
+       /** Constructor
+        *
+        *  \param _name Nombre único que identifica el objeto
+        */

        PlantItem(const std::string &_name);
        PlantItem(const std::string &_name);

+       /// FIXME : agregar el nombre!

        PlantItem(unsigned ins, unsigned outs);
        PlantItem(unsigned ins, unsigned outs);

+       /// Destructor

        virtual ~PlantItem();
 
        // FIXME: ver que parametros seran necesarios
        virtual ~PlantItem();
 
        // FIXME: ver que parametros seran necesarios

+       // TODO : ver si no son inutiles!!!

        virtual void send_fluid() {}
        virtual void receive_fluid() {}
 
        virtual void send_fluid() {}
        virtual void receive_fluid() {}
 

-       /// Hace que los elementos de la plata actualicen su flujo en esta etapa
+       /** Ejecuta la fase de actualización.
+        *
+        *  Durante la fase de actualización los objetos se comunican entre
+        *  sí para determinar cual es el flujo que manejan en una iteración.
+        */

        virtual void update() = 0;
        virtual void update() = 0;

-       /// Hace la simulación de esta iteración
+       /** Hace la simulación de esta iteración
+        *
+        *  Por simulacion se entiende que el modelo debe avisar a las vistas
+        *  que ya está actualizado para que el usuario vea los resultados.
+        */

        virtual void simulate() = 0;
 
        /// Setea el nuevo color del fluido
        virtual void simulate() = 0;
 
        /// Setea el nuevo color del fluido


@@ -32,11 +51,15 @@ public:
        /// Retorna el actual color del fluido
        const RGB &getColor() { return fluid_color; }
 
        /// Retorna el actual color del fluido
        const RGB &getColor() { return fluid_color; }
 

+       /** Recive un mensage y lo procesa
+        *  
+        *  \see IConector::recieve_msg
+        */

        virtual void recieve_msg(int msg, IConector *who, void *data);
 
        /// Mensages manejados por los elementos de la planta
        enum {
        virtual void recieve_msg(int msg, IConector *who, void *data);
 
        /// Mensages manejados por los elementos de la planta
        enum {

-               MSG_QUERY_MAX_FLOW = IConector::MSG_LAST, ///< pregunta por el maximo flujo
+               MSG_QUERY_MAX_FLOW = IConector::MSG_LAST, ///< preguntar por el máximo flujo

                MSG_RESPONSE_MAX_FLOW, ///< responde al mensage QUERY_MAX_FLOW. data == float
                MSG_LAST
        };
                MSG_RESPONSE_MAX_FLOW, ///< responde al mensage QUERY_MAX_FLOW. data == float
                MSG_LAST
        };

diff --git a/Model/include/source.h b/Model/include/source.h
index 41a7266c85a1db6dad679c4185fff3a9a7d7a078..fde6511666fd824ce4e17f4104e7aa5f1026dc18 100644 (file)
--- a/Model/include/source.h
+++ b/Model/include/source.h
@@ -11,14 +11,19 @@ namespace Model {
 /** Modela objetos desde donde fluye liquido */
 class Source:public Control {
 public:
 /** Modela objetos desde donde fluye liquido */
 class Source:public Control {
 public:

+       /// Constructor

        Source(const std::string &_name);
        Source(const std::string &_name);

+       /// Destructor

        virtual ~Source();
 
        virtual bool get_output();
 
        virtual void simulate();
        virtual ~Source();
 
        virtual bool get_output();
 
        virtual void simulate();

+       /// Retorna el flujo que entrega actualmente

        float get_actual_flow() { return actual_flow; }
        float get_actual_flow() { return actual_flow; }

+       /// Retorna el flujo máximo capaz de entregar

        float get_max_flow() { return max_flow; }
        float get_max_flow() { return max_flow; }

+       /// Asigna el flojo máximo capaz de entregar

        void  set_max_flow(float _f) { max_flow = _f; }
 protected:
        float max_flow;
        void  set_max_flow(float _f) { max_flow = _f; }
 protected:
        float max_flow;

diff --git a/Model/include/transport.h b/Model/include/transport.h
index b6474b3c38d5336976a86396ac897744fe493234..d27ca0dbc8f436f3505615eae40c3d791dc28714 100644 (file)
--- a/Model/include/transport.h
+++ b/Model/include/transport.h
@@ -9,13 +9,22 @@ namespace PlaQui {
 
 namespace Model {
 
 
 namespace Model {
 

+/** Elementos que permiten transportar fluidos
+ *
+ *  Estos objetos son capaces de transportar fluidos solamente.
+ */

 class Transport:public PlantItem {
 public:
 class Transport:public PlantItem {
 public:

+       /// Constructor

        Transport(const std::string &_name);
        Transport(const std::string &_name);

+       /// Destructor

        virtual ~Transport();
 
        virtual ~Transport();
 

+       /// Retorna el flujo actual que maneja el objeto.

        float get_actual_flow() { return actual_flow; }
        float get_actual_flow() { return actual_flow; }

+       /// Retorna el flujo máximo soportado por el objeto

        float get_max_flow() { return max_flow; }
        float get_max_flow() { return max_flow; }

+       /// Asigna el flujo máximo a manejar

        void  set_max_flow(float _f) { max_flow = _f; }
 protected:
        // Es de solo lectura, no hay set
        void  set_max_flow(float _f) { max_flow = _f; }
 protected:
        // Es de solo lectura, no hay set

diff --git a/Model/include/union.h b/Model/include/union.h
new file mode 100644 (file)
index 0000000..71a8791
--- /dev/null
+++ b/Model/include/union.h
@@ -0,0 +1,28 @@
+
+#ifndef _UNION_H_
+#define _UNION_H_
+
+#include "transport.h"
+
+namespace PlaQui {
+
+namespace Model {
+
+class Union:public Transport {
+public:
+       Union(const std::string &_name);
+       virtual ~Union();
+
+       virtual void recieve_msg(int msg, IConector *who, void *data);
+       virtual void update();
+       virtual void simulate();
+protected:
+private:
+       Union(const Union &):Transport("null") {}
+       Union &operator = (const Union &) { return *this; }
+};
+
+}
+}
+
+#endif //_UNION_H_

diff --git a/Model/src/bomb.cpp b/Model/src/bomb.cpp
index b9159a66706a8e4a1963a996236199b692d2d649..82302b0da43c1bd1607cafb74299d4d91d87de09 100644 (file)
--- a/Model/src/bomb.cpp
+++ b/Model/src/bomb.cpp
@@ -30,6 +30,7 @@ void Bomb::simulate()
        std::cout << name << "::Flujo actual = " << ((active && open)?actual_flow:0) \
        << " de " << max_flow;
        std::cout << ((active && open)?" (funcionando)":" (apagada)") << std::endl;
        std::cout << name << "::Flujo actual = " << ((active && open)?actual_flow:0) \
        << " de " << max_flow;
        std::cout << ((active && open)?" (funcionando)":" (apagada)") << std::endl;

+       updated = false;

 }
 
 bool Bomb::get_output()
 }
 
 bool Bomb::get_output()

diff --git a/Model/src/conduct.cpp b/Model/src/conduct.cpp
index 495e94a7bb5f129913e86c71fda77f7714c61968..5eb885cc327f361d09c70a05f0036731d7cadaae 100644 (file)
--- a/Model/src/conduct.cpp
+++ b/Model/src/conduct.cpp
@@ -50,8 +50,8 @@ void Conduct::update()
        // Seteo mi actualizar en true para evitar entrar de nuevo
        actual_flow = 99999;
        updated = true;
        // Seteo mi actualizar en true para evitar entrar de nuevo
        actual_flow = 99999;
        updated = true;

-       send_msg(IN, MSG_QUERY_MAX_FLOW);

        send_msg(OUT, MSG_QUERY_MAX_FLOW);
        send_msg(OUT, MSG_QUERY_MAX_FLOW);

+       send_msg(IN, MSG_QUERY_MAX_FLOW);

 }
 
 void Conduct::simulate()
 }
 
 void Conduct::simulate()

diff --git a/Model/src/iconector.cpp b/Model/src/iconector.cpp
index eb9a647f1e86bf83296c6f344a61591a0f484ac2..3307305eefed82dd58437632228cc88d5be9e4e5 100644 (file)
--- a/Model/src/iconector.cpp
+++ b/Model/src/iconector.cpp
@@ -54,6 +54,7 @@ bool IConector::connect(IConector *obj, int place)
                        } else {
                                return false; // no se pudo conectar!
                        }
                        } else {
                                return false; // no se pudo conectar!
                        }

+               break;

                case OUT:
                        if (out_list.size() <= out_slots) {
                                out_list.push_back(obj);
                case OUT:
                        if (out_list.size() <= out_slots) {
                                out_list.push_back(obj);

diff --git a/Model/src/main.cpp b/Model/src/main.cpp
index 237e158770bf98af83eee5e10622be36ab783714..01f9ecb402d17fb0a174cc94325d389568766ac0 100644 (file)
--- a/Model/src/main.cpp
+++ b/Model/src/main.cpp
@@ -3,6 +3,7 @@
 /* Compilar : g++ -Wall -o test -I../include *.cpp */
 #include "bomb.h"
 #include "conduct.h"
 /* Compilar : g++ -Wall -o test -I../include *.cpp */
 #include "bomb.h"
 #include "conduct.h"

+#include "union.h"

 #include <unistd.h>
 
 using namespace std;
 #include <unistd.h>
 
 using namespace std;


@@ -10,42 +11,70 @@ using namespace PlaQui::Model;
 
 int main(int argc, char *argv[])
 {
 
 int main(int argc, char *argv[])
 {

-       Bomb *bomba;
+       Bomb *bomba1, *bomba2;

        Conduct *canio1;
        Conduct *canio2;
        Conduct *canio1;
        Conduct *canio2;

+       Conduct *salida;
+       Union *union1;
+       

 
 

-       bomba = new Bomb("bomba");
-       bomba->set_max_flow(3);
+       bomba1 = new Bomb("bomba1");
+       bomba1->set_max_flow(3);
+       bomba2 = new Bomb("bomba2");
+       bomba2->set_max_flow(5);

        canio1 = new Conduct("cond_1");
        canio1 = new Conduct("cond_1");

-       canio1->set_max_flow(10);
+       canio1->set_max_flow(5);

        canio2 = new Conduct("cond_2");
        canio2->set_max_flow(5);
 
        canio2 = new Conduct("cond_2");
        canio2->set_max_flow(5);
 

-       bomba->connect(canio1, IConector::OUT);
-       canio1->connect(bomba, IConector::IN);
-       canio1->connect(canio2, IConector::OUT);
-       canio2->connect(canio1, IConector::IN);
+       union1 = new Union("union");
+       union1->set_max_flow(5);
+       salida = new Conduct("salida");
+       salida->set_max_flow(10);
+
+       bomba1->connect(canio1, IConector::OUT);
+       canio1->connect(bomba1, IConector::IN);
+       canio1->connect(union1, IConector::OUT);
+
+       bomba2->connect(canio2, IConector::OUT);
+       canio2->connect(bomba2, IConector::IN);
+       canio2->connect(union1, IConector::OUT);
+
+       union1->connect(canio1, IConector::IN);
+       union1->connect(canio2, IConector::IN);
+       union1->connect(salida, IConector::OUT);
+
+       salida->connect(union1, IConector::IN);

 
        int i = 0;
        while (i<10) {
 
        int i = 0;
        while (i<10) {

-               bomba->update();
+               bomba1->update();
+               bomba2->update();

                canio1->update();
                canio2->update();
                canio1->update();
                canio2->update();

+               salida->update();
+               union1->update();

 
 

-               bomba->simulate();
+               bomba1->simulate();
+               bomba2->simulate();

                canio1->simulate();
                canio2->simulate();
                canio1->simulate();
                canio2->simulate();

+               salida->simulate();
+               union1->simulate();

                                        
                sleep(1);
                if (i == 5) {
                                        
                sleep(1);
                if (i == 5) {

-                       bomba->deactivate();
+                       bomba1->deactivate();

                }
                i++;
        }
 
                }
                i++;
        }
 

-       delete bomba;
+       delete bomba1;
+       delete bomba2;

        delete canio1;
        delete canio2;
        delete canio1;
        delete canio2;

+       delete salida;
+       delete union1;

        return 1;
 }
 
        return 1;
 }
 

diff --git a/Model/src/union.cpp b/Model/src/union.cpp
new file mode 100644 (file)
index 0000000..331e953
--- /dev/null
+++ b/Model/src/union.cpp
@@ -0,0 +1,78 @@
+
+#include "union.h"
+#include <iostream>
+
+using namespace PlaQui::Model;
+
+Union::Union(const std::string &_name):Transport(_name)
+{
+       in_slots = 2;
+       out_slots = 1;
+       max_flow = actual_flow = 0.0f;
+}
+
+Union::~Union()
+{
+}
+
+void Union::recieve_msg(int msg, IConector *who, void *data)
+{
+       int pos = OUT;
+
+       // Verifico si esta conectado a mi entrada
+       std::list<IConector *>::iterator i;
+       for(i=in_list.begin(); i!=in_list.end(); i++) {
+               if ((*i) == who) pos = IN;
+       }
+       
+       switch (msg) {
+               case MSG_QUERY_MAX_FLOW: {
+                       // Me preguntan por el flujo máximo.
+                       // Primero me actualizo, y luego respondo
+                       update();
+                       float tmp;
+
+                       tmp = (actual_flow<max_flow)?actual_flow:max_flow;
+                       if (pos == IN) {
+                                       // Si esta conectado a mi entrada, le puedo aceptar
+                                       // solo la mitad del flujo maximo
+                                       tmp /= 2;
+                       }
+                       who->recieve_msg(MSG_RESPONSE_MAX_FLOW, this, &tmp);
+               }
+               break;
+               case MSG_RESPONSE_MAX_FLOW: {
+                       float max = *((float *)data);
+                       if (pos == OUT) {
+                               if (max < actual_flow)  actual_flow = max;
+                       } else {
+                               if ((2*max) < actual_flow) actual_flow = 2*max;
+                       }
+               }
+               break;
+               default:
+                       Transport::recieve_msg(msg, who, data);
+       }
+}
+
+void Union::update()
+{
+       // Si ya me actualice, no lo tengo que hacer de nuevo
+       if (updated) return;
+       // Seteo mi actualizar en true para evitar entrar de nuevo
+       actual_flow = 99999;
+       updated = true;
+       send_msg(OUT, MSG_QUERY_MAX_FLOW);
+       send_msg(IN, MSG_QUERY_MAX_FLOW);
+}
+
+void Union::simulate()
+{
+       if (!updated) {
+               return;
+       }
+
+       std::cout << name << "::Flujo actual = " << actual_flow << std::endl;
+       updated = false;
+}
+