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
-@use Control.
@plugin "plugin.so" (SAbrFunctions).
+ 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.
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.
}
{
public:
std::string* m_nombres ;
- T* m_datos ;
- unsigned m_cant ;
+ T* m_datos ;
+ unsigned m_cant ;
+ typedef T* iterator;
public:
CIndiceMagico()
}
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
#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()
{
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) ;
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) ;
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) ;
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) ;
// Ejecuto el plan
- a.ejecutar(plan) ;
+// a.ejecutar(plan) ;
return 0 ;
\r
/////////////////////////// CTeoria /////////////////////////\r
\r
-double NoOp(CEntorno&) { return 0.0; } // FIXME (hack horrible porque no puedo usar ptr a fun)\r
-\r
// pointer{Teoria} TeoriaNew(string, string, int, int)\r
int SAbrTeoriaNew(brEval args[], brEval* result, void* data)\r
{\r
result->set(new CTeoria(\r
BRSTRING(args),\r
- NoOp, // FIXME (no hay puntero a funcion, poner BRINT(args+1))\r
- //BRSTRING(args+1),\r
+ BRSTRING(args+1),\r
BRINT(args+2),\r
BRINT(args+3)));\r
return EC_OK;\r
return EC_OK;\r
}\r
\r
+// void SistemaAutonomoSetDatoFinal(pointer{SistemaAutonomo}, string, float)\r
+int SAbrSistemaAutonomoSetDatoFinal(brEval args[], brEval* result, void* data)\r
+{\r
+ CSistemaAutonomo* sa = (CSistemaAutonomo*) BRPOINTER(args);\r
+ sa->m_datos_finales.set_val(BRSTRING(args+1), BRDOUBLE(args+2));\r
+ return EC_OK;\r
+}\r
+\r
// void SistemaAutonomoPlan(pointer{SistemaAutonomo})\r
int SAbrSistemaAutonomoPlan(brEval args[], brEval* result, void* data)\r
{\r
- // TODO CSistemaAutonomo* sa = (CSistemaAutonomo*) BRPOINTER(args);\r
- // TODO sa->plan();\r
+ CSistemaAutonomo* sa = (CSistemaAutonomo*) BRPOINTER(args);\r
+ sa->plan();\r
return EC_OK;\r
}\r
\r
-// pointer SistemaAutonomoGetNextTheory(pointer{SistemaAutonomo})\r
+// bool SistemaAutonomoHasNextTheory(pointer{SistemaAutonomo})\r
+int SAbrSistemaAutonomoHasNextTheory(brEval args[], brEval* result, void* data)\r
+{\r
+ CSistemaAutonomo* sa = (CSistemaAutonomo*) BRPOINTER(args);\r
+ result->set(sa->has_next_theory());\r
+ return EC_OK;\r
+}\r
+\r
+// pointer{Teoria} SistemaAutonomoGetNextTheory(pointer{SistemaAutonomo})\r
int SAbrSistemaAutonomoGetNextTheory(brEval args[], brEval* result, void* data)\r
{\r
- // TODO CSistemaAutonomo* sa = (CSistemaAutonomo*) BRPOINTER(args);\r
- // TODO result->set(sa->get_next_theory());\r
- result->set(new CTeoria("test", NoOp, 1, 1)); // FIXME\r
+ CSistemaAutonomo* sa = (CSistemaAutonomo*) BRPOINTER(args);\r
+ result->set(sa->get_next_theory());\r
return EC_OK;\r
}\r
\r
// bool SistemaAutonomoValidateTheory(pointer{SistemaAutonomo}, pointer{Teoria})\r
int SAbrSistemaAutonomoValidateTheory(brEval args[], brEval* result, void* data)\r
{\r
- // TODO CSistemaAutonomo* sa = (CSistemaAutonomo*) BRPOINTER(args);\r
- // TODO result->set(sa->validate_theory((CTeoria*) BRPOINTER(args+1)));\r
- result->set(true); // FIXME\r
+ CSistemaAutonomo* sa = (CSistemaAutonomo*) BRPOINTER(args);\r
+ result->set(sa->validate_theory((CTeoria*) BRPOINTER(args+1)));\r
return EC_OK;\r
}\r
\r
AT_NULL, AT_POINTER, AT_POINTER, 0);\r
brNewBreveCall(data, "SistemaAutonomoSetValue", SAbrSistemaAutonomoSetValue,\r
AT_NULL, AT_POINTER, AT_STRING, AT_DOUBLE, 0);\r
+ brNewBreveCall(data, "SistemaAutonomoSetDatoFinal", SAbrSistemaAutonomoSetDatoFinal,\r
+ AT_NULL, AT_POINTER, AT_STRING, AT_DOUBLE, 0);\r
brNewBreveCall(data, "SistemaAutonomoPlan", SAbrSistemaAutonomoPlan,\r
AT_NULL, AT_POINTER, 0);\r
+ brNewBreveCall(data, "SistemaAutonomoHasNextTheory", SAbrSistemaAutonomoHasNextTheory,\r
+ AT_INT, AT_POINTER, 0);\r
brNewBreveCall(data, "SistemaAutonomoGetNextTheory", SAbrSistemaAutonomoGetNextTheory,\r
AT_POINTER, AT_POINTER, 0);\r
brNewBreveCall(data, "SistemaAutonomoValidateTheory", SAbrSistemaAutonomoValidateTheory,\r
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;
+}
//--------------------------------------------------------------------------------------------
}
-
+/*
//--------------------------------------------------------------------------------------------
//--
bool CSistemaAutonomo::ejecutar (CIndiceMagico<CTeoria>& plan)
//
return result ;
}
+*/
#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
// 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.
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
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)
{
{
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 ;
// 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:
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) ;
} ;
projects / z.facultad / 75.68 / celdas.git / commitdiff