Se completa bastante el model y se crea un ejemplo que al parecer funciona

 bien en este caso!!!!!
 El Conduct tiene un hack para simular un sumidero.

diff --git a/Model/include/bomb.h b/Model/include/bomb.h
new file mode 100644 (file)
index 0000000..468bbb5
--- /dev/null
+++ b/Model/include/bomb.h
@@ -0,0 +1,42 @@
+
+#ifndef _BOMB_H_
+#define _BOMB_H_
+
+#include "source.h"
+
+namespace PlaQui {
+
+namespace Model {
+
+class Bomb:public Source {
+public:
+       Bomb(const std::string &_name);
+       ~Bomb();
+
+       virtual void update();
+       virtual void simulate();
+
+       virtual bool get_output();
+
+       virtual void recieve_msg(int msg, IConector *who, void *data);
+
+       void activate() { active = true; }
+       void deactivate() { active = false; }
+protected:
+       /** Define si la bomba esta abierta o no. Esto lo maneja la logica de
+        * control
+        */
+       bool open;
+       /** Define si la bomba esta activa, es decir, si el control manual esta en
+        * "on" 
+        */
+       bool active;
+private:
+       Bomb(const Bomb &):Source("null") {}
+       Bomb &operator = (const Bomb &) { return *this; }
+};
+
+}
+}
+
+#endif // _BOMB_H_

diff --git a/Model/include/conducto.h b/Model/include/conduct.h
similarity index 56%
rename from Model/include/conducto.h
rename to Model/include/conduct.h
index 95d67f5ebdbbaeffd9a3b3df7a0157d3b8062dfc..811ea26ac79ee2d63d0f7af0b8b841d2721f7c8c 100644 (file)
--- a/Model/include/conducto.h
+++ b/Model/include/conduct.h
@@ -3,14 +3,16 @@
 #ifndef _CONDUCTO_H_
 #define _CONDUCTO_H_
 
-#include "transporte.h"
+#include "transport.h"
 
 namespace PlaQui {
 
-class Conducto:public Transporte {
+namespace Model {
+                               
+class Conduct:public Transport {
 public:
-       Conducto(const std::string &_name);
-       virtual ~Conducto();
+       Conduct(const std::string &_name);
+       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
@@ -20,10 +22,12 @@ public:
 
 protected:
 private:
-       Conducto():Transporte("null") {}
-       Conducto &operator = (const Conducto &) { return (*this); }
+       Conduct():Transport("null") {}
+       Conduct &operator = (const Conduct &) { return (*this); }
 };
 
-}
+} // namespace Model
+} // namespace PlaQui
+
 #endif // _CONDUCTO_H_
 

diff --git a/Model/include/control.h b/Model/include/control.h
new file mode 100644 (file)
index 0000000..00c56fa
--- /dev/null
+++ b/Model/include/control.h
@@ -0,0 +1,31 @@
+
+#ifndef _CONTROL_H_
+#define _CONTROL_H_
+
+#include "plantitem.h"
+
+namespace PlaQui {
+
+namespace Model {
+
+/** Elementos que pueden ser automatizados */
+class Control:public PlantItem {
+public:
+       Control(const std::string &_name);
+       virtual ~Control();
+
+       virtual bool get_output() = 0;
+protected:
+       /*
+       LogicControl input;
+       LogicControl output;
+       */
+private:
+       Control(const Control &):PlantItem("null") {}
+       Control &operator = (const Control &) { return (*this); }
+};
+
+}
+}
+
+#endif // _CONTROL_H_

diff --git a/Model/include/iconector.h b/Model/include/iconector.h
index 44e1e32295ab00cbaa23851803d6658e273c4b61..eae2175e480432a8e85b493aad1f04f6f9d39587 100644 (file)
--- a/Model/include/iconector.h
+++ b/Model/include/iconector.h
@@ -7,6 +7,7 @@
 
 namespace PlaQui {
 
+namespace Model {
 /** Conector genérico de elementos
  */
 class IConector {
@@ -92,6 +93,8 @@ private:
        IConector &operator = (const IConector &) { return (*this); }
 };
 
-}
+} // namespace Model
+} // namespace PlaQui
 
 #endif // _I_CONECTOR_H_
+

diff --git a/Model/include/elementoplanta.h b/Model/include/plantitem.h
similarity index 80%
rename from Model/include/elementoplanta.h
rename to Model/include/plantitem.h
index f4a293542614c630cdda702c4a35bfce38004eb8..1e28b0bc0fb6adbf824d7c338f97a3d2fb67462e 100644 (file)
--- a/Model/include/elementoplanta.h
+++ b/Model/include/plantitem.h
@@ -9,12 +9,14 @@
 
 namespace PlaQui {
 
-class ElementoPlanta:public IConector {
+namespace Model {
+                               
+class PlantItem:public IConector {
 public:
        /// Constructor
-       ElementoPlanta(const std::string &_name);
-       ElementoPlanta(unsigned ins, unsigned outs);
-       virtual ~ElementoPlanta();
+       PlantItem(const std::string &_name);
+       PlantItem(unsigned ins, unsigned outs);
+       virtual ~PlantItem();
 
        // FIXME: ver que parametros seran necesarios
        virtual void send_fluid() {}
@@ -45,13 +47,14 @@ protected:
        RGB fluid_color;
        // es de solo lectura
        std::string name;
-
+       bool updated;
 private:
        // Hago que no se puedan copiar objetos ElementosPlanta
-       ElementoPlanta(const ElementoPlanta &):IConector(0,0) {}
-       ElementoPlanta &operator = (const ElementoPlanta &) { return (*this); }
+       PlantItem(const PlantItem &):IConector(0,0) {}
+       PlantItem &operator = (const PlantItem &) { return (*this); }
 };
 
+}
 }
 
 #endif

diff --git a/Model/include/source.h b/Model/include/source.h
new file mode 100644 (file)
index 0000000..48a9a12
--- /dev/null
+++ b/Model/include/source.h
@@ -0,0 +1,30 @@
+
+#ifndef _H_SOURCE_H_
+#define _H_SOURCE_H_
+
+#include "control.h"
+
+namespace PlaQui {
+
+namespace Model {
+
+/** Modela objetos desde donde fluye liquido */
+class Source:public Control {
+public:
+       Source(const std::string &_name);
+       virtual ~Source();
+
+       virtual bool get_output();
+
+       virtual void simulate();
+protected:
+       float max_flow;
+private:
+       Source(const Source &):Control("null") {}
+       Source &operator = (const Source &) { return *this; }
+};
+
+}
+}
+#endif // _H_SOURCE_H_
+

diff --git a/Model/include/transporte.h b/Model/include/transport.h
similarity index 59%
rename from Model/include/transporte.h
rename to Model/include/transport.h
index 04057b930f0bae0c87d4f4945d0e69144a33fab6..b6474b3c38d5336976a86396ac897744fe493234 100644 (file)
--- a/Model/include/transporte.h
+++ b/Model/include/transport.h
@@ -3,14 +3,16 @@
 #ifndef _TRANSPORTE_H_
 #define _TRANSPORTE_H_
 
-#include "elementoplanta.h"
+#include "plantitem.h"
 
 namespace PlaQui {
 
-class Transporte:public ElementoPlanta {
+namespace Model {
+
+class Transport:public PlantItem {
 public:
-       Transporte(const std::string &_name);
-       virtual ~Transporte();
+       Transport(const std::string &_name);
+       virtual ~Transport();
 
        float get_actual_flow() { return actual_flow; }
        float get_max_flow() { return max_flow; }
@@ -20,10 +22,11 @@ protected:
        float actual_flow;
        float max_flow;
 private:
-       Transporte():ElementoPlanta("null") {}
-       Transporte &operator = (const Transporte &) { return (*this); }
+       Transport():PlantItem("null") {}
+       Transport &operator = (const Transport &) { return (*this); }
 };
 
+}
 }
 #endif // _TRANSPORTE_H_
 

diff --git a/Model/src/bomb.cpp b/Model/src/bomb.cpp
new file mode 100644 (file)
index 0000000..9bae0a5
--- /dev/null
+++ b/Model/src/bomb.cpp
@@ -0,0 +1,62 @@
+
+#include "bomb.h"
+#include <iostream>
+
+using namespace PlaQui::Model;
+
+Bomb::Bomb(const std::string &_name):Source(_name)
+{
+       in_slots = 0;
+       out_slots = 1;
+       active = true;
+       open = true;
+       max_flow = 1;
+}
+
+Bomb::~Bomb()
+{
+}
+
+void Bomb::update()
+{
+       if (updated) return;
+       updated = true;
+       send_msg(OUT, MSG_QUERY_MAX_FLOW);
+}
+
+void Bomb::simulate()
+{
+       std::cout << name << "::Flujo entregado = " << (active && open)?max_flow:0;
+       std::cout << ((active && open)?" (funcionando)":" (apagada)") << std::endl;
+}
+
+bool Bomb::get_output()
+{
+       /* Si el corte fue manual, no puedo hacer nada */
+       if (active == false) return false;
+
+       /* Si no, depende del control automatico */
+       return open;
+}
+
+void Bomb::recieve_msg(int msg, IConector *who, void *data)
+{
+       switch (msg) {
+               case MSG_QUERY_MAX_FLOW: {
+                       // Me preguntan por el flujo máximo.
+                       // Primero me actualizo, y luego respondo
+                       update();
+                       float tmp = (active && open)?max_flow:0;
+                       who->recieve_msg(MSG_RESPONSE_MAX_FLOW, this, &tmp);
+               }
+               break;
+               case MSG_RESPONSE_MAX_FLOW: {
+                       max_flow = *((float *)data);
+               }
+               break;
+               default:
+                       Source::recieve_msg(msg, who, data);
+       }
+
+}
+

diff --git a/Model/src/conduct.cpp b/Model/src/conduct.cpp
new file mode 100644 (file)
index 0000000..495e94a
--- /dev/null
+++ b/Model/src/conduct.cpp
@@ -0,0 +1,66 @@
+
+#include "conduct.h"
+#include <iostream>
+
+using namespace PlaQui::Model;
+
+Conduct::Conduct(const std::string &_name):Transport(_name)
+{
+       max_flow = actual_flow = 0.0f;
+
+       // Inicio los parametros de conectores
+       in_slots = 1;
+       out_slots = 1;
+}
+
+Conduct::~Conduct()
+{
+}
+
+void Conduct::recieve_msg(int msg, IConector *who, void *data)
+{
+       switch (msg) {
+               case MSG_QUERY_MAX_FLOW: {
+                       // Me preguntan por el flujo máximo.
+                       // Primero me actualizo, y luego respondo
+                       update();
+                       float tmp = (actual_flow>max_flow)?max_flow:actual_flow;
+                       // FIXME : no tiene que ir
+                       if (out_list.size() == 0) tmp = max_flow;
+                       who->recieve_msg(MSG_RESPONSE_MAX_FLOW, this, &tmp);
+               }
+               break;
+               case MSG_RESPONSE_MAX_FLOW: {
+                       float max = *((float *)data);
+                       // Actualizo mi flujo en base a la respuesta
+                       if (max < actual_flow) {
+                               actual_flow = max;
+                       }
+               }
+               break;
+               default:
+                       Transport::recieve_msg(msg, who, data);
+       }
+}
+
+void Conduct::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(IN, MSG_QUERY_MAX_FLOW);
+       send_msg(OUT, MSG_QUERY_MAX_FLOW);
+}
+
+void Conduct::simulate()
+{
+       if (!updated) {
+               return;
+       }
+
+       std::cout << name << "::Flujo actual = " << actual_flow << std::endl;
+       updated = false;
+}
+

diff --git a/Model/src/conducto.cpp b/Model/src/conducto.cpp
deleted file mode 100644 (file)
index 0b5e9a2..0000000
--- a/Model/src/conducto.cpp
+++ /dev/null
@@ -1,40 +0,0 @@
-
-#include "conducto.h"
-
-using namespace PlaQui;
-
-Conducto::Conducto(const std::string &_name):Transporte(_name)
-{
-       max_flow = actual_flow = 0.0f;
-
-       // Inicio los parametros de conectores
-       in_slots = 1;
-       out_slots = 1;
-}
-
-Conducto::~Conducto()
-{
-}
-
-void Conducto::recieve_msg(int msg, IConector *who, void *data)
-{
-       switch (msg) {
-               case MSG_QUERY_MAX_FLOW: {
-                       // Me preguntan por el flujo máximo. Le respondo
-                       float tmp = actual_flow;
-                       who->recieve_msg(MSG_RESPONSE_MAX_FLOW, this, &tmp);
-               }
-               break;
-               case MSG_RESPONSE_MAX_FLOW: {
-                       float max = *((float *)data);
-                       // Actualizo mi flujo en base a la respuesta
-                       if (max < actual_flow) {
-                               actual_flow = max;
-                       }
-               }
-               break;
-               default:
-                       Transporte::recieve_msg(msg, who, data);
-       }
-}
-

diff --git a/Model/src/control.cpp b/Model/src/control.cpp
new file mode 100644 (file)
index 0000000..e297253
--- /dev/null
+++ b/Model/src/control.cpp
@@ -0,0 +1,13 @@
+
+#include "control.h"
+
+using namespace PlaQui::Model;
+
+Control::Control(const std::string &_name):PlantItem(_name)
+{
+}
+
+Control::~Control()
+{
+}
+

diff --git a/Model/src/elementoplanta.cpp b/Model/src/elementoplanta.cpp
deleted file mode 100644 (file)
index 833c757..0000000
--- a/Model/src/elementoplanta.cpp
+++ /dev/null
@@ -1,31 +0,0 @@
-
-
-#include "elementoplanta.h"
-
-using namespace PlaQui;
-
-ElementoPlanta::ElementoPlanta(const std::string &_name):IConector(0, 0)
-{
-       name = _name;
-}
-
-ElementoPlanta::ElementoPlanta(unsigned ins, unsigned outs):IConector(ins, outs)
-{
-}
-
-ElementoPlanta::~ElementoPlanta()
-{
-}
-       
-void ElementoPlanta::recieve_msg(int msg, IConector *who, void *data)
-{
-       switch (msg) {
-               case MSG_QUERY_MAX_FLOW:
-                       // TODO
-                       return;
-               break;
-               default:
-                       IConector::recieve_msg(msg, who, data);
-       }
-}
-

diff --git a/Model/src/iconector.cpp b/Model/src/iconector.cpp
index 4a27a9c2b758afbf635facf3a377b1efe1fab305..eb9a647f1e86bf83296c6f344a61591a0f484ac2 100644 (file)
--- a/Model/src/iconector.cpp
+++ b/Model/src/iconector.cpp
@@ -2,7 +2,7 @@
 
 #include "iconector.h"
 
-using namespace PlaQui;
+using namespace PlaQui::Model;
 
 IConector::IConector(unsigned in, unsigned out)
 {

diff --git a/Model/src/main.cpp b/Model/src/main.cpp
new file mode 100644 (file)
index 0000000..2b4e5a9
--- /dev/null
+++ b/Model/src/main.cpp
@@ -0,0 +1,51 @@
+
+/* Test pedorro a ver que pasa con lo que esta programado!! */
+/* Compilar : g++ -Wall -o test -I../include *.cpp */
+#include "bomb.h"
+#include "conduct.h"
+#include <unistd.h>
+
+using namespace std;
+using namespace PlaQui::Model;
+
+int main(int argc, char *argv[])
+{
+       Bomb *bomba;
+       Conduct *canio1;
+       Conduct *canio2;
+
+       bomba = new Bomb("bomba");
+       canio1 = new Conduct("cond_1");
+       canio1->set_max_flow(10);
+       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);
+
+       int i = 0;
+       while (i<10) {
+               bomba->update();
+               canio1->update();
+               canio2->update();
+
+               bomba->simulate();
+               canio1->simulate();
+               canio2->simulate();
+                                       
+               sleep(1);
+               if (i == 5) {
+                       bomba->deactivate();
+               }
+               i++;
+       }
+
+       delete bomba;
+       delete canio1;
+       delete canio2;
+       return 1;
+}
+
+

diff --git a/Model/src/plantitem.cpp b/Model/src/plantitem.cpp
new file mode 100644 (file)
index 0000000..aa3aa23
--- /dev/null
+++ b/Model/src/plantitem.cpp
@@ -0,0 +1,33 @@
+
+
+#include "plantitem.h"
+
+using namespace PlaQui::Model;
+
+PlantItem::PlantItem(const std::string &_name):IConector(0, 0)
+{
+       name = _name;
+       updated = false;
+}
+
+PlantItem::PlantItem(unsigned ins, unsigned outs):IConector(ins, outs)
+{
+       updated = false;
+}
+
+PlantItem::~PlantItem()
+{
+}
+       
+void PlantItem::recieve_msg(int msg, IConector *who, void *data)
+{
+       switch (msg) {
+               case MSG_QUERY_MAX_FLOW:
+                       // TODO
+                       return;
+               break;
+               default:
+                       IConector::recieve_msg(msg, who, data);
+       }
+}
+

diff --git a/Model/src/source.cpp b/Model/src/source.cpp
new file mode 100644 (file)
index 0000000..1362c1c
--- /dev/null
+++ b/Model/src/source.cpp
@@ -0,0 +1,26 @@
+
+#include "source.h"
+#include <iostream>
+
+using namespace PlaQui::Model;
+
+Source::Source(const std::string &_name):Control(_name)
+{
+}
+
+Source::~Source()
+{
+}
+
+bool Source::get_output()
+{
+       // Siempre esta abierta una Fuente, salvo que
+       // se indique lo contrario!
+       return true;
+}
+
+void Source::simulate()
+{
+       std::cout << name << "::Flujo entregado : " << max_flow << std::endl;
+}
+

diff --git a/Model/src/transport.cpp b/Model/src/transport.cpp
new file mode 100644 (file)
index 0000000..8951b39
--- /dev/null
+++ b/Model/src/transport.cpp
@@ -0,0 +1,14 @@
+
+#include "transport.h"
+
+using namespace PlaQui::Model;
+
+Transport::Transport(const std::string &_name):PlantItem(_name)
+{
+       max_flow = actual_flow = 0.0f;
+}
+
+Transport::~Transport()
+{
+}
+

diff --git a/Model/src/transporte.cpp b/Model/src/transporte.cpp
deleted file mode 100644 (file)
index 2bb2190..0000000
--- a/Model/src/transporte.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-
-#include "transporte.h"
-
-using namespace PlaQui;
-
-Transporte::Transporte(const std::string &_name):ElementoPlanta(_name)
-{
-       max_flow = actual_flow = 0.0f;
-}
-
-Transporte::~Transporte()
-{
-}
-