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.

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

• !=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

• )  // Cuando encuentro la mf que me interesa, le asigno el valor

         {
            aux_ret->value = &(aux_mf->value);
          }
          j++;
        }
        if(( R [1] != 0) || (R[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[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[1])
          {
            aux_ret->value = &(aux_mf->value);
          }
          j++;
        }
        if(R[2] != 0) // chequeo si hay mas antecedentes
        {
          aux_ret->next = malloc(sizeof(struct rule_element_type));
          aux_ret = aux_ret->next;
        }
      }
      //Condicionante
      if(R[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[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[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 función.
    }