Electronics Engineering

Idc = Irms / Sqr(2)

Avec :

Idc = Courant continu (DC)

Irms = Courant sinusoidal (AC)

AM has a frequency range of 531 kHz to 1602 kHz and on the other hand FM has a frequency range between 8705 MHz to 108 MHz. If we talk about the bandwidth of AM then it is 1071 KHz and bandwidth of FM is 20.5 MHz.

According to the bandwidth FM should be used for long distance transmission but it is not used for long distance but AM is used fir long distance transmissions. the answer is here.

Long distance transmissions are also decided by the Spectrum of the Signal in frequency domain by doing the Fouriertransform of the Signal.

If we draw the Spectrum of AM waves the we find that their is a main loop in the central part of the spectrum with a high frequency and on the left and right side of this loop their are side loop which are very smaller then the main loop. In FM information can be recover from the main loop only not from the side loops. On the other hand in AM waves all the loops in spectrum is of same size and information can be recover from all the loops.

That is why AM is used for long distance transmission.

Thnx -Vipin Jasoria

There is no relationship other than that they are programming concepts. they each serve a different purpose.

Type Definition

A type definition is an alias; an alternate name for a type that already exists. Type definition help to make code easier to read. For instance, instead of using the type "unsigned long long int", we can alias it:

typedef unsigned long long int UINT;

Now we can use the UINT type wherever we would normally have used "unsigned long long int".

Union

A union is a type with two or more members of different types that all have the same start address. The length of a union is determined by the longest member of the union. Unions are useful when you have a variety of data types but do not need to maintain separate values for those types; only one member can be active at any one time. As an example, consider the following:

union pointer {

int* pint;

char* pchar;

};

Here we can assign the memory address of an integer to pint and then read back the first byte of that integer using pchar:

int i=0x12345678;

pointer x;

x.pint = &i;

std::cout<<"Integer: "<<*x.pint<

std::cout<<"Byte: "<<*x.pchar<

The output will be:

Integer: 305419896

Byte: 120

Unions are best avoided as they are often used to provide type-casts that are inherently unsafe.

Enum

An enum is an enumeration. When you define an enumeration you define a type for which some values of that type have names. Those names are constant members of the enum.

enum traffic_light {red, amber, green};

If a type is not specified, the type defaults to an int. Given that there are only three values in this enum, a char would suffice:

enum traffic_light : char {red, amber, green};

Enums are useful in that they allow a related set of constants to be grouped.

If no values are specified, the constants are valued according to the order in which they are declared. Thus the above is equivalent to:

enum traffic_light : char {red=0, amber=1, green=2};

If you assign any value to an enum member, all subsequent members are numbered in sequence:

enum traffic_light : char {red=1, amber, green};

The above is therefore equivalent to:

enum traffic_light : char {red=1, amber=2, green=3};

Enum members can also be given the same value if desired:

enum traffic_light : char {red=1, amber=2, yellow=2, green=3};

Using enums help eliminate coding errors:

void f (traffic_light colour) {/*...*/}

f (red); // ok

f (green); // ok

f (4); // error: 4 is not a member of traffic_light!

Enums are also useful for naming bits:

enum bit {

bit_0 = 1<<0, // = 0x01 = 00000001

bit_1 = 1<<1, // = 0x02 = 00000010

bit_2 = 1<<2, // = 0x04 = 00000100

bit_3 = 1<<3, // = 0x08 = 00001000

bit_4 = 1<<4, // = 0x10 = 00010000

bit_5 = 1<<5, // = 0x20 = 00100000

bit_6 = 1<<6, // = 0x40 = 01000000

bit_7 = 1<<7 // = 0x80 = 10000000

};

void f (bit b)

{

if (b & bit_1)

{

// bit_1 is set in b

}

else

{

// bit_1 is not set in b

}

if (b & (bit_1 | bit_2))

{

// bit_1 and/or bit_2 is set

}

else

{

// neither bit_1 nor bit_2 are set

}

}