//GET VOLTAGE
	//Vref = 3.3V
	//12bit AtoD = 0 to 4095
	//4095 = 3.3V



	double d_temp;
	d_temp = (((double)3.3 / 4095) * atod_buffer_0);

	WORD voltage_x100;
	voltage_x100 = (WORD)((((double)3.3 / 4095) * atod_buffer_0) * 100);

Converting Voltage Value After Potential Divider Resistors

	//Vref = 3.3V
	//12bit AtoD = 0 to 4095
	//4095 = 3.3V

	//Potential divider input:- Vin -> 39K -> AtoD -> 100K -> Gnd
	//Total resistance = 139
	//To Gnd resistance = 100

	double d_temp;
	d_temp = ((((double)3.3 * ((double)139 / 100)) / 4095) * atod_buffer_0);

	WORD voltage_x100;
	voltage_x100 = (WORD)(((((double)3.3 * ((double)139 / 100)) / 4095) * atod_buffer_0) * 100);

For instance if double d = 5.83

x = (WORD)d;

Would produce x=5

x = (WORD)rint(d);

Would produce x=6

In C you use pow()

	pow(base, exponent)

In C you can use exponents in two places. Firstly, where numbers are so large or so small that decimal point notation is not human-readable. For instance 100,000,000,000 is best written as 1 * 10 ^11. Secondly where the program logic calls for a value to be raised to the power of another value.

For instance, say you have a virus multiplying in a large population, and each infected person infects another five on average before dying. How many people will be infected after N rounds? The answer is 5^N, or, in C, pow(5.0, N).

For mathematical reasons which are too involved to go into here the expression e^x has special characteristics, so it has its own function, exp(). The expression x^0.5, or sqrt(x) is also special and has its own function – here it is easy for a non-mathematician to see the value of this.

typedef union _SYSTEM_CONFIGURATION_TYPEDEF
{
    DWORD dw[25];
    WORD w[50];
    BYTE b[100];
} SYSTEM_CONFIGURATION_TYPEDEF;



SYSTEM_CONFIGURATION_TYPEDEF system_config_buffer;

	system_config_buffer.b[0] = 1;
	system_config_buffer.b[1] = 2;
	system_config_buffer.b[2] = 3;
	system_config_buffer.b[3] = 4;
	system_config_buffer.b[4] = 5;
	//Will give:
	//system_config_buffer.w = 0x0201
	//system_config_buffer.dw = 0x04030201

Typedef Struct For A Buffer Of Different Registers In An Buffer

typedef struct _TEST_HEADER
{
	WORD source_port;
	DWORD sequence_number;

	union		//<<< You can also have unions inside a struct
	{
		struct
		{
			BYTE flag_fin	:1;
			BYTE flag_syn	:1;
			BYTE flag_rst	:1;
			BYTE flag_psh	:1;
			BYTE flag_ack	:1;
			BYTE flag_urg	:1;
			BYTE reserved	:2;
		} bits;
		BYTE byte;
	} flags;

	WORD window;
} TEST_HEADER;

#define	USART_DIR_TX(state)	(state ? ([true]) : ([false]))

(state ? true : false)  //1:0



#define OUTPUT_PIN(state) (state ? LATAbis.LATA1 = 1 : LATAbis.LATA1 = 0)  //1:0

	bytesThisSector = (bytesLeftToWrite > 512) ? 512 : bytesLeftToWrite;

	sizeof(char) 		// = 1
	sizeof(my_array) 		// = size of the array in bytes
	sizeof(my_structure) 	// = size of the structure in bytes
	sizeof(my_union) 		// = size of the union in bytes

	for count = 0; count < (sizeof(my_array) / sizeof(my_array_tye)); count++)
	{
		//Do each entry in the array of a not necessarily known object size

Note that 16 and 32bit compilers may add padd bytes and these will be included in the sizeof - this can be a source of bugs!

Avoiding Padding

You can used the packed variable attribute. For example in the following code, type c_t will have a size of 3 bytes and there will be no wasted space between a and b:

typedef struct
{
  unsigned char a[1];
} __attribute__ ((packed)) a_t;

typedef struct
{
  unsigned char b[2];
} __attribute__ ((packed)) b_t;

typedef struct
{
  a_t a;
  b_t b;
} __attribute__ ((packed)) c_t;