* Agrego lógica de control al modelo!!. Implementadas :

     - And
		 - Or
		 - ByPass
		 - LogicControl (Abstracta)
 * Pump y Exclusa ya tiene sus ByPass funcionando a pleno :-)

diff --git a/Model/include/and.h b/Model/include/and.h
new file mode 100644 (file)
index 0000000..be71958
--- /dev/null
+++ b/Model/include/and.h
@@ -0,0 +1,34 @@
+
+#ifndef _AND_H_
+#define _AND_H_
+
+#include "logiccontrol.h"
+#include <iostream>
+#include <limits.g>
+
+namespace PlaQui {
+namespace Model {
+
+class And:LogicControl {
+public:
+       And():LogicControl(MAX_INT,1) {}
+       virtual ~And() {}
+
+       virtual bool get_output() {
+               LogicControl *mi_entrada;
+               bool mi_salida = true;
+               /* Si tengo alguien conectado */
+               std::list<IConector *>::iterator it;
+               for(it = in_list.begin(); it != in_list.end(); it++) {
+                       mi_entrada = *it;
+                       mi_salida &&= mi_entrada->get_output();
+               }
+               return mi_salida;
+       }
+};
+
+}
+}
+
+#endif // _And_H_
+

diff --git a/Model/include/bypass.h b/Model/include/bypass.h
new file mode 100644 (file)
index 0000000..4282752
--- /dev/null
+++ b/Model/include/bypass.h
@@ -0,0 +1,61 @@
+
+#ifndef _BYPASS_H_
+#define _BYPASS_H_
+
+#include "logiccontrol.h"
+#include <iostream>
+#include <limits.h>
+#include "control.h"
+
+namespace PlaQui {
+namespace Model {
+
+class ByPass:public LogicControl {
+public:
+       ByPass():LogicControl(1,1) { control = NULL; }
+       virtual ~ByPass() {}
+
+       virtual bool get_output() {
+               LogicControl *mi_entrada;
+               bool mi_salida = false;
+               // Si tengo conectado algo a mi salida, es porque
+               // le tengo que consultar a el.
+               // Si no tengo nadia a mi salida, es porque tengo 
+               // que consultar a mis entradas
+               if (control == NULL) {
+                       // No tengo nadie a mi salida!, pregunto a mis entradas, si es
+                       // que tengo!!
+                       if (in_list.begin() != in_list.end()) {
+                               mi_entrada = (LogicControl *)(*in_list.begin());
+                               mi_salida = mi_entrada->get_output();
+                       } else {
+                               mi_salida = true; // Paso true por defecto
+                       }
+               } else {
+                       mi_salida = control->get_output();
+               }
+
+               return mi_salida;
+       }
+       /** Setea el objeto a controlar
+        *
+        *  El ByPass puede ser utilizado para consultar el estado
+        *  de un elemento Control (utilizado en el slot output de
+        *  la lógica de control) o para que un elemento de Control
+        *  le pregunte por que valor tiene que tener a su entrada.
+        *  Si Control == NULL se asume que esta funcionando como entrada
+        *  y en caso contrario como salida de un objeto Control.
+        *  \param NULL No controla a nadie
+        *  \param Objeto Controla al objeto pasado
+        */
+       void set_control(Control *c) { control = c; }
+protected:
+       /// Objeto a controlar
+       Control *control;
+};
+
+}
+}
+
+#endif // _OR_H_
+

diff --git a/Model/include/control.h b/Model/include/control.h
index 442962780870e3ef5f5f1de0b232ce5fd588e1e7..3763da9f38de95061fe41e1035630bef3bc223f5 100644 (file)
--- a/Model/include/control.h
+++ b/Model/include/control.h
@@ -3,6 +3,7 @@
 #define _CONTROL_H_
 
 #include "plantitem.h"
 #define _CONTROL_H_
 
 #include "plantitem.h"

+#include "logiccontrol.h"

 
 namespace PlaQui {
 
 
 namespace PlaQui {
 


@@ -19,10 +20,8 @@ public:
        /// Retorna un estado booleano dependiendo de su estado actual
        virtual bool get_output() = 0;
 protected:
        /// Retorna un estado booleano dependiendo de su estado actual
        virtual bool get_output() = 0;
 protected:

-       /*
-       LogicControl input;
-       LogicControl output;
-       */
+       LogicControl *input;
+       LogicControl *output;

 private:
        Control(const Control &):PlantItem("null") {}
        Control &operator = (const Control &) { return (*this); }
 private:
        Control(const Control &):PlantItem("null") {}
        Control &operator = (const Control &) { return (*this); }

diff --git a/Model/include/exclusa.h b/Model/include/exclusa.h
index db24be4c098873b3a537b97372fb1adbe4c83492..75ab185c50897e3e4e05aac371e714841ec12ac5 100644 (file)
--- a/Model/include/exclusa.h
+++ b/Model/include/exclusa.h
@@ -3,6 +3,7 @@
 #define _EXCLUSE_H_
 
 #include "control.h"
 #define _EXCLUSE_H_
 
 #include "control.h"

+#include "bypass.h"

 
 namespace PlaQui {
 
 
 namespace PlaQui {
 

diff --git a/Model/include/logiccontrol.h b/Model/include/logiccontrol.h
new file mode 100644 (file)
index 0000000..758f238
--- /dev/null
+++ b/Model/include/logiccontrol.h
@@ -0,0 +1,36 @@
+
+#ifndef _LOGIC_CONTROL_H_
+#define _LOGIC_CONTROL_H_
+
+#include "iconector.h"
+
+namespace PlaQui {
+namespace Model {
+
+/** Modelo de control lógico para automatización
+ *
+ */
+class LogicControl:public IConector {
+public:
+       /** Constructor
+        *
+        *  \param ins Cantidad de entradas
+        *  \param outs Cantidad de salidas
+        */
+       LogicControl(int ins, int outs):IConector(ins, outs) {}
+       /// Destructor
+       virtual ~LogicControl() {}
+
+       /** Retorna el estado actual.
+        *
+        *  Esta función retorna un valor booleano resultado
+        *  de aplicar la operación lógica que cada hijo decida
+        *  implementar.
+        */
+       virtual bool get_output() = 0;
+};
+
+}
+}
+#endif // _LOGIC_CONTROL_H_
+

diff --git a/Model/include/not.h b/Model/include/not.h
new file mode 100644 (file)
index 0000000..5e74940
--- /dev/null
+++ b/Model/include/not.h
@@ -0,0 +1,33 @@
+
+#ifndef _NOT_H_
+#define _NOT_H_
+
+#include "logiccontrol.h"
+#include <iostream>
+
+namespace PlaQui {
+namespace Model {
+
+class Not:LogicControl {
+       Not():LogicControl(1,1) {}
+       virtual ~Not() {}
+
+       virtual bool get_output() {
+               LogicControl *mi_entrada;
+               bool mi_salida;
+               /* Si tengo alguien conectado */
+               if (in_list.begin() != in_list.end()) {
+                       mi_entrada = (LogicControl *)(*in_list.begin());
+                       mi_salida = !(mi_entrada->get_output());
+                       return mi_salida;
+               }
+               std::cout << "NOT NO CONECTADO" << std::endl;
+               return false;
+       }
+}
+
+}
+}
+
+#endif // _NOT_H_
+

diff --git a/Model/include/or.h b/Model/include/or.h
new file mode 100644 (file)
index 0000000..502fe41
--- /dev/null
+++ b/Model/include/or.h
@@ -0,0 +1,34 @@
+
+#ifndef _OR_H_
+#define _OR_H_
+
+#include "logiccontrol.h"
+#include <iostream>
+#include <limits.g>
+
+namespace PlaQui {
+namespace Model {
+
+class Or:LogicControl {
+public:
+       Or():LogicControl(MAX_INT,1) {}
+       virtual ~Or() {}
+
+       virtual bool get_output() {
+               LogicControl *mi_entrada;
+               bool mi_salida = false;
+               /* Si tengo alguien conectado */
+               std::list<IConector *>::iterator it;
+               for(it = in_list.begin(); it != in_list.end(); it++) {
+                       mi_entrada = *it;
+                       mi_salida ||= mi_entrada->get_output();
+               }
+               return mi_salida;
+       }
+};
+
+}
+}
+
+#endif // _OR_H_
+

diff --git a/Model/include/pump.h b/Model/include/pump.h
index 6d137623b4e9336b72e677c83141bde609e258e7..b7b1575fafe11665b5806269aad42594f8c526b5 100644 (file)
--- a/Model/include/pump.h
+++ b/Model/include/pump.h
@@ -3,6 +3,7 @@
 #define _BOMB_H_
 
 #include "source.h"
 #define _BOMB_H_
 
 #include "source.h"

+#include "bypass.h"

 
 namespace PlaQui {
 
 
 namespace PlaQui {
 

diff --git a/Model/src/exclusa.cpp b/Model/src/exclusa.cpp
index 553c8cea6edf197f15bc56c522614dcf50a86075..326a7b9e04df00788edef54cb5610ec8803ef250 100644 (file)
--- a/Model/src/exclusa.cpp
+++ b/Model/src/exclusa.cpp
@@ -8,6 +8,10 @@ Exclusa::Exclusa(const std::string &_name):Control(_name)
 {
        open = true;
        in_slots = out_slots = 1;
 {
        open = true;
        in_slots = out_slots = 1;

+       // Genero mi logica de control
+       input = new ByPass();
+       output = new ByPass();
+       ((ByPass *)output)->set_control(this);

 }
 
 Exclusa::~Exclusa()
 }
 
 Exclusa::~Exclusa()


@@ -16,7 +20,8 @@ Exclusa::~Exclusa()
 
 void Exclusa::update(int dir)
 {
 
 void Exclusa::update(int dir)
 {

-       // no hace nada
+       // Mi entrada define mi estado
+       open = input->get_output();

 }
 
 void Exclusa::simulate()
 }
 
 void Exclusa::simulate()

diff --git a/Model/src/pump.cpp b/Model/src/pump.cpp
index 78d4dcd9f2e4ee6d3aaf96072e2700093f95f5a3..7f1ace4a325ffba404d61f15492e57fbd8dd16f5 100644 (file)
--- a/Model/src/pump.cpp
+++ b/Model/src/pump.cpp
@@ -11,6 +11,9 @@ Pump::Pump(const std::string &_name):Source(_name),Control(_name)
        active = true;
        open = true;
        max_flow = actual_flow = 0.0f;
        active = true;
        open = true;
        max_flow = actual_flow = 0.0f;

+       input = new ByPass();
+       output = new ByPass();
+       ((ByPass *)output)->set_control(this);

 }
 
 Pump::~Pump()
 }
 
 Pump::~Pump()


@@ -20,6 +23,8 @@ Pump::~Pump()
 void Pump::update(int dir)
 {
        if (updated) return;
 void Pump::update(int dir)
 {
        if (updated) return;

+       // Me fijo si me tengo que apagar automaticamente
+       open = input->get_output();

        if (active && open)
                actual_flow = max_flow;
        else
        if (active && open)
                actual_flow = max_flow;
        else