TODOPIC

Microcontroladores PIC => Lenguaje C para microcontroladores PIC => Mensaje iniciado por: Carlos2302 en 06 de Enero de 2020, 16:16:17

Título: Sobre este codigo
Publicado por: Carlos2302 en 06 de Enero de 2020, 16:16:17

Hola muchachos alguien me puede explicar este código lo utilizo para leer la eeprom y guardar el valor directamente en un int32 pero no entiendo cómo funciona en la simulación con proteus funciona bien.
Int32 ret;
      unsigned int8* pret = &ret;
int i,Dir;
Dir=0;
   for(i=0;i<SERIAL_SIZE;i++)
   *pret++ = read_eeprom(Dir++);
   return ret;

Título: Re:Sobre este codigo
Publicado por: remi04 en 06 de Enero de 2020, 18:41:43

Básicamente lo que hace es leer 4 posiciones contiguas en la memoria eeprom serial o interna, etc y construir una variable única de 32 bits con esos 4 valores.  ( SERIAL_SIZE). Digo 4 valores / 32 bits pero puede ser un valor de 16 bits creados a partir de dos posiciónes de eeprom.  Para no liarte mucho asumiré que se trata de un valor de 32’bits y que SERIAL_SIZE vale 4 por consiguiente.


La forma de hacerlo es mediante puntero:
- Crea primero la variable de 32 bits que albergará el valor final.  (ret)
- Luego crea una variable de tipo puntero de 8 bits (int8* pret) la cual es inicializada con la dirección de memoria (&ret) del primer byte de la variable ret

-Luego declara un entero (i) clásicamente usado para la iteracción for();
Y un entero (dir) para direccionar la memoria eeprom. (Leerá 4 posiciones contiguas para construir la variable de 32 bits)  Esta variable no es de tipo puntero pero a efecto práctico actuará con la eeprom como si lo fuese ya que apuntará a la dirección de memoria de la eeprom donde está el valor que quiero leer. Hace lo mismo, con la diferencia de que la variable puntero pret es necesaria para poder apuntar a la dirección ram interna de la cpu que queramos. 

Luego la interacción lo que hace es:

  - Carga en la dirección de memoria donde apunta pret ( que como vimos arriba, apunta a la dirección de memoria del primer byte de ret) el valor leído en la posición cero de la eeprom.  (dir = 0)

 - Incrementa la dirección a la siguiente de la eeprom (dir++) para la siguiente iteracción.

 -  Incrementa el apuntador (pret++). Ahora pret apunta al siguiente byte de la variable ret.

   De nuevo se lee la eeprom (siguiente valor que había sido incrementado antes (dir++) ) 
 Y se asigna su contenido a donde está apuntando pret que es el segundo byte de ret.

  Se repite la operación : SERIAL_SIZE veces, donde SERIAL_SIZE estará cargado con el número de bytes de la variable a construir como ya vimos arriba.  4 en este caso .

 Finalmente retorna el valor de 32 bits construido a partir de las 4 posiciones eeprom leídas.


Explicado linea a línea sobre el código sería:

Código: C

1. Int32 ret; //variable de 32 bits. (4 bytes)
2.       unsigned int8* pret = &ret; // puntero para apuntar a la dirección de memoria de        cada uno de los 4 bytes de la variable ret.
3. int i,Dir;  //  Variables de control iteracción y dirección de la eeprom .
4. Dir=0;   // inicializacion del director de la eeprom a la dirección cero de la misma.
5.    for(i=0;i<SERIAL_SIZE;i++) //Se repetirá SERIAL_SIZE veces la siguiente línea:
6.    *pret++ = read_eeprom(Dir++); //lee la direccion correspondiente de la eeprom y carga su valor en la dirección de memoria a donde apunta pret.  luego incrementa en una unidad tanto dir como pret, (dir++, pret++). Y ejecuta la siguiente repetición de la iteracción
7.    return ret;  // concluida la iteracción devuelve el valor de 32 bits obtenidos a partir de 4 posiciones eeprom de 8 bits.

Título: Re:Sobre este codigo
Publicado por: Carlos2302 en 06 de Enero de 2020, 19:06:32

Gracias por responder remi04 pues exactamente eso es lo que pensaba pero lo que no entendia es que si yo creo una variable del tipo int32 y luego creo una variable del tipo puntero de int8, como es que apunta a una variable int32 si son dos datos diferentes, ahora no se si sera que int32 y int8 son el mismo tipo de dato solo que una es mas pequeño que el otro. Yo me estaba matando la cabeza preguntando como hace el puntero de int8 para apuntar a int32. Pero tu razonamiento yo lo pensaba pero tu me lo acabas de afirmar gracias. :-/

Título: Re:Sobre este codigo
Publicado por: remi04 en 06 de Enero de 2020, 19:15:30

Cita de: Carlos2302 en 06 de Enero de 2020, 19:06:32

Gracias por responder remi04 pues exactamente eso es lo que pensaba pero lo que no entendia es que si yo creo una variable del tipo int32 y luego creo una variable del tipo puntero de int8, como es que apunta a una variable int32 si son dos datos diferentes, ahora no se si sera que int32 y int8 son el mismo tipo de dato solo que una es mas pequeño que el otro. Yo me estaba matando la cabeza preguntando como hace el puntero de int8 para apuntar a int32. Pero tu razonamiento yo lo pensaba pero tu me lo acabas de afirmar gracias. :-/

 Así es. Cada posición de memoria de la cpu son 8 bits (en micros de 8 bits claro),

 Cuando declaras una variable de 32 bits lo que hace el compilador es coger 4 posiciones contiguas de memoria para construirla.  Si por ejemplo la dirección de tu variable de 32 bits es 100,  internamente esa variable ocupará las posiciones 100,101,102 y 103.  Esas 4 posiciones quedan reservadas para tu variable.

  Si accedes a la variable de forma directa siempre modificarás o leerás las 4 posiciones como una sola. Pero con un puntero de 8 bits puedes acceder individualmente a cada byte (100, 101,102 o 103) el que quieras de esa variable y leer o modificar su contenido, que es justo lo que hace tu programa.