Ayuda - Punteros-malloc-

Si eres principiante y tienes alguna consulta entra en este foro.
Responder
Mensaje
Autor
ma5acre14
Mensajes: 4
Registrado: 15/03/2019 4:14 pm

Ayuda - Punteros-malloc-

#1 Mensaje por ma5acre14 » 15/03/2019 4:18 pm

Hola! necesito que alguien me ayude a entender porque no esta funcionando mi función.
estoy programando una librería en C y necesito hacer un "árbol" de distintas estructuras, donde los nodos tengas interrelación.
Esto lo programe en el IDE Codeblocks, donde los compile y debuggie (anduvo perfectamente)
Luego pase al IDE de Arduino y lo programe ahi, nunca pudo ejecutar mas de 14/17 repeticiones de la función (lo chequee con el puerto serie, imprimiendo en cada iteracion)
pensé qe tal vez al arduino uno(atmega 328) no le daba para ejecutar, asiq pase a una placa de desarrollo que tiene un PIC32mx764F128L, una bestia pero tampoco pasa la función :-\

el código qe paso es solo la parte que se "tilda" la función tiene mas lineas. no creo que haga falta, pero si alguien necesita lo paso.
ultima aclaración, hice la iteracion esa a la fuerza (1300 lineas de código) y lo ejecuta perfectamente, arduino uno, la placa de desarrollo, codeblocks..todo.

Código: Seleccionar todo

extern  struct io_type    *e, *s,*aux_io;     // Entradas y salidas
extern  struct mf_type    *mf1, *aux_mf;      // Funciones de membresia p/entrada 1
extern  struct mf_type    *mf2;               // Funciones de membresia p/entrada 2
extern  struct mf_type    *mf3;               // Funciones de membresia p/entrada 3
extern  struct mf_type    *mf0;               // Funciones de membresia p/salida 1
extern  struct rule_type  *Rule_Base;         // Puntero a la base de la lista de reglas
extern  struct rule_type  *rule;             // Reglas del sistemas
extern  struct rule_element_type  *aux_ret;
extern  int rangos[NUM_ENTRADAS][2];

/*Reglas*/
    int R[NUM_REGLAS][4] =
                          {
                            {0,0,4,1},  //1
                            {1,0,0,1},  //2
                            {2,1,0,1},  //3
                            {2,2,0,1},  //4
                            {2,3,0,1},  //5
                            {2,4,0,1},  //6
                            {2,5,1,2},  //7
                            {2,5,2,2},  //8
                            {2,5,3,2},  //9
                            {3,1,0,1},  //10
                            {3,2,0,1},  //11
                            {3,3,0,1},  //12
                            {3,4,3,2},  //13
                            {3,4,2,2},  //14
                            {3,4,1,1},  //15
                            {3,5,3,2},  //16
                            {3,5,2,2},  //17
                            {3,5,1,2},  //18
                            {4,1,0,1},  //19
                            {4,2,0,1},  //20
                            {4,3,3,2},  //21
                            {4,3,2,1},  //22
                            {4,3,1,1},  //23
                            {4,4,3,2},  //24
                            {4,4,2,2},  //25
                            {4,4,1,1},  //26
                            {4,5,3,2},  //27
                            {4,5,2,2},  //28
                            {4,5,1,2},  //29
                            {5,1,0,1},  //30
                            {5,2,0,1},  //31
                            {5,3,3,2},  //32
                            {5,3,2,2},  //33
                            {5,3,1,2},  //34
                            {5,4,3,2},  //35
                            {5,4,2,2},  //36
                            {5,4,1,2},  //37
                            {5,5,3,2},  //38
                            {5,5,2,2},  //39
                            {5,5,1,2}   //40
                        };

    Rule_Base = malloc(sizeof(struct rule_type));     //Alojo memoria para la base de la lista de reglas
    rule = Rule_Base;   //para no perder el puntero a la base, copio la direccion
    for(i=0;i < NUM_REGLAS ; i++)
    {
      rule->if_side = malloc(sizeof(struct rule_element_type));
      aux_ret = rule->if_side;
      //Error
      if(R[i][0] !=0) //chequeo si en la regla "i" el error es parte de la regla
      {
        j = 1;
        for(aux_mf=mf1; aux_mf != NULL; aux_mf=aux_mf->next) // recorro las mf
        {
          if(j == R[i][0])  // Cuando encuentro la mf que me interesa, le asigno el valor
          {
            aux_ret->value = &(aux_mf->value);
          }
          j++;
        }
        if((R[i][1] != 0) || (R[i][2] != 0))  // chequeo si hay mas antecedentes
        {
          aux_ret->next = malloc(sizeof(struct rule_element_type)); //asigno memoria para el proximo antecedente
          aux_ret = aux_ret->next;
        }
      }
      //Derivada de la temperatura
      if(R[i][1] !=0) //chequeo si en la regla "i" la dT/dt es parte de la regla
      {
        j = 1;
        for(aux_mf=mf2; aux_mf != NULL; aux_mf=aux_mf->next)
        {
          if(j == R[i][1])
          {
            aux_ret->value = &(aux_mf->value);
          }
          j++;
        }
        if(R[i][2] != 0) // chequeo si hay mas antecedentes
        {
          aux_ret->next = malloc(sizeof(struct rule_element_type));
          aux_ret = aux_ret->next;
        }
      }
      //Condicionante
      if(R[i][2] !=0) //chequeo si en la regla "i" el condicionante es parte de la regla
      {
        j = 1;
        for(aux_mf=mf3; aux_mf != NULL; aux_mf=aux_mf->next)
        {
          if(j == R[i][2])
          {
            aux_ret->value = &(aux_mf->value);
          }
          j++;
        }
      }
      aux_ret->next = NULL; // como no hay mas antecedentes, termino la lista if_side
      rule->then_side = malloc(sizeof(struct rule_element_type)); //Asigno memoria para los concecuentes
      aux_ret = rule->then_side;
      //Salida
      aux_mf = mf0;
      if(R[i][3] == 1) //Cerrado
      {
          aux_ret->value = &(aux_mf->value);
      }
      else            //Abierto
      {
          aux_mf = mf0->next;
          aux_ret->value = &(aux_mf->value);
      }
      aux_ret->next = NULL; //Como no hay mas salidas, se termina la lista.
      if( i != (NUM_REGLAS-1)) //chequeo si se escribieron todas las reglas
      {
        rule->next = malloc(sizeof(struct rule_type));  //aloco memoria para la siguiente regla
        rule = rule->next;
      }
      else{rule->next = NULL;} //Como no hay mas reglas, finaliza la funcion.
    }
Última edición por mollok el 16/03/2019 2:14 am, editado 1 vez en total.
Razón: Los códigos deben ir entre etiquetas 'code', botón </>

mollok
Mensajes: 439
Registrado: 30/01/2018 9:47 am
Ubicación: Mallorca, España

Re: Ayuda - Punteros-malloc-

#2 Mensaje por mollok » 16/03/2019 2:30 am

Por lo pronto veo mucho malloc pero ningún free.
Al no liberar memoria te puedes quedar rápidamente sin ella.
while(is_alive(yourself)) {
    make_true(yourself, yourdreams);
}

ma5acre14
Mensajes: 4
Registrado: 15/03/2019 4:14 pm

Re: Ayuda - Punteros-malloc-

#3 Mensaje por ma5acre14 » 16/03/2019 3:24 am

Hola, gracias por responder. no puedo liberar xq eso significaría perder información. esto es parte de una función de inicializacion.
En relación a cantidad de memoria, ese mismo for lo implemente linea por linea, (1000 lineas de codigo) y lo ejecuta normalmente.
fuzzy_io.zip
Acá va la función completa
(2.5 KiB) Descargado 11 veces

mollok
Mensajes: 439
Registrado: 30/01/2018 9:47 am
Ubicación: Mallorca, España

Re: Ayuda - Punteros-malloc-

#4 Mensaje por mollok » 16/03/2019 12:43 pm

Déjame ver las estructuras.
while(is_alive(yourself)) {
    make_true(yourself, yourdreams);
}

ma5acre14
Mensajes: 4
Registrado: 15/03/2019 4:14 pm

Re: Ayuda - Punteros-malloc-

#5 Mensaje por ma5acre14 » 17/03/2019 5:01 am

Código: Seleccionar todo

struct io_type{
  char name[MAXNAME];        /*  nombre del sistema entrada/salida       */
  double value;                 /*  valor del sistema entrada/salida      */
  struct mf_type             /*  lista de funciones de membresia para  */
    *membership_functions;   /*     este sistema entrada/salida       */
  struct io_type *next;      /*  puntero a la siguiente entrada/salida  */
  };


struct mf_type{
  char name[MAXNAME]; /* nombre de la funcion de membresia (fuzzy set)    */
  double value;          /* grado de membresia/salida    */
  double point1;         /* limite izq de la func. mem.*/
  double point2;         /* limite der de la func. mem    */
  double slope1;         /* pendiente izq  */
  double slope2;         /* pendiente der */
  struct mf_type *next;   /* puntero a la siguiente funcion de membresia    */
  };


struct rule_element_type{
  double *value;                /* puntero a antecedente/salida */
  struct rule_element_type *next; /* siguiente antecedente o salida */
  };

struct rule_type{
  struct rule_element_type *if_side;     /* lista de antencedentes  */
  struct rule_element_type *then_side;   /* lista de salida     */
  struct rule_type *next;                /* siguiente regla  */
  };
Última edición por mollok el 17/03/2019 9:23 am, editado 1 vez en total.
Razón: Los códigos deben ir entre etiquetas 'code', botón </>

mollok
Mensajes: 439
Registrado: 30/01/2018 9:47 am
Ubicación: Mallorca, España

Re: Ayuda - Punteros-malloc-

#6 Mensaje por mollok » 18/03/2019 4:26 pm

Según lo que me has pasado he hecho dos versiones del código que funcionan de forma más modular.
Hay que decir que tiene algunos hacks porque, al no tener el proyecto entero, debía hacer pruebas. Si lo quieres probar debes eliminar esas partes para pruebas, añadir lo que tengas que añadir a tus cabeceras, usar extern y static para dar visibilidad o restringirla a otros módulos, etc.
Al no tener el resto del código ni la placa para probarlo puede contener errores, pero está basado en tu trabajo, mas o menos debería ir como es esperado.

Faltan funciones para liberar elementos y para modificar su contenido.

Por otra parte, si siempre hay el mismo número de datos ¿has pensado en usar arrays estáticos? Es mucho más sencillo trabajar con ellos.

Código 1:

Código: Seleccionar todo

#include <string.h>
#include <stdlib.h>


// ------- ESTO ES PARA PRUEBAS, USA TUS DATOS ----------------
#define NUM_ENTRADAS 3
#define NUM_REGLAS 40
#define MAX_NAME 25
#define INFINITO 1
#define PENDIENTE_CERO 0
// -------------------------------------------------------------

typedef struct io_type_t io_type;
typedef struct mf_type_t mf_type;
typedef struct rule_type_t rule_type;
typedef struct rule_element_type_t rule_element_type;

io_type    *e, *s;     // Entradas y salidas
mf_type    *mf;
mf_type    *mf0;       // Funciones de membresia p/salida 1
mf_type    *mf1;       // Funciones de membresia p/entrada 1
mf_type    *mf2;       // Funciones de membresia p/entrada 2
mf_type    *mf3;       // Funciones de membresia p/entrada 3
rule_type  *rule;      // Puntero a la base de la lista de reglas

int rangos[NUM_ENTRADAS][2];

struct io_type_t {
    char name[MAX_NAME];            /*  nombre del sistema entrada/salida     */
    double value;                   /*  valor del sistema entrada/salida      */
    mf_type *membership_functions;  /*  lista de funciones de membresia para  */
                                    /*     este sistema entrada/salida        */
    io_type *next;                  /*  puntero a la siguiente entrada/salida */
};

struct mf_type_t {
    char name[MAX_NAME];  /* nombre de la funcion de membresia (fuzzy set)    */
    double value;         /* grado de membresia/salida                        */
    double point1;        /* limite izq de la func. mem.                      */
    double point2;        /* limite der de la func. mem                       */
    double slope1;        /* pendiente izq                                    */
    double slope2;        /* pendiente der                                    */
    mf_type *next;        /* puntero a la siguiente funcion de membresia      */
};

struct rule_type_t {
    rule_element_type *if_side;   /* lista de antencedentes   */
    rule_element_type *then_side; /* lista de salida          */
    rule_type *next;              /* siguiente regla          */
};

struct rule_element_type_t {
    double *value;              /* puntero a antecedente/salida     */
    rule_element_type *next;    /* siguiente antecedente o salida   */
};

// FUNCIONES PARA io_type
io_type* new_io() {
    return NULL;
}

void add_io(io_type **root, char *name, double value, mf_type *membership_function_list) {
    io_type *node = malloc(sizeof(io_type));

    strncpy(node->name, name, MAX_NAME);
    node->value = value;
    node->membership_functions = membership_function_list;
    node->next = NULL;

    if(!*root) {
        *root = node;
    }
    else {
        io_type *aux = *root;
        while(aux->next)
            aux = aux->next;
        aux->next = node;
    }
}

// FUNCIONES PARA mf_type
mf_type* new_mf() {
    return NULL;
}

void add_mf(mf_type **root, char *name, double value, double point1, double point2, double slope1, double slope2) {
    mf_type *node = malloc(sizeof(mf_type));

    strncpy(node->name, name, MAX_NAME);
    node->value = value;
    node->point1 = point1;
    node->point2 = point2;
    node->slope1 = slope1;
    node->slope2 = slope2;
    node->next = NULL;

    if(!*root) {
        *root = node;
    }
    else {
        mf_type *aux = *root;
        while(aux->next)
            aux = aux->next;
        aux->next = node;
    }
}


// FUNCIONES PARA rule_type
rule_type* new_rule() {
    return NULL;
}

void add_rule(rule_type **root, rule_element_type *if_side_list, rule_element_type *then_side_list) {
    rule_type *node = malloc(sizeof(rule_type));

    node->if_side = if_side_list;
    node->then_side = then_side_list;
    node->next = NULL;

    if(!*root) {
        *root = node;
    }
    else {
        rule_type *aux = *root;
        while(aux->next)
            aux = aux->next;
        aux->next = node;
    }
}

// FUNCIONES PARA rule_element_type
rule_element_type* new_rule_element() {
    return NULL;
}

void add_rule_element(rule_element_type **root, double *value) {
    rule_element_type *node = malloc(sizeof(rule_element_type));

    node->value = value;
    node->next = NULL;

    if(!*root) {
        *root = node;
    }
    else {
        rule_element_type *aux = *root;
        while(aux->next)
            aux = aux->next;
        aux->next = node;
    }
}

// -------------------------------------------------------------

void fuzzy_init(){
    int i, j, k;

    // ENTRADA
    e = new_io();
    // Se cargan las membership functions
    mf1 = new_mf();
    add_mf(&mf1, "gn", 0, -INFINITO, -0.3, PENDIENTE_CERO, 5);
    add_mf(&mf1, "mn", 0, -0.5, -0.12, 6.66, 7.17);
    add_mf(&mf1, "ac", 0, -0.235, 0.235, 4.25, 4.25);
    add_mf(&mf1, "mp", 0, 0.12, 0.5, 7.14, 6.66);
    add_mf(&mf1, "gp", 0, 0.3, INFINITO, 5, PENDIENTE_CERO);

    mf2 = new_mf();
    add_mf(&mf2, "gn", 0, -INFINITO, -0.08, PENDIENTE_CERO, 25);
    add_mf(&mf2, "mn", 0, -0.1, 0, 20, 20);
    add_mf(&mf2, "ac", 0, -0.05, 0.05, 20, 20);
    add_mf(&mf2, "mp", 0, 0, 0.1, 20, 20);
    add_mf(&mf2, "gp", 0, 0.08, INFINITO, 25, PENDIENTE_CERO);

    mf3 = new_mf();
    add_mf(&mf3, "mf", 0, -INFINITO, 2, PENDIENTE_CERO, 0.5);
    add_mf(&mf3, "f", 0, 1, 4, 1, 1);
    add_mf(&mf3, "n", 0, 3, 6, 1, 1);
    add_mf(&mf3, "c", 0, 5, INFINITO, 0.5, PENDIENTE_CERO);

    // Se cargan las io
    add_io(&e, "error", 0, mf1);
    add_io(&e, "dT", 0, mf2);
    add_io(&e, "cond", 0, mf3);

    // SALIDA
    // Se cargan las membership functions
    mf0 = new_mf();
    add_mf(&mf0, "ce", 0, 0, 0.6, 100, 6.66);
    add_mf(&mf0, "ab", 0, 0.6, 1, 6.66, 100);

    // Se carga la io
    s = new_io();
    add_io(&s, "Elect", 0, mf0);

    /*Funciones de membresia*/
    int ran[NUM_ENTRADAS][2] = {{-1,1},    //error
                                {-1,1},    //dT/dt
                                {-10,15}}; //temperatura del refrigerante

    for(i=0; i<NUM_ENTRADAS; i++) {
        for(j=0; j<2; j++) {
            rangos[i][j] = ran[i][j];
        }
    }

    /*Reglas*/
    int R[NUM_REGLAS][4] = {{0,0,4,1},  //1
                            {1,0,0,1},  //2
                            {2,1,0,1},  //3
                            {2,2,0,1},  //4
                            {2,3,0,1},  //5
                            {2,4,0,1},  //6
                            {2,5,1,2},  //7
                            {2,5,2,2},  //8
                            {2,5,3,2},  //9
                            {3,1,0,1},  //10
                            {3,2,0,1},  //11
                            {3,3,0,1},  //12
                            {3,4,3,2},  //13
                            {3,4,2,2},  //14
                            {3,4,1,1},  //15
                            {3,5,3,2},  //16
                            {3,5,2,2},  //17
                            {3,5,1,2},  //18
                            {4,1,0,1},  //19
                            {4,2,0,1},  //20
                            {4,3,3,2},  //21
                            {4,3,2,1},  //22
                            {4,3,1,1},  //23
                            {4,4,3,2},  //24
                            {4,4,2,2},  //25
                            {4,4,1,1},  //26
                            {4,5,3,2},  //27
                            {4,5,2,2},  //28
                            {4,5,1,2},  //29
                            {5,1,0,1},  //30
                            {5,2,0,1},  //31
                            {5,3,3,2},  //32
                            {5,3,2,2},  //33
                            {5,3,1,2},  //34
                            {5,4,3,2},  //35
                            {5,4,2,2},  //36
                            {5,4,1,2},  //37
                            {5,5,3,2},  //38
                            {5,5,2,2},  //39
                            {5,5,1,2}}; //40

    rule = new_rule();

    for(i=0; i < NUM_REGLAS; i++) {
        mf_type *aux_mf;
        io_type *aux_io = e;

        // Entrada
        rule_element_type *if_rule = new_rule_element();
        // Para j = 0: Error
        // Para j = 1: Derivada de la temperatura
        // Para j = 2: Condicionante
        for(j = 0; j < 3; ++j) {
            if(R[i][j] != 0) {
                k = 1;
                for(aux_mf=aux_io->membership_functions; aux_mf != NULL; aux_mf=aux_mf->next) { // recorro las mf
                    if(k == R[i][j]) { // Cuando encuentro la mf que me interesa, le asigno el valor
                        add_rule_element(&if_rule, &aux_mf->value);
                    }
                    k++;
                }
            }
            aux_io = aux_io->next;
        }

        //Salida
        aux_mf = s->membership_functions;
        rule_element_type *then_rule = new_rule_element();

        if(R[i][3] == 1) {  //Cerrado
            add_rule_element(&then_rule, &aux_mf->value);
        }
        else {              //Abierto
            aux_mf = aux_mf->next;
            add_rule_element(&then_rule, &aux_mf->value);
        }
        add_rule(&rule, if_rule, then_rule);
    }
}

// El main está para que no salte el error en pruebas del compilador
int main() {}
Código 2: Aún más modular

Código: Seleccionar todo

#include <string.h>
#include <stdlib.h>

// ------- ESTO ES PARA PRUEBAS, USA TUS DATOS ----------------
#define NUM_ENTRADAS 3
#define NUM_REGLAS 40
#define MAX_NAME 25
#define INFINITO 1
#define PENDIENTE_CERO 0
// -------------------------------------------------------------

typedef struct io_type_t io_type;
typedef struct mf_type_t mf_type;
typedef struct rule_type_t rule_type;
typedef struct rule_element_type_t rule_element_type;

io_type    *e, *s;     // Entradas y salidas
rule_type  *rule;      // Puntero a la base de la lista de reglas

int rangos[NUM_ENTRADAS][2];

struct io_type_t {
    char name[MAX_NAME];            /*  nombre del sistema entrada/salida     */
    double value;                   /*  valor del sistema entrada/salida      */
    mf_type *membership_functions;  /*  lista de funciones de membresia para  */
                                    /*     este sistema entrada/salida        */
    io_type *next;                  /*  puntero a la siguiente entrada/salida */
};

struct mf_type_t {
    char name[MAX_NAME];  /* nombre de la funcion de membresia (fuzzy set)    */
    double value;         /* grado de membresia/salida                        */
    double point1;        /* limite izq de la func. mem.                      */
    double point2;        /* limite der de la func. mem                       */
    double slope1;        /* pendiente izq                                    */
    double slope2;        /* pendiente der                                    */
    mf_type *next;        /* puntero a la siguiente funcion de membresia      */
};

struct rule_type_t {
    rule_element_type *if_side;   /* lista de antencedentes   */
    rule_element_type *then_side; /* lista de salida          */
    rule_type *next;              /* siguiente regla          */
};

struct rule_element_type_t {
    double *value;              /* puntero a antecedente/salida     */
    rule_element_type *next;    /* siguiente antecedente o salida   */
};

// FUNCIONES PARA io_type
io_type* new_io() {
    return NULL;
}

void add_io(io_type **root, char *name, double value) {
    io_type *node = malloc(sizeof(io_type));

    strncpy(node->name, name, MAX_NAME);
    node->value = value;
    node->membership_functions = NULL;
    node->next = NULL;

    if(!*root) {
        *root = node;
    }
    else {
        io_type *aux = *root;
        while(aux->next)
            aux = aux->next;
        aux->next = node;
    }
}

io_type* get_io_by_name(io_type *io_list, char *name) {
    io_type *retval = io_list;

    while(retval && strcmp(retval->name, name))
        retval = retval->next;
    return retval;
}

// FUNCIONES PARA mf_type
void append_mf(io_type *io, char *name, double value, double point1, double point2, double slope1, double slope2) {
    mf_type *node = malloc(sizeof(mf_type));

    strncpy(node->name, name, MAX_NAME);
    node->value = value;
    node->point1 = point1;
    node->point2 = point2;
    node->slope1 = slope1;
    node->slope2 = slope2;
    node->next = NULL;

    if(!io->membership_functions) {
        io->membership_functions = node;
    }
    else {
        mf_type *aux = io->membership_functions;
        while(aux->next)
            aux = aux->next;
        aux->next = node;
    }
}

mf_type* get_mf_by_name(io_type *io_element, char *name) {
    mf_type *retval = io_element->membership_functions;

    while(retval && strcmp(retval->name, name))
        retval = retval->next;
    return retval;
}

// FUNCIONES PARA rule_type
rule_type* new_rule() {
    return NULL;
}

void add_rule(rule_type **root) {
    rule_type *node = malloc(sizeof(rule_type));

    node->if_side = NULL;
    node->then_side = NULL;
    node->next = NULL;

    if(!*root) {
        *root = node;
    }
    else {
        rule_type *aux = *root;
        while(aux->next)
            aux = aux->next;
        aux->next = node;
    }
}

// FUNCIONES PARA rule_element_type

void append_rule_if(rule_type *rule, double *value) {
    rule_element_type *node = malloc(sizeof(rule_element_type));

    node->value = value;
    node->next = NULL;

    if(!rule->if_side) {
        rule->if_side = node;
    }
    else {
        rule_element_type *aux = rule->if_side;
        while(aux->next)
            aux = aux->next;
        aux->next = node;
    }
}

void append_rule_then(rule_type *rule, double *value)  {
    rule_element_type *node = malloc(sizeof(rule_element_type));

    node->value = value;
    node->next = NULL;

    if(!rule->then_side) {
        rule->then_side = node;
    }
    else {
        rule_element_type *aux = rule->then_side;
        while(aux->next)
            aux = aux->next;
        aux->next = node;
    }
}

// -------------------------------------------------------------

void fuzzy_init(){
    int i, j, k;
    io_type *aux_io;
    // ENTRADA
    e = new_io();
    add_io(&e, "error", 0);
    aux_io = e;
    // Se cargan las membership functions
    append_mf(aux_io, "gn", 0, -INFINITO, -0.3, PENDIENTE_CERO, 5);
    append_mf(aux_io, "mn", 0, -0.5, -0.12, 6.66, 7.17);
    append_mf(aux_io, "ac", 0, -0.235, 0.235, 4.25, 4.25);
    append_mf(aux_io, "mp", 0, 0.12, 0.5, 7.14, 6.66);
    append_mf(aux_io, "gp", 0, 0.3, INFINITO, 5, PENDIENTE_CERO);

    add_io(&e, "dT", 0);
    aux_io = aux_io->next;
    append_mf(aux_io, "gn", 0, -INFINITO, -0.08, PENDIENTE_CERO, 25);
    append_mf(aux_io, "mn", 0, -0.1, 0, 20, 20);
    append_mf(aux_io, "ac", 0, -0.05, 0.05, 20, 20);
    append_mf(aux_io, "mp", 0, 0, 0.1, 20, 20);
    append_mf(aux_io, "gp", 0, 0.08, INFINITO, 25, PENDIENTE_CERO);

    add_io(&e, "cond", 0);
    aux_io = aux_io->next;
    append_mf(aux_io, "mf", 0, -INFINITO, 2, PENDIENTE_CERO, 0.5);
    append_mf(aux_io, "f", 0, 1, 4, 1, 1);
    append_mf(aux_io, "n", 0, 3, 6, 1, 1);
    append_mf(aux_io, "c", 0, 5, INFINITO, 0.5, PENDIENTE_CERO);

    // SALIDA
    s = new_io();
    add_io(&s, "Elect", 0);
    // Se cargan las membership functions
    append_mf(s, "ce", 0, 0, 0.6, 100, 6.66);
    append_mf(s, "ab", 0, 0.6, 1, 6.66, 100);

    /*Funciones de membresia*/
    int ran[NUM_ENTRADAS][2] = {{-1,1},    //error
                                {-1,1},    //dT/dt
                                {-10,15}}; //temperatura del refrigerante

    for(i=0; i<NUM_ENTRADAS; i++) {
        for(j=0; j<2; j++) {
            rangos[i][j] = ran[i][j];
        }
    }

    /*Reglas*/
    int R[NUM_REGLAS][4] = {{0,0,4,1},  //1
                            {1,0,0,1},  //2
                            {2,1,0,1},  //3
                            {2,2,0,1},  //4
                            {2,3,0,1},  //5
                            {2,4,0,1},  //6
                            {2,5,1,2},  //7
                            {2,5,2,2},  //8
                            {2,5,3,2},  //9
                            {3,1,0,1},  //10
                            {3,2,0,1},  //11
                            {3,3,0,1},  //12
                            {3,4,3,2},  //13
                            {3,4,2,2},  //14
                            {3,4,1,1},  //15
                            {3,5,3,2},  //16
                            {3,5,2,2},  //17
                            {3,5,1,2},  //18
                            {4,1,0,1},  //19
                            {4,2,0,1},  //20
                            {4,3,3,2},  //21
                            {4,3,2,1},  //22
                            {4,3,1,1},  //23
                            {4,4,3,2},  //24
                            {4,4,2,2},  //25
                            {4,4,1,1},  //26
                            {4,5,3,2},  //27
                            {4,5,2,2},  //28
                            {4,5,1,2},  //29
                            {5,1,0,1},  //30
                            {5,2,0,1},  //31
                            {5,3,3,2},  //32
                            {5,3,2,2},  //33
                            {5,3,1,2},  //34
                            {5,4,3,2},  //35
                            {5,4,2,2},  //36
                            {5,4,1,2},  //37
                            {5,5,3,2},  //38
                            {5,5,2,2},  //39
                            {5,5,1,2}}; //40

    rule = new_rule();
    add_rule(&rule);
    for(i=0; i < NUM_REGLAS; i++) {
        mf_type *aux_mf;
        aux_io = e;

        // Entrada
        // Para j = 0: Error
        // Para j = 1: Derivada de la temperatura
        // Para j = 2: Condicionante
        for(j = 0; j < 3; ++j) {
            if(R[i][j] != 0) {
                k = 1;
                for(aux_mf=aux_io->membership_functions; aux_mf != NULL; aux_mf=aux_mf->next) { // recorro las mf
                    if(k == R[i][j]) { // Cuando encuentro la mf que me interesa, le asigno el valor
                        append_rule_if(rule, &aux_mf->value);
                    }
                    k++;
                }
            }
            aux_io = aux_io->next;
        }

        //Salida
        aux_mf = s->membership_functions;

        if(R[i][3] == 1) {  //Cerrado
            append_rule_then(rule, &aux_mf->value);
        }
        else {              //Abierto
            aux_mf = aux_mf->next;
            append_rule_then(rule, &aux_mf->value);
        }
    }
}

// El main está para que no salte el error en pruebas del compilador
int main() {}
while(is_alive(yourself)) {
    make_true(yourself, yourdreams);
}

ma5acre14
Mensajes: 4
Registrado: 15/03/2019 4:14 pm

Re: Ayuda - Punteros-malloc-

#7 Mensaje por ma5acre14 » 19/03/2019 5:01 am

Joya.. lo estoy mirando y lo pruebo. si queres te paso toda la libreria completa.
la idea es que sea escable y/o modificable, entonces por eso lo hice asi. ademas (no dato menor) no soy muy bueno con la programación, pedí ayuda y me mandaron por este camino, asiq a muerte con este camino jaja

En estos dias estuve haciendo pruebas en la placa y descubrí qe modificando el tamaño de la heap memory (de 2KB a 10KB) me permitía hacer muchas mas instrucciones, igual se tilda mas adelante, pero me parece qe puede ir por ahi la cosa tambien. El micro qe utilizo tiene 32KB de memoria de datos y el IDE me dice qe estoy usando unos 21KB entonces cuando aumento la heap a 10KB no debo estar dejando memoria disponible para el stack o algo por el estilo..es una teoría nada mas fundada en poco y nada conocimiento.

te adjunto la libreria por las dudas qe tengas curiosidad de qe se trata.
gracias y cuando termine de probar te cuento!
Adjuntos
Desktop.zip
(7.98 KiB) Descargado 10 veces

mollok
Mensajes: 439
Registrado: 30/01/2018 9:47 am
Ubicación: Mallorca, España

Re: Ayuda - Punteros-malloc-

#8 Mensaje por mollok » 19/03/2019 7:44 am

Por lo que dices parece que sí, que el stack comparte memoria con el heap.

Por cómo hiciste el programa está todo muy codificado a mano. Si bien es la forma más rápida pues no hay sobrecarga de operaciones es muy poco modulable.

Voy a mirar tu proyecto, a ver que tal.
while(is_alive(yourself)) {
    make_true(yourself, yourdreams);
}

Responder

¿Quién está conectado?

Usuarios navegando por este Foro: No hay usuarios registrados visitando el Foro y 9 invitados