From: Leandro Lucarella <llucax@gmail.com>
Date: Thu, 14 Dec 2006 01:27:56 +0000 (+0000)
Subject: Adaptación de Sistema Autónomo para que pueda hablar más fácil con Breve.
X-Git-Tag: entrega-20061218~36
X-Git-Url: https://git.llucax.com/z.facultad/75.68/celdas.git/commitdiff_plain/38252dfa17d6be81f176feceb8b4fbe612a9b597?ds=inline

Adaptación de Sistema Autónomo para que pueda hablar más fácil con Breve.
---

diff --git a/trunk/doc/Documentacion.doc b/trunk/doc/Documentacion.doc
new file mode 100644
index 0000000..893c673
Binary files /dev/null and b/trunk/doc/Documentacion.doc differ
diff --git a/trunk/src/Makefile b/trunk/src/Makefile
index cb15e54..d72514e 100644
--- a/trunk/src/Makefile
+++ b/trunk/src/Makefile
@@ -6,8 +6,8 @@ targets=test plugin.so
 
 all: $(targets)
 
-plugin.so: plugin.o $(BREVEDIR)/brevePlugin.a
-	$(CXX) $(CPPFLAGS) -shared -o $@ plugin.o $(BREVEDIR)/brevePlugin.a
+plugin.so: plugin.o sistemaautonomo.o $(BREVEDIR)/brevePlugin.a
+	$(CXX) $(CPPFLAGS) -shared -o $@ plugin.o sistemaautonomo.o $(BREVEDIR)/brevePlugin.a
 
 test: main.o sistemaautonomo.o
 	$(CXX) $(LDFLAGS) -o test *.o
diff --git a/trunk/src/SistemaAutonomo.tz b/trunk/src/SistemaAutonomo.tz
index 147c776..b7c3cc7 100644
--- a/trunk/src/SistemaAutonomo.tz
+++ b/trunk/src/SistemaAutonomo.tz
@@ -1,4 +1,3 @@
-@use Control.
 
 @plugin "plugin.so" (SAbrFunctions).
 
@@ -44,19 +43,32 @@ Object : SistemaAutonomo {
 	+ to add teoria theTeoria (object):
 		SistemaAutonomoAddTeoria(ptr, (theTeoria get-ptr)).
 
-	+ to set value theValue (float) with-name theName (string):
+	+ to set-entorno value theValue (float) with-name theName (string):
 		SistemaAutonomoSetValue(ptr, theName, theValue).
 
-	+ to update entorno theEntorno (hash):
+	+ to set-dato-final value theValue (float) with-name theName (string):
+		SistemaAutonomoSetDatoFinal(ptr, theName, theValue).
+
+	+ to update-entorno entorno theEntorno (hash):
 		nombre (string).
 		foreach nombre in keys(theEntorno): {
 			print "Seteando valor de entorno ", nombre, " con ", theEntorno{nombre}.
-			self set value theEntorno{nombre} with-name nombre.
+			self set-entorno value theEntorno{nombre} with-name nombre.
+		}
+
+	+ to update-datos-finales datos-finales datos (hash):
+		nombre (string).
+		foreach nombre in keys(datos): {
+			print "Seteando valor de dato final ", nombre, " con ", datos{nombre}.
+			self set-dato-final value datos{nombre} with-name nombre.
 		}
 
 	+ to plan:
 		SistemaAutonomoPlan(ptr).
 
+	+ to has-next-theory:
+		return SistemaAutonomoHasNextTheory(ptr).
+
 	+ to get-next-theory:
 		t (object).
 		t = new Teoria.
diff --git a/trunk/src/SistemaAutonomoDemo.tz b/trunk/src/SistemaAutonomoDemo.tz
index 5c8fdd4..391d5bc 100644
--- a/trunk/src/SistemaAutonomoDemo.tz
+++ b/trunk/src/SistemaAutonomoDemo.tz
@@ -10,49 +10,69 @@ Control : SistemaAutonomoController {
 		sa (object).
 		teoria (object).
 		entorno (hash).
+		datos-finales (hash).
 
 		print "Llena entorno".
-		entorno{"sensor1"} = 10.5.
-		entorno{"sensor2"} = 1.5.
+		entorno{"sensor"} = 0.
+		entorno{"movido"} = 0.
 
 		print "Crea Sistema autónomo".
 		sa = new SistemaAutonomo.
 
 		print "Crea Teorías".
-		teorias = 3 new Teorias.
-		teorias{0} init named "t1" with-action 1.
-		teorias{1} init named "t2" with-action 2.
-		teorias{2} init named "t3" with-action 3.
-
-		print "Carga datos a las teorías".
-		(teorias{0}) set-dato-inicial name "sensor1" value 10.5.
-		(teorias{0}) set-dato-inicial name "sensor2" value 0.5.
-		(teorias{1}) set-dato-inicial name "sensor1" value 0.5.
-		(teorias{1}) set-dato-inicial name "sensor2" value 10.5.
-		(teorias{2}) set-dato-inicial name "sensor1" value 5.5.
-		(teorias{2}) set-dato-inicial name "sensor2" value 5.5.
+		teorias = 2 new Teorias.
+		teorias{0} init named "t1" with-action "avanza".
+		(teorias{0}) set-dato-inicial name "sensor" value 0.
+		(teorias{0}) set-dato-inicial name "movido" value -3000000.
+		(teorias{0}) set-dato-final name "sensor" value -3000000.
+		(teorias{0}) set-dato-final name "movido" value 1.
+
+		teorias{1} init named "t2" with-action "retrocede".
+		(teorias{1}) set-dato-inicial name "sensor" value 1.
+		(teorias{1}) set-dato-inicial name "movido" value -3000000.
+		(teorias{1}) set-dato-final name "sensor" value -3000000.
+		(teorias{1}) set-dato-final name "movido" value 1.
 
 		print "Agrega teorías al sistema autónomo".
 		sa add teoria (teorias{0}).
 		sa add teoria (teorias{1}).
-		sa add teoria (teorias{2}).
 		print "Actualiza entorno".
-		sa update entorno entorno.
+		sa update-entorno entorno entorno.
+		print "Ponemos condición final esperada para el plan".
+		datos-finales{"movido"} = 1.
+		sa update-datos-finales datos-finales datos-finales.
 		print "Calcula el plan".
 		sa plan.
-		print "Obtiene próxima teoría".
-		teoria = sa get-next-theory.
-		print "Obtiene datos de la teoría teoría".
-		print(teoria get-nombre).
-		print(teoria get-accion).
-		print "Valida teoría".
-		if (sa validate theory teoria): {
-			print "valida".
+		print "Vemos si tiene una teoría más".
+		while (sa has-next-theory): {
+			print "Sí, tiene".
+			print "Obtiene próxima teoría".
+			teoria = sa get-next-theory.
+			print "Obtiene datos de la teoría teoría".
+			print(teoria get-nombre).
+			print(teoria get-accion).
+			if ((teoria get-accion) == "avanza"): {
+				entorno{"sensor"} = 1.
+				entorno{"movido"} = 1.
+			}
+			if ((teoria get-accion) == "retrocede"): {
+				entorno{"sensor"} = 0.
+				entorno{"movido"} = 1.
+			}
+			print "Valida teoría".
+			sa update-entorno entorno entorno.
+			if (sa validate theory teoria): {
+				print "valida".
+			}
+			else {
+				print "Teoria no valida, salimos".
+			}
+			print "Vemos si tiene una teoría más".
 		}
+		print "No, no tiene".
 
 		free teorias{0}.
 		free teorias{1}.
-		free teorias{2}.
 		free sa.
 
 }
diff --git a/trunk/src/indicemagico.h b/trunk/src/indicemagico.h
index a90412a..49f18f1 100644
--- a/trunk/src/indicemagico.h
+++ b/trunk/src/indicemagico.h
@@ -17,8 +17,9 @@ class CIndiceMagico
 {
 public:
 	std::string*	m_nombres ;
-	T*				m_datos ;
-	unsigned		m_cant ;
+	T*		m_datos ;
+	unsigned	m_cant ;
+	typedef		T*	iterator;
 
 public:
 	CIndiceMagico()	
@@ -43,6 +44,8 @@ public:
 	}
 
 public:
+	iterator begin() { return m_datos; }
+	iterator end() { return m_datos + m_cant; }
 	void add(const char* nombre, const T dato)
 	{
 		//Si ya existía, lo borro
diff --git a/trunk/src/main.cpp b/trunk/src/main.cpp
index a259805..3886fcf 100644
--- a/trunk/src/main.cpp
+++ b/trunk/src/main.cpp
@@ -2,28 +2,6 @@
 #include "main.h"
 #include <iostream>
 
-//
-double AvanzarX(CEntorno& e)
-{
-	avanzo_en_x = true ;
-	return 0 ;
-}
-
-
-double AvanzarY(CEntorno& e)
-{
-	avanzo_en_y = true ;
-	return 0 ;
-}
-
-
-double AvanzarZ(CEntorno& e)
-{
-	avanzo_en_z = true ;
-	return 0 ;
-}
-
-
 //
 void CMiEntorno::inicializar()
 {
@@ -57,13 +35,13 @@ void CMiEntorno::actualizar()
 int main(int argc, char** argv)
 {
 	//
-	CMiEntorno				e ;
+	CMiEntorno			e ;
 	CSistemaAutonomo		a ;
 
 	e.inicializar() ;
 
 	// Inicializo las teorias
-	CTeoria t1("Avanzar_X_1", &AvanzarX, 1, 1) ;
+	CTeoria t1("Avanzar_X_1", "AvanzarX", 1, 1) ;
 	t1.datos_iniciales.add ("robot.sensor_1", 0) ;
 	t1.datos_iniciales.add ("robot.sensor_2", ANY) ;
 	t1.datos_iniciales.add ("robot.sensor_3", ANY) ;
@@ -71,13 +49,13 @@ int main(int argc, char** argv)
 	t1.datos_iniciales.add ("robot.avanzo_en_y", ANY) ;
 	t1.datos_iniciales.add ("robot.avanzo_en_z", ANY) ;
 	t1.datos_finales.add ("robot.avanzo_en_x", 1) ;
-	t1.datos_finales.add ("robot.avanzo_en_y", 0) ;
-	t1.datos_finales.add ("robot.avanzo_en_z", 0) ;
+	t1.datos_finales.add ("robot.avanzo_en_y", ANY) ;
+	t1.datos_finales.add ("robot.avanzo_en_z", ANY) ;
 	t1.datos_finales.add ("robot.sensor_1", ANY) ;
 	t1.datos_finales.add ("robot.sensor_2", ANY) ;
 	t1.datos_finales.add ("robot.sensor_3", ANY) ;
 
-	CTeoria t2("Avanzar_Y_1", &AvanzarY, 1, 1) ;
+	CTeoria t2("Avanzar_Y_1", "AvanzarY", 1, 1) ;
 	t2.datos_iniciales.add ("robot.sensor_1", ANY) ;
 	t2.datos_iniciales.add ("robot.sensor_2", 0) ;
 	t2.datos_iniciales.add ("robot.sensor_3", ANY) ;
@@ -91,7 +69,7 @@ int main(int argc, char** argv)
 	t2.datos_finales.add ("robot.sensor_2", ANY) ;
 	t2.datos_finales.add ("robot.sensor_3", ANY) ;
 
-	CTeoria t3("Avanzar_Z_1", &AvanzarZ, 1, 1) ;
+	CTeoria t3("Avanzar_Z_1", "AvanzarZ", 1, 1) ;
 	t3.datos_iniciales.add ("robot.sensor_1", ANY) ;
 	t3.datos_iniciales.add ("robot.sensor_2", ANY) ;
 	t3.datos_iniciales.add ("robot.sensor_3", 0) ;
@@ -119,7 +97,7 @@ int main(int argc, char** argv)
 	CIndiceMagico<CTeoria> plan ;
 	CIndiceMagico<t_dato> datos_finales ;
  
-	datos_finales.add ("robot.avanzo_en_y", 1) ;
+	datos_finales.add ("robot.avanzo_en_x", 1) ;
 
 	a.planificar (a.p_entorno->datos, datos_finales, plan, p) ;
 
@@ -128,7 +106,7 @@ int main(int argc, char** argv)
 
 
 	// Ejecuto el plan
-	a.ejecutar(plan) ;
+//	a.ejecutar(plan) ;
 
 
 	return 0 ;
diff --git a/trunk/src/plugin.cpp b/trunk/src/plugin.cpp
index c91f570..a1098e6 100644
--- a/trunk/src/plugin.cpp
+++ b/trunk/src/plugin.cpp
@@ -4,15 +4,12 @@
 
 /////////////////////////// CTeoria /////////////////////////
 
-double NoOp(CEntorno&) { return 0.0; } // FIXME (hack horrible porque no puedo usar ptr a fun)
-
 // pointer{Teoria} TeoriaNew(string, string, int, int)
 int SAbrTeoriaNew(brEval args[], brEval* result, void* data)
 {
 	result->set(new CTeoria(
 		BRSTRING(args),
-		NoOp, // FIXME (no hay puntero a funcion, poner BRINT(args+1))
-		//BRSTRING(args+1),
+		BRSTRING(args+1),
 		BRINT(args+2),
 		BRINT(args+3)));
 	return EC_OK;
@@ -85,29 +82,43 @@ int SAbrSistemaAutonomoSetValue(brEval args[], brEval* result, void* data)
 	return EC_OK;
 }
 
+// void SistemaAutonomoSetDatoFinal(pointer{SistemaAutonomo}, string, float)
+int SAbrSistemaAutonomoSetDatoFinal(brEval args[], brEval* result, void* data)
+{
+	CSistemaAutonomo* sa = (CSistemaAutonomo*) BRPOINTER(args);
+	sa->m_datos_finales.set_val(BRSTRING(args+1), BRDOUBLE(args+2));
+	return EC_OK;
+}
+
 // void SistemaAutonomoPlan(pointer{SistemaAutonomo})
 int SAbrSistemaAutonomoPlan(brEval args[], brEval* result, void* data)
 {
-	// TODO CSistemaAutonomo* sa = (CSistemaAutonomo*) BRPOINTER(args);
-	// TODO sa->plan();
+	CSistemaAutonomo* sa = (CSistemaAutonomo*) BRPOINTER(args);
+	sa->plan();
 	return EC_OK;
 }
 
-// pointer SistemaAutonomoGetNextTheory(pointer{SistemaAutonomo})
+// bool SistemaAutonomoHasNextTheory(pointer{SistemaAutonomo})
+int SAbrSistemaAutonomoHasNextTheory(brEval args[], brEval* result, void* data)
+{
+	CSistemaAutonomo* sa = (CSistemaAutonomo*) BRPOINTER(args);
+	result->set(sa->has_next_theory());
+	return EC_OK;
+}
+
+// pointer{Teoria} SistemaAutonomoGetNextTheory(pointer{SistemaAutonomo})
 int SAbrSistemaAutonomoGetNextTheory(brEval args[], brEval* result, void* data)
 {
-	// TODO CSistemaAutonomo* sa = (CSistemaAutonomo*) BRPOINTER(args);
-	// TODO result->set(sa->get_next_theory());
-	result->set(new CTeoria("test", NoOp, 1, 1)); // FIXME
+	CSistemaAutonomo* sa = (CSistemaAutonomo*) BRPOINTER(args);
+	result->set(sa->get_next_theory());
 	return EC_OK;
 }
 
 // bool SistemaAutonomoValidateTheory(pointer{SistemaAutonomo}, pointer{Teoria})
 int SAbrSistemaAutonomoValidateTheory(brEval args[], brEval* result, void* data)
 {
-	// TODO CSistemaAutonomo* sa = (CSistemaAutonomo*) BRPOINTER(args);
-	// TODO result->set(sa->validate_theory((CTeoria*) BRPOINTER(args+1)));
-	result->set(true); // FIXME
+	CSistemaAutonomo* sa = (CSistemaAutonomo*) BRPOINTER(args);
+	result->set(sa->validate_theory((CTeoria*) BRPOINTER(args+1)));
 	return EC_OK;
 }
 
@@ -139,8 +150,12 @@ DLLEXPORT void SAbrFunctions(void *data)
 		       AT_NULL, AT_POINTER, AT_POINTER, 0);
 	brNewBreveCall(data, "SistemaAutonomoSetValue", SAbrSistemaAutonomoSetValue,
 		       AT_NULL, AT_POINTER, AT_STRING, AT_DOUBLE, 0);
+	brNewBreveCall(data, "SistemaAutonomoSetDatoFinal", SAbrSistemaAutonomoSetDatoFinal,
+		       AT_NULL, AT_POINTER, AT_STRING, AT_DOUBLE, 0);
 	brNewBreveCall(data, "SistemaAutonomoPlan", SAbrSistemaAutonomoPlan,
 		       AT_NULL, AT_POINTER, 0);
+	brNewBreveCall(data, "SistemaAutonomoHasNextTheory", SAbrSistemaAutonomoHasNextTheory,
+		       AT_INT, AT_POINTER, 0);
 	brNewBreveCall(data, "SistemaAutonomoGetNextTheory", SAbrSistemaAutonomoGetNextTheory,
 		       AT_POINTER, AT_POINTER, 0);
 	brNewBreveCall(data, "SistemaAutonomoValidateTheory", SAbrSistemaAutonomoValidateTheory,
diff --git a/trunk/src/sistemaautonomo.cpp b/trunk/src/sistemaautonomo.cpp
index 2b988f0..48e458c 100644
--- a/trunk/src/sistemaautonomo.cpp
+++ b/trunk/src/sistemaautonomo.cpp
@@ -20,6 +20,65 @@ bool incluye_a (CIndiceMagico<t_dato>& a, CIndiceMagico<t_dato>& b)
 	return result ;
 }
 
+//--------------------------------------------------------------------------------------------
+//--
+void CSistemaAutonomo::plan()
+{
+	double p = 1.0;
+	m_plan.clear();
+	planificar(p_entorno->datos, m_datos_finales, m_plan, p);
+	curr_theory = m_plan.begin();
+}
+
+//--------------------------------------------------------------------------------------------
+//--
+#include <iostream> // XXX FIXME
+bool CSistemaAutonomo::has_next_theory()
+{
+	return curr_theory != m_plan.end();
+}
+
+//--------------------------------------------------------------------------------------------
+//--
+CTeoria* CSistemaAutonomo::get_next_theory()
+{
+	if (curr_theory == m_plan.end())
+	{
+		m_datos_finales.clear();
+		return 0;
+	}
+	else
+	{
+		return curr_theory++;
+	}
+}
+
+//--------------------------------------------------------------------------------------------
+//--
+bool CSistemaAutonomo::validate_theory(CTeoria* t)
+{
+	bool result ;
+
+	result = verificar_condicion(t->datos_finales) ;
+
+
+	// Si fallo la teoria
+	if (!result)
+	{
+		// Aplico heuristicas de correccion
+		this->heurisitca_retraccion(*t) ;
+	}
+	else
+	{
+		t->p++ ;
+	}
+
+	// Aplico heuristicas de observacion
+	this->heurisitca_observacion(*t) ;
+	this->heurisitca_generalizacion(*t);
+
+	return result;
+}
 
 
 //--------------------------------------------------------------------------------------------
@@ -183,7 +242,7 @@ void CSistemaAutonomo::planificar (	CIndiceMagico<t_dato>&	datos_iniciales,
 }
 
 
-
+/*
 //--------------------------------------------------------------------------------------------
 //--
 bool CSistemaAutonomo::ejecutar (CIndiceMagico<CTeoria>& plan)
@@ -230,3 +289,4 @@ bool CSistemaAutonomo::ejecutar (CIndiceMagico<CTeoria>& plan)
 	//
 	return result ;
 }
+*/
diff --git a/trunk/src/sistemaautonomo.h b/trunk/src/sistemaautonomo.h
index ce08cfa..91db5e2 100644
--- a/trunk/src/sistemaautonomo.h
+++ b/trunk/src/sistemaautonomo.h
@@ -30,7 +30,7 @@ typedef double t_dato ;
 #define ANY -3000000
 
 
-#define t_fnc(name)		double (*name)(CEntorno&)
+//#define t_fnc(name)		double (*name)(CEntorno&)
 
 
 #define INFINITO	9999999 //CORREGIR: Poner aca el numero maximo que puede tomar un unsigend long
@@ -44,7 +44,7 @@ typedef double t_dato ;
 
 // Precision en la comparacion de atributos.
 // Poner en 0 si se quiere hacer la comparacion exacta.
-#define PRECISION								0.50000
+#define PRECISION								0.150000
 
 // Cuando se ejecuta un plan, se espera que al termina el ultimo paso se hallan alcanzado las condiciones finales.
 // Es posible que las condiciones finales se alcancen en algun paso previo.
@@ -97,7 +97,7 @@ public:
 	CIndiceMagico<t_dato>	datos_iniciales ;
 
 	// La funcion que se debe ejecutar para hacer valer la teoria.
-	double (*funcion)(CEntorno& e) ;
+	std::string funcion ;
 	// TODO std::string accion; Debería ser el nombre de la acción que va a realizar el BREVE
 
 	// Condiciones finales que deben cumplirsem luego de ejecutar la funcion final valiendo la condicion inicial
@@ -107,13 +107,13 @@ public:
 	CTeoria()
 	{
 		nombre = "" ;
-		funcion = NULL ;
+		funcion = "" ;
 		k = 1 ;
 		p = 1 ;
 	}
 
 	CTeoria(const char* ini_nombre, 
-			double (*ini_funcion)(CEntorno& e),
+		const char* ini_funcion,
 			unsigned long ini_k,
 			unsigned long ini_p)
 	{
@@ -166,7 +166,10 @@ class CSistemaAutonomo
 {
 public:
 	// El entono en el que se mueve el SA.
-	CEntorno*					p_entorno ;
+	CEntorno*			p_entorno ;
+
+	// Datos finales a utilizar al hacer
+	CIndiceMagico<t_dato>		m_datos_finales;
 
 	// Las teorias que tiene el SA.
 	CIndiceMagico<CTeoria>		teorias ;
@@ -178,9 +181,27 @@ public:
 	// Destructor
 	~CSistemaAutonomo() { delete p_entorno; }
 
+	// Genera un nuevo plan
+	void plan();
+
+	// Indica si hay una teoria mas para ejecutar
+	bool has_next_theory();
+
+	// Obtiene la próxima teoría del plan actual
+	CTeoria* get_next_theory();
+
+	// Retorna true si los valores de la condicion coinciden con los valores del entorno.
+	bool validate_theory(CTeoria*) ;
+
+protected:
 	// Retorna true si los valores de la condicion coinciden con los valores del entorno.
 	bool verificar_condicion(CIndiceMagico<t_dato>&	datos) ;
 
+	// plan actual
+	CIndiceMagico<CTeoria> m_plan;
+
+	// teoria actual
+	CIndiceMagico<CTeoria>::iterator curr_theory;
 
 protected: 
 
@@ -199,18 +220,16 @@ protected:
 public:
 
 	
-	void planificar (	CIndiceMagico<t_dato>&	datos_iniciales,
-						CIndiceMagico<t_dato>&	datos_finales,
-						CIndiceMagico<CTeoria>& plan,
-						double&					p,
-						unsigned long			numero_de_llamada=0) ;
+	void planificar (CIndiceMagico<t_dato>&	datos_iniciales,
+			CIndiceMagico<t_dato>&	datos_finales,
+			CIndiceMagico<CTeoria>& plan,
+			double&		p,
+			unsigned long	numero_de_llamada=0) ;
 
 
 	// Ejecuta una serie de pasos.
 	// Retorna true si se alcanza la condicion final.
-	bool ejecutar (CIndiceMagico<CTeoria>& plan) ;
-
-
+//	bool ejecutar (CIndiceMagico<CTeoria>& plan) ;
 } ;