From: Ricardo Markiewicz Date: Tue, 28 Oct 2003 23:58:35 +0000 (+0000) Subject: - Se cambia bomb por Pump, que es mas representativo en ingles a igual X-Git-Tag: svn_import~353 X-Git-Url: https://git.llucax.com/z.facultad/75.42/plaqui.git/commitdiff_plain/70d2e24643727ab1ea48e1793d609d27b7d21fed?ds=sidebyside - Se cambia bomb por Pump, que es mas representativo en ingles a igual traduccion - Se agregan Sumideros (Drain) y Drenaje (Drainage) - Se agrega Splitter - La Union no funciona como debe. Cuestiones de diseño que tengo que resolver - Nuevo ejemplo con Splitter y Drenaje - Se actualiza diagrama de clases Salvando por la Union, el modelo esta casi listo. Las clases que faltan agregar son triviales. El problema de la Union lo estoy replanteando. La logica de control se agrega en breve. --- diff --git a/Model/include/conduct.h b/Model/include/conduct.h index 41921ba..7013622 100644 --- a/Model/include/conduct.h +++ b/Model/include/conduct.h @@ -23,7 +23,7 @@ public: virtual ~Conduct(); virtual void recieve_msg(int msg, IConector *who, void *data); - virtual void update(); + virtual void update(int dir=OUT); virtual void simulate(); protected: diff --git a/Model/include/drain.h b/Model/include/drain.h new file mode 100644 index 0000000..a24c9a3 --- /dev/null +++ b/Model/include/drain.h @@ -0,0 +1,39 @@ + +#ifndef _H_DRAIN_H +#define _H_DRAIN_H + +#include "control.h" + +namespace PlaQui { + +namespace Model { + +/** Modela objetos que recibe liquido */ +class Drain:public Control { +public: + /// Constructor + Drain(const std::string &_name); + /// Destructor + virtual ~Drain(); + + virtual bool get_output(); + + virtual void simulate(); + /// Retorna el flujo que entrega actualmente + float get_actual_flow() { return actual_flow; } + /// Retorna el flujo máximo capaz de entregar + float get_capacity() { return capacity; } + /// Asigna el flojo máximo capaz de entregar + virtual void set_capacity(float _f) { capacity = _f; } +protected: + float capacity; + float actual_flow; +private: + Drain(const Drain &):Control("null") {} + Drain &operator = (const Drain &) { return *this; } +}; + +} +} +#endif // _H_SOURCE_H_ + diff --git a/Model/include/drainage.h b/Model/include/drainage.h new file mode 100644 index 0000000..0491fff --- /dev/null +++ b/Model/include/drainage.h @@ -0,0 +1,36 @@ + +#ifndef _DRAINAGE_H_ +#define _DRAINAGE_H_ + +#include "drain.h" + +namespace PlaQui { + +namespace Model { + +/** Dranaje + * + */ +class Drainage:public Drain { +public: + /// Constructor + Drainage(const std::string &_name); + /// Destructor + virtual ~Drainage(); + + virtual void update(int dir=OUT); + virtual void simulate(); + + virtual void recieve_msg(int msg, IConector *who, void *data); + + virtual void set_capacity(float _f) { /* IGNORO EL CAMBIO DE CAPACIDAD! */ } +protected: +private: + Drainage(const Drainage &):Drain("null") {} + Drainage &operator = (const Drainage &) { return *this; } +}; + +} +} + +#endif // _DRAINAGE_H_ diff --git a/Model/include/iconector.h b/Model/include/iconector.h index 889e098..916d341 100644 --- a/Model/include/iconector.h +++ b/Model/include/iconector.h @@ -28,7 +28,7 @@ public: * \param where Donde enviar el mensage, IConector::IN o IConector::OUT * \param msg Mensage a enviar */ - void send_msg(int where, int msg); + void send_msg(int where, int msg, void *data=NULL); /** Recibe un mensage * diff --git a/Model/include/plantitem.h b/Model/include/plantitem.h index b07816f..70fd6ac 100644 --- a/Model/include/plantitem.h +++ b/Model/include/plantitem.h @@ -38,7 +38,7 @@ public: * 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(int dir=OUT) = 0; /** Hace la simulación de esta iteración * * Por simulacion se entiende que el modelo debe avisar a las vistas @@ -59,7 +59,8 @@ public: /// Mensages manejados por los elementos de la planta enum { - MSG_QUERY_MAX_FLOW = IConector::MSG_LAST, ///< preguntar por el máximo flujo + MSG_QUERY_MAX_FLOW_OUT = IConector::MSG_LAST, ///< flujo maximo a la salida + MSG_QUERY_MAX_FLOW_IN, ///< flujo maximo a la entrada MSG_RESPONSE_MAX_FLOW, ///< responde al mensage QUERY_MAX_FLOW. data == float MSG_LAST }; diff --git a/Model/include/bomb.h b/Model/include/pump.h similarity index 86% rename from Model/include/bomb.h rename to Model/include/pump.h index ebba127..ab7966f 100644 --- a/Model/include/bomb.h +++ b/Model/include/pump.h @@ -23,14 +23,14 @@ namespace Model { * 0 cuando se le consulta por su flojo máximo. * */ -class Bomb:public Source { +class Pump:public Source { public: /// Constructor - Bomb(const std::string &_name); + Pump(const std::string &_name); /// Destructor - virtual ~Bomb(); + virtual ~Pump(); - virtual void update(); + virtual void update(int dir=OUT); virtual void simulate(); virtual bool get_output(); @@ -51,8 +51,8 @@ protected: */ bool active; private: - Bomb(const Bomb &):Source("null") {} - Bomb &operator = (const Bomb &) { return *this; } + Pump(const Pump &):Source("null") {} + Pump &operator = (const Pump &) { return *this; } }; } diff --git a/Model/include/splitter.h b/Model/include/splitter.h new file mode 100644 index 0000000..7adbb49 --- /dev/null +++ b/Model/include/splitter.h @@ -0,0 +1,28 @@ + +#ifndef _SPLITTER_H +#define _SPLITTER_H + +#include "transport.h" + +namespace PlaQui { + +namespace Model { + +class Splitter:public Transport { +public: + Splitter(const std::string &_name); + virtual ~Splitter(); + + virtual void recieve_msg(int msg, IConector *who, void *data); + virtual void update(int dir=OUT); + virtual void simulate(); +protected: +private: + Splitter(const Splitter &):Transport("null") {} + Splitter &operator = (const Splitter &) { return *this; } +}; + +} +} + +#endif //_SPLITTER_H diff --git a/Model/include/union.h b/Model/include/union.h index 71a8791..b08bc23 100644 --- a/Model/include/union.h +++ b/Model/include/union.h @@ -14,9 +14,11 @@ public: virtual ~Union(); virtual void recieve_msg(int msg, IConector *who, void *data); - virtual void update(); + virtual void update(int dir=OUT); virtual void simulate(); protected: + int in_on_zero; + int in_ready; private: Union(const Union &):Transport("null") {} Union &operator = (const Union &) { return *this; } diff --git a/Model/src/conduct.cpp b/Model/src/conduct.cpp index 5eb885c..4a4e731 100644 --- a/Model/src/conduct.cpp +++ b/Model/src/conduct.cpp @@ -11,6 +11,7 @@ Conduct::Conduct(const std::string &_name):Transport(_name) // Inicio los parametros de conectores in_slots = 1; out_slots = 1; + actual_flow = 9999; } Conduct::~Conduct() @@ -20,14 +21,19 @@ Conduct::~Conduct() void Conduct::recieve_msg(int msg, IConector *who, void *data) { switch (msg) { - case MSG_QUERY_MAX_FLOW: { + case MSG_QUERY_MAX_FLOW_OUT: { // Me preguntan por el flujo máximo. // Primero me actualizo, y luego respondo - update(); - float tmp = (actual_flow>max_flow)?max_flow:actual_flow; + float tmp = *((float *)data); + // update(); + actual_flow = (actual_flow>max_flow)?max_flow:actual_flow; + actual_flow = (actual_flowrecieve_msg(MSG_RESPONSE_MAX_FLOW, this, &tmp); + who->recieve_msg(MSG_RESPONSE_MAX_FLOW, this, &actual_flow); + updated = true; } break; case MSG_RESPONSE_MAX_FLOW: { @@ -43,15 +49,20 @@ void Conduct::recieve_msg(int msg, IConector *who, void *data) } } -void Conduct::update() +void Conduct::update(int dir) { // 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; +// actual_flow = 99999; updated = true; - send_msg(OUT, MSG_QUERY_MAX_FLOW); - send_msg(IN, MSG_QUERY_MAX_FLOW); + switch (dir) { + case IN: + send_msg(IN, MSG_QUERY_MAX_FLOW_IN, (void *)&max_flow); + break; + case OUT: + send_msg(OUT, MSG_QUERY_MAX_FLOW_OUT, (void *)&max_flow); + } } void Conduct::simulate() @@ -62,5 +73,6 @@ void Conduct::simulate() std::cout << name << "::Flujo actual = " << actual_flow << std::endl; updated = false; + actual_flow = 99999; } diff --git a/Model/src/drain.cpp b/Model/src/drain.cpp new file mode 100644 index 0000000..fa682cc --- /dev/null +++ b/Model/src/drain.cpp @@ -0,0 +1,26 @@ + +#include "drain.h" +#include + +using namespace PlaQui::Model; + +Drain::Drain(const std::string &_name):Control(_name) +{ +} + +Drain::~Drain() +{ +} + +bool Drain::get_output() +{ + // Siempre esta abierta una Fuente, salvo que + // se indique lo contrario! + return true; +} + +void Drain::simulate() +{ + std::cout << name << "::Flujo aceptado : " << actual_flow << std::endl; +} + diff --git a/Model/src/drainage.cpp b/Model/src/drainage.cpp new file mode 100644 index 0000000..95c55e8 --- /dev/null +++ b/Model/src/drainage.cpp @@ -0,0 +1,51 @@ + +#include "drainage.h" +#include + +using namespace PlaQui::Model; + +Drainage::Drainage(const std::string &_name):Drain(_name) +{ + in_slots = 1; + out_slots = 0; + // FIXME hacer INFINITO! + capacity = 99999; + actual_flow = 0.0f; +} + +Drainage::~Drainage() +{ +} + +void Drainage::update(int dir) +{ + // El drenaje no tiene que actualizar + if (updated) return; + actual_flow = 0; + updated = true; +} + +void Drainage::simulate() +{ + std::cout << name << "::Flujo recibido = " << actual_flow << std::endl; + updated = false; + actual_flow = 0; +} + +void Drainage::recieve_msg(int msg, IConector *who, void *data) +{ + float tmp; + switch (msg) { + case MSG_QUERY_MAX_FLOW_OUT: + // FIXME Hacer INFINITO !!! + actual_flow = *((float *)data); + std::cout << "DD" << std::endl; + tmp = 999999; + who->recieve_msg(MSG_RESPONSE_MAX_FLOW, this, &tmp); + updated = true; + break; + default: + Drain::recieve_msg(msg, who, data); + } +} + diff --git a/Model/src/iconector.cpp b/Model/src/iconector.cpp index 3307305..7cbdd56 100644 --- a/Model/src/iconector.cpp +++ b/Model/src/iconector.cpp @@ -17,7 +17,7 @@ IConector::~IConector() out_list.clear(); } -void IConector::send_msg(int where, int msg) +void IConector::send_msg(int where, int msg, void *data) { // Recorro toda la lista y envío el mensage a cada // elemento conectado en "where" @@ -25,11 +25,11 @@ void IConector::send_msg(int where, int msg) switch (where) { case IN: for(it=in_list.begin(); it!=in_list.end(); it++) - (*it)->recieve_msg(msg, this, NULL); + (*it)->recieve_msg(msg, this, data); break; case OUT: for(it=out_list.begin(); it!=out_list.end(); it++) - (*it)->recieve_msg(msg, this, NULL); + (*it)->recieve_msg(msg, this, data); } } diff --git a/Model/src/main.cpp b/Model/src/main.cpp index 01f9ecb..3fa359e 100644 --- a/Model/src/main.cpp +++ b/Model/src/main.cpp @@ -1,9 +1,11 @@ /* Test pedorro a ver que pasa con lo que esta programado!! */ /* Compilar : g++ -Wall -o test -I../include *.cpp */ -#include "bomb.h" +#include "pump.h" #include "conduct.h" #include "union.h" +#include "splitter.h" +#include "drainage.h" #include using namespace std; @@ -11,56 +13,57 @@ using namespace PlaQui::Model; int main(int argc, char *argv[]) { - Bomb *bomba1, *bomba2; - Conduct *canio1; - Conduct *canio2; - Conduct *salida; - Union *union1; + Pump *bomba1; + Conduct *salida1; + Conduct *salida2; + Conduct *entrada; + Splitter *split; + Drainage *dren1, *dren2; - bomba1 = new Bomb("bomba1"); - bomba1->set_max_flow(3); - bomba2 = new Bomb("bomba2"); - bomba2->set_max_flow(5); - canio1 = new Conduct("cond_1"); - canio1->set_max_flow(5); - canio2 = new Conduct("cond_2"); - canio2->set_max_flow(5); + bomba1 = new Pump("bomba"); + bomba1->set_max_flow(30); + salida1 = new Conduct("salida_1"); + salida1->set_max_flow(2); + salida2 = new Conduct("salida_2"); + salida2->set_max_flow(5); - union1 = new Union("union"); - union1->set_max_flow(5); - salida = new Conduct("salida"); - salida->set_max_flow(10); + split = new Splitter("splitter"); + split->set_max_flow(8); + entrada = new Conduct("entrada"); + entrada->set_max_flow(10); - bomba1->connect(canio1, IConector::OUT); - canio1->connect(bomba1, IConector::IN); - canio1->connect(union1, IConector::OUT); + dren1 = new Drainage("drenaje1"); + dren2 = new Drainage("drenaje2"); - 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); + bomba1->connect(entrada, IConector::OUT); + entrada->connect(bomba1, IConector::IN); + entrada->connect(split, IConector::OUT); + split->connect(entrada, IConector::IN); + split->connect(salida1, IConector::OUT); + split->connect(salida2, IConector::OUT); + salida1->connect(split, IConector::IN); + salida2->connect(split, IConector::IN); + salida1->connect(dren1, IConector::OUT); + salida2->connect(dren2, IConector::OUT); int i = 0; while (i<10) { bomba1->update(); - bomba2->update(); - canio1->update(); - canio2->update(); - salida->update(); - union1->update(); + salida1->update(); + salida2->update(); + entrada->update(); + split->update(); + dren1->update(); + dren2->update(); bomba1->simulate(); - bomba2->simulate(); - canio1->simulate(); - canio2->simulate(); - salida->simulate(); - union1->simulate(); + salida1->simulate(); + salida2->simulate(); + entrada->simulate(); + split->simulate(); + dren1->simulate(); + dren2->simulate(); sleep(1); if (i == 5) { @@ -70,11 +73,10 @@ int main(int argc, char *argv[]) } delete bomba1; - delete bomba2; - delete canio1; - delete canio2; - delete salida; - delete union1; + delete salida1; + delete salida2; + delete entrada; + delete split; return 1; } diff --git a/Model/src/plantitem.cpp b/Model/src/plantitem.cpp index aa3aa23..1ce56f8 100644 --- a/Model/src/plantitem.cpp +++ b/Model/src/plantitem.cpp @@ -22,7 +22,7 @@ PlantItem::~PlantItem() void PlantItem::recieve_msg(int msg, IConector *who, void *data) { switch (msg) { - case MSG_QUERY_MAX_FLOW: + case MSG_QUERY_MAX_FLOW_OUT: // TODO return; break; diff --git a/Model/src/bomb.cpp b/Model/src/pump.cpp similarity index 59% rename from Model/src/bomb.cpp rename to Model/src/pump.cpp index 82302b0..086138f 100644 --- a/Model/src/bomb.cpp +++ b/Model/src/pump.cpp @@ -1,10 +1,10 @@ -#include "bomb.h" +#include "pump.h" #include using namespace PlaQui::Model; -Bomb::Bomb(const std::string &_name):Source(_name) +Pump::Pump(const std::string &_name):Source(_name) { in_slots = 0; out_slots = 1; @@ -13,19 +13,22 @@ Bomb::Bomb(const std::string &_name):Source(_name) max_flow = actual_flow = 0.0f; } -Bomb::~Bomb() +Pump::~Pump() { } -void Bomb::update() +void Pump::update(int dir) { if (updated) return; - actual_flow = 99999; + if (active && open) + actual_flow = max_flow; + else + actual_flow = 0; updated = true; - send_msg(OUT, MSG_QUERY_MAX_FLOW); + send_msg(OUT, MSG_QUERY_MAX_FLOW_OUT, (void *)&actual_flow); } -void Bomb::simulate() +void Pump::simulate() { std::cout << name << "::Flujo actual = " << ((active && open)?actual_flow:0) \ << " de " << max_flow; @@ -33,7 +36,7 @@ void Bomb::simulate() updated = false; } -bool Bomb::get_output() +bool Pump::get_output() { /* Si el corte fue manual, no puedo hacer nada */ if (active == false) return false; @@ -42,20 +45,17 @@ bool Bomb::get_output() return open; } -void Bomb::recieve_msg(int msg, IConector *who, void *data) +void Pump::recieve_msg(int msg, IConector *who, void *data) { switch (msg) { - case MSG_QUERY_MAX_FLOW: { + case MSG_QUERY_MAX_FLOW_OUT: { // Me preguntan por el flujo máximo. // Primero me actualizo, y luego respondo - update(); + // TODO la bomba nunca deberia ser consultada,pues el flujo sale ella + /* update(); float tmp; - if (active && open) { - tmp = (actual_flowrecieve_msg(MSG_RESPONSE_MAX_FLOW, this, &tmp); + tmp = (actual_flowrecieve_msg(MSG_RESPONSE_MAX_FLOW, this, &tmp);*/ } break; case MSG_RESPONSE_MAX_FLOW: { diff --git a/Model/src/splitter.cpp b/Model/src/splitter.cpp new file mode 100644 index 0000000..bf59c0f --- /dev/null +++ b/Model/src/splitter.cpp @@ -0,0 +1,89 @@ + +#include "splitter.h" +#include + +using namespace PlaQui::Model; + +Splitter::Splitter(const std::string &_name):Transport(_name) +{ + in_slots = 1; + out_slots = 2; + max_flow = actual_flow = 0.0f; +} + +Splitter::~Splitter() +{ +} + +void Splitter::recieve_msg(int msg, IConector *who, void *data) +{ + int pos = OUT; + + // Verifico si esta conectado a mi entrada + std::list::iterator i; + for(i=in_list.begin(); i!=in_list.end(); i++) { + if ((*i) == who) pos = IN; + } + + switch (msg) { + case MSG_QUERY_MAX_FLOW_OUT: { + // Me preguntan por el flujo máximo. + // Primero me actualizo, y luego respondo + actual_flow = *((float *)data); + + if (max_flow < actual_flow) actual_flow = max_flow; + + actual_flow /= 2.0f; + + send_msg(OUT, MSG_QUERY_MAX_FLOW_OUT, &actual_flow); + + // Listo, mi flujo ahora es el doble de lo que me pueden + // dar las salidas + actual_flow *= 2.0f; + who->recieve_msg(MSG_RESPONSE_MAX_FLOW, this, &actual_flow); + updated = true; + } + break; + case MSG_RESPONSE_MAX_FLOW: { + float max = *((float *)data); + if (pos == OUT) { + if (max < actual_flow) actual_flow = max; + if (max_flow < actual_flow) actual_flow = max_flow; + } else { + if (((2*max) < actual_flow) && (max != 0)) + actual_flow = 2*max; + } + } + break; + default: + Transport::recieve_msg(msg, who, data); + } +} + +void Splitter::update(int dir) +{ + // 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; + switch (dir) { + case IN: + send_msg(IN, MSG_QUERY_MAX_FLOW_IN, (void *)&max_flow); + break; + case OUT: + send_msg(OUT, MSG_QUERY_MAX_FLOW_OUT, (void *)&max_flow); + } +} + +void Splitter::simulate() +{ + if (!updated) { + return; + } + + std::cout << name << "::Flujo actual = " << actual_flow << std::endl; + updated = false; + actual_flow = 99999; +} + diff --git a/Model/src/union.cpp b/Model/src/union.cpp index 331e953..3b6a266 100644 --- a/Model/src/union.cpp +++ b/Model/src/union.cpp @@ -9,6 +9,8 @@ Union::Union(const std::string &_name):Transport(_name) in_slots = 2; out_slots = 1; max_flow = actual_flow = 0.0f; + in_on_zero = 0; + in_ready = 0; } Union::~Union() @@ -26,19 +28,33 @@ void Union::recieve_msg(int msg, IConector *who, void *data) } switch (msg) { - case MSG_QUERY_MAX_FLOW: { + case MSG_QUERY_MAX_FLOW_OUT: { // Me preguntan por el flujo máximo. // Primero me actualizo, y luego respondo - update(); - float tmp; + float m_data = *((float *)data)*2; - tmp = (actual_flowrecieve_msg(MSG_RESPONSE_MAX_FLOW, this, &tmp); + updated = true; } break; case MSG_RESPONSE_MAX_FLOW: { @@ -46,7 +62,8 @@ void Union::recieve_msg(int msg, IConector *who, void *data) if (pos == OUT) { if (max < actual_flow) actual_flow = max; } else { - if ((2*max) < actual_flow) actual_flow = 2*max; + if (((2*max) < actual_flow) && (max != 0)) + actual_flow = 2*max; } } break; @@ -55,15 +72,20 @@ void Union::recieve_msg(int msg, IConector *who, void *data) } } -void Union::update() +void Union::update(int dir) { // 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; +// actual_flow = 99999; updated = true; - send_msg(OUT, MSG_QUERY_MAX_FLOW); - send_msg(IN, MSG_QUERY_MAX_FLOW); + switch (dir) { + case IN: + send_msg(IN, MSG_QUERY_MAX_FLOW_IN, (void *)&max_flow); + break; + case OUT: + send_msg(OUT, MSG_QUERY_MAX_FLOW_OUT, (void *)&max_flow); + } } void Union::simulate() @@ -74,5 +96,8 @@ void Union::simulate() std::cout << name << "::Flujo actual = " << actual_flow << std::endl; updated = false; + actual_flow = 99999; + in_on_zero = 0; + in_ready = 0; } diff --git a/docs/clases.dia b/docs/clases.dia index 8ac7176..3ec9093 100644 Binary files a/docs/clases.dia and b/docs/clases.dia differ