elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: AIO elhacker.NET 2021 Compilación herramientas análisis y desinfección malware


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación C/C++ (Moderadores: Eternal Idol, Littlehorse, K-YreX)
| | |-+  Ayuda - Punteros-malloc-
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: Ayuda - Punteros-malloc-  (Leído 401 veces)
ma5acre.14

Desconectado Desconectado

Mensajes: 1


Ver Perfil
Ayuda - Punteros-malloc-
« en: 16 Marzo 2019, 01:05 am »

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


« Última modificación: 16 Marzo 2019, 01:26 am por ma5acre.14 » En línea

Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
Ayuda con el uso de malloc
Programación C/C++
alexis33de 2 3,065 Último mensaje 21 Agosto 2010, 23:18 pm
por alexis33de
Problemilla con punteros y malloc
Programación C/C++
totolia 2 3,044 Último mensaje 25 Marzo 2012, 01:02 am
por totolia
Ayuda con el uso de malloc en char (C) « 1 2 »
Programación C/C++
m4rkk0s 15 5,111 Último mensaje 3 Julio 2012, 14:42 pm
por DickGumshoe
[Ayuda-C] Programación de MV; Punteros, malloc() y free()
Programación C/C++
Miky Gonzalez 6 1,919 Último mensaje 14 Julio 2013, 15:26 pm
por Miky Gonzalez
[Ayuda] Array dinamico malloc/realloc con puntero doble
Programación C/C++
mokaNordic 2 1,715 Último mensaje 28 Noviembre 2014, 01:36 am
por mokaNordic
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines