Foro de elhacker.NET

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.
   }