Tipos de variables

[migsantiago]

Hola

Estoy estudiando una librería en donde se definen los tipos de variables que un compilador usa. Me encuentro con variables nuevas para mi. Las pongo a continuación.

Código: [Seleccionar]

/*+----------------------------------------------------------------------------------------------+*/
typedef unsigned char u8; ///< 8bit unsigned integer
typedef unsigned short u16; ///< 16bit unsigned integer
typedef unsigned int u32; ///< 32bit unsigned integer
typedef unsigned long long u64; ///< 64bit unsigned integer
/*+----------------------------------------------------------------------------------------------+*/
typedef signed char s8; ///< 8bit signed integer
typedef signed short s16; ///< 16bit signed integer
typedef signed int s32; ///< 32bit signed integer
typedef signed long long s64; ///< 64bit signed integer
/*+----------------------------------------------------------------------------------------------+*/
typedef volatile unsigned char vu8; ///< 8bit unsigned volatile integer
typedef volatile unsigned short vu16; ///< 16bit unsigned volatile integer
typedef volatile unsigned int vu32; ///< 32bit unsigned volatile integer
typedef volatile unsigned long long vu64; ///< 64bit unsigned volatile integer
/*+----------------------------------------------------------------------------------------------+*/
typedef volatile signed char vs8; ///< 8bit signed volatile integer
typedef volatile signed short vs16; ///< 16bit signed volatile integer
typedef volatile signed int vs32; ///< 32bit signed volatile integer
typedef volatile signed long long vs64; ///< 64bit signed volatile integer
/*+----------------------------------------------------------------------------------------------+*/
// fixed point math typedefs
typedef s16 sfp16;                              ///< 1:7:8 fixed point
typedef s32 sfp32;                              ///< 1:19:8 fixed point
typedef u16 ufp16;                              ///< 8:8 fixed point
typedef u32 ufp32;                              ///< 24:8 fixed point
/*+----------------------------------------------------------------------------------------------+*/
typedef float f32;
typedef double f64;
/*+----------------------------------------------------------------------------------------------+*/
typedef volatile float vf32;
typedef volatile double vf64;
/*+----------------------------------------------------------------------------------------------+*/
typedef unsigned int BOOL;
/*+----------------------------------------------------------------------------------------------+*/
// alias type typedefs
#define FIXED s32                               ///< Alias type for sfp32
/*+----------------------------------------------------------------------------------------------+*/
¿Me podrían explicar las siguientes por favor?

unsigned volatile integer
signed volatile integer
fixed point
volatile float
volatile double

¿Por qué son valátiles? ¿Toda la RAM es volátil no? ¿Por qué punto fijo y no flotante? 

Gracias

[MGLSOFT]

A que compilador pertenecen??

[RICHI777]

Hola, el calificador "volatile" instruye al compilador para que no haga ninguna optimizacion sobre la misma y acceda tal cual aparece en el codigo, normalmente en cualquier compilador para embebidos el compilador optimza mucho, ejemplo
...

Código: [Seleccionar]

volatile byte Register; // assumimos que es un registro del micro
byte Prueba;
Prueba = Register;
Prueba = Register;
Prueba = Register;

Si la variable no es "calificada" como volatile el compilador elimina las dos primeras lineas, porque asume que es una operacion sin sentido, al colocar volatile el compilador no optimiza nada, y las tres asignaciones son hechas.
Saludos

[migsantiago]

Richi, ¿entonces conviene usarlas? Porque mejor sigo usando las antiguas int, float, long, etc. No estoy haciendo programas complejos ni importa la velocidad con que se ejecuten.

MGLSoft, estoy adentrándome al compilador que trae el devkitPro para el Nintendo Gamecube. Estoy haciendo mi segundo programa, el primero fue el Hello World 

Estaba estudiando las variables que puedo usar y me encontré con esas raras.

Todavía tengo la duda de qué es fixed point.

[RICHI777]

Santiago, normalmente se usan cuando interactuas con el hardware o cuando usas una variable compartida con algun handler de interrupcion. Con respecto a los nombres fixed, integer son llamados typedefs que no son ni mas ni menos que tipos definidos por el usuario para mejor claridad del codigo, ejemplo en "C" standart el Bool no esta implementado es decir no es un tipo de datos intrinsico del lenguaje como lo es char, int, long pero con un simple arreglo se puede definir

Código: [Seleccionar]

typedef unsigned char Bool
El compilador sabe ahora que el tipo Bool es un unsigned char
En el compilador que estas usuando se define asi

*+----------------------------------------------------------------------------------------------+*/
typedef unsigned int BOOL;
/*+----------------------------------------------------------------------------------------------+*/

En este caso se define como un entero, esto se hace para optimizar el uso del tipo de datos que el micro ( en tu caso seguro que es de 32 bits o mas ) puede manejar mas rapidamente...pero esto es tema para otro post.
Con respecto a Fixed Point se refiere a operando de punto fijo es decir no posee decimales como los floats, double como veras solo es una cuestion de notacion.

Saludos !

[migsantiago]

Ohh, entonces el fixed point, ¿se puede considerar como un unsigned int por ejemplo?

El procesador del Nintendo es de 128bits, pero la variable int es trabajada por el compilador a 32bits.

[RICHI777]

Ohh, entonces el fixed point, ¿se puede considerar como un unsigned int por ejemplo?

Correcto !

El procesador del Nintendo es de 128bits, pero la variable int es trabajada por el compilador a 32bits.

Pabada de micro tiene

Saludos !

[migsantiago]

Hola de nuevo

¿Qué significa una declaración de variable así?

extern u8 variable[];

Sé que es una cadena de chars de tamaño indefinido, pero ¿qué se logra con ponerle extern? 

[RICHI777]

La idea es que tengo vision global, el compilador trata a la variable como esta declarada ( U8 char * ) y el linker define la direccion real de la misa, obvio que en algun modulo debe estar declarada. Basicamente es lo mismo cuando en assembler  declaras variables como PUBLIC y EXTERN.
Saludos !

[migsantiago]

Ah OK, entonces es global nadamás. Tenía la idea de que al poner extern se usaba otra memoria RAM externa, y como el Nintendo tiene memoria RAM de audio, creí que era esa.

Gracias Richi

[jfh900]

La etiqueta extern se pone cuando una variable esta declarada en otro fichero y dado que solo se puede resolver en tiempo de "linkado", para evitar que el compilador de un error de variable no declarada, se utiliza esta etiqueta.

Un saludo

[migsantiago]

Mmhh, sí, de hecho la llena con lo obtenido de un archivo .s, pero estoy viendo si alguien me puede ayudar... 

http://www.todopic.com.ar/foros/index.php?topic=21215.0

[maunix]

Mi consejo es que las variables las definas siempre como su tipado normal. 

Usa el modo "volatile" cuando la variable sea global y no solo se modifique en la rutina actual sino que pueda ser modificada por otras rutinas de modo inesperado ya sea por interrupción (caso típico de microcontroladores) o por "eventos" que serían interrupciones al flujo normal de ejecución de un programa, esto último ya aplica más a sistemas operativos como windows o linux.

[migsantiago]

OK, Maunix.

Es que en los programas de ejemplo que veo en este compilador para el Gamecube, estoy viendo puras variables raras y métodos de rellenarlas igual de raros.

[maunix]

OK, Maunix.

Es que en los programas de ejemplo que veo en este compilador para el Gamecube, estoy viendo puras variables raras y métodos de rellenarlas igual de raros.

Lo de los métodos de rellenarlas podrías postearlos y vemos si los podemos comprender

Lo de las 'variables raras' que mencionaste más arriba en el post, en realidad simplemente es una forma de "cambiar el nombre" de un tipo de variable ya sea para abreviar su sintaxis (vu8 sería volatile unsigned char) o también para unificar tipos de variables entre compiladores.

A veces sucede que uno usa varios compiladores para una misma plataforma o bien usa varias plataformas, y quiere que un código se " lo más transportable posible " entre compiladores y entre plataformas.   Entonces, una forma es declarar tipos de variable que signifiquen lo mismo sin depender de la plataforma.

Para ser más claro

Por ejemplo, en ccs el tipo int es un tipo de 8 bits.  En C18 int es un tipo de 16 bits.  Si quisiéramos copiar/pegar un código de C18 en ccs sin tener en cuenta ese pequeño gran detalle, el código es muy muy muy posible que no funcione.  Entonces una forma sería hacer un archivo .h de encabezados en CCS y otro en C18.  Ambos de mismo nombre pero diferente contenido.

Ese archivo podría tener algo así como

En CCS

typedef BYTE int


En C18

typedef BYTE char


Luego en el código "transportable" declararíamos las variables como BYTE y asunto solucionado.