RADAR Range Equation

The radar range equation is the most fundamental formula for radar operation. As its name implies, it gives the possible maximum range of a radar, as determined by the following factors:

• Electrical noise. This is a function of environmental noise, which tends to be unpredictable, and the noise inherent in the electronic systems of the receiver. A radar pulse echo return must be above the noise threshold for a target to be detected.
• Transmitter power. As mentioned, this is a function of pulse power and PRF, as well as antenna gain.
• Receiver gain. This is a function of the receiver antenna gain and the sensitivity of the receiver electronics.
• Attenuation due to range. The power of a radar beam will fall off with the square of distance. Since the radar must pick up the return echo of the transmit pulse, which also falls off by the square of distance, that means that the strength of a return pulse falls off by the fourth power of the distance to the target.
• Target "radar cross section (RCS)". The RCS of a target is effectively its reflectivity to radar. RCS varies with the material being illuminated, for example metal surfaces tend to be more reflective than plastic surfaces, and with the physical configuration of the surfaces. A smooth surface tends to be less reflective than a jagged rough surface. The RCS of a target tends to be highly variable, depending on the viewing angle of the target. An aircraft that is very bright to radar from one angle may be almost invisible from another, and its radar return may change drastically as it flies around.
• Atmospheric attenuation. This is the trickiest of all the factors to estimate, since it can vary wildly given different atmospheric conditions. It is usually just given as a flat constant, since it is hard to do much better in practice.

This gives a simplified version of the radar range equation:

     power * gain * RCS

   -----------------------  >  noise

    attenuation * range^4

There are many variations of this equation, usually providing greater detail or modified to demonstrate the capabilities of different radar configurations. The basic idea is simple: the capability of a radar to detect a target is directly proportional to its transmit power, its receiver gain, and the RCS of a target; and inversely proportional to the atmospheric attenuation and the fourth power of the range.

OpenGL curve Program

#include

#include "stdafx.h"

GLfloat ctrlpoints[4][3] = {

        { -4.0, -4.0, 0.0}, { -2.0, 4.0, 0.0},

        {2.0, -4.0, 0.0}, {4.0, 4.0, 0.0}};

void init(void)

{

   glClearColor(0.0, 0.0, 0.0, 0.0);

   glShadeModel(GL_FLAT);

   glMap1f(GL_MAP1_VERTEX_3, 0.0, 1.0, 3, 4, &ctrlpoints[0][0]);

   glEnable(GL_MAP1_VERTEX_3);

}

void display(void)

{

   int i;

   glClear(GL_COLOR_BUFFER_BIT);

   glColor3f(1.0, 1.0, 1.0);

   glBegin(GL_LINE_STRIP);

      for (i = 0; i <= 30; i++)

         glEvalCoord1f((GLfloat) i/30.0);

   glEnd();

   /* The following code displays the control points as dots. */

   glPointSize(5.0);

   glColor3f(1.0, 1.0, 0.0);

   glBegin(GL_POINTS);

      for (i = 0; i < 4; i++)

         glVertex3fv(&ctrlpoints[i][0]);

   glEnd();

   glFlush();

}

void reshape(int w, int h)

{

   glViewport(0, 0, (GLsizei) w, (GLsizei) h);

   glMatrixMode(GL_PROJECTION);

   glLoadIdentity();

   if (w <= h)

      glOrtho(-5.0, 5.0, -5.0*(GLfloat)h/(GLfloat)w,

               5.0*(GLfloat)h/(GLfloat)w, -5.0, 5.0);

   else

      glOrtho(-5.0*(GLfloat)w/(GLfloat)h,

               5.0*(GLfloat)w/(GLfloat)h, -5.0, 5.0, -5.0, 5.0);

   glMatrixMode(GL_MODELVIEW);

   glLoadIdentity();

}

int main(int argc, char** argv)

{

   glutInit(&argc, argv);

   glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);

   glutInitWindowSize (500, 500);

   glutInitWindowPosition (100, 100);

   glutCreateWindow (argv[0]);

   init ();

   glutDisplayFunc(display);

   glutReshapeFunc(reshape);

   glutMainLoop();

   return 0;

}

Edge-triggered D flip-flop

Edge-triggered D flip-flop

A more efficient way to make a D flip-flop is not so easy to understand, but it works the same way. While the master–slave D flip-flop is also triggered on the edge of a clock, its components are each triggered by clock levels. The "edge-triggered D flip-flop" does not have the master–slave properties.

Edge Triggered D flip flops are often implemented in integrated high speed operations using dynamic logic. This means that the digital output is stored on parasitic device capacitance while the device is not transitioning. This design of dynamic flip flops also enable simple resetting since the reset operation can be performed by simply discharging one or more internal nodes. A common dynamic flip flop variety is the True Single Phase Clock (TSPC) which performs the flip flop operation with little power and at high speeds.

D FlipFlop

D flip-flop

The D flip-flop is the most common flip-flop in use today. It is better known as delay flip-flop

The Q output always takes on the state of the D input at the moment of a positive edge (or negative edge if the clock input is active low). It is called the D flip-flop for this reason, since the output takes the value of the D input or Data input, and Delays it by one clock count. The D flip-flop can be interpreted as a primitive memory cell, aero order hold, or delay line. Whenever the clock pulses, the value of Q_next is D and Q_prev otherwise.

Truth table:

Clock	D	Q	Qprev
Rising edge	0	0	X
Rising edge	1	1	X
Non-Rising	X	Qprev

('X' denotes a Don’t care condition, meaning the signal is irrelevant)

These flip-flops are very useful, as they form the basis for shift registers, which are an essential part of many electronic devices. The advantage of the D flip-flop over the D-type latch is that it "captures" the signal at the moment the clock goes high, and subsequent changes of the data line do not influence Q until the next rising clock edge. An exception is that some flip-flops have a "reset" signal input, which will reset Q (to zero), and may be either asynchronous or synchronous with the clock.

The above circuit shifts the contents of the register to the right, one bit position on each active transition of the clock. The input X is shifted into the leftmost bit position.

C Important Interview Questions

Int *a[10] refers to

        (a) array of pointers        (b) pointer to an array        (c) pointer to a pointer          (d)        none of these

 Identify the incorrect one from below

                1.if(c=1)

                2.if(c!=3)

                3.if(a

                4.if(c==1)

        (a) 1 only                     (b) 1&3                            (c) 3 only                            (d) All of the above

Regarding the scope of the variables, identify the incorrect statement below:

(a) automatic variables are automatically initialized to 0    (b) static variables are are automatically initialized to 0

(c) the address of a register variable is not accessible       (d) static variables cannot be initialized with any expression

condition 1?condition 2?condition 3?:exp 1:exp 2:exp 3:exp 4;

is equivalent to which of the following?

                (a) if condition 1

                    exp 1;

                    else if condition 2

                    exp 2;

                    else if condition 3

                    exp 3;

                    else exp 4;

                (b) if condition 1

                    if condition 2

                    if condition 3

                    exp 1;

                    else exp 2;

                    else exp 3;

                    else exp 4;

                (c) if condition 1 && condition 2 && condition 3

                    exp 1 |exp 2|exp 3|exp 4;

                (d) if condition 3

                    exp 1;

                    else if condition 2 exp 2;

                    else if condition 3 exp 3;

                    else exp 4;

What is y value of the code, if input x=10

            y=5;

            if (x==10)

            else if(x==9)

            else y=8;

        (a)9                            (b)8                                 (c)6                            (d)7 

Given the piece of code

                int a[50];

                int *pa;

                pa=a;

     To access the 6th element of the array which of the following is incorrect?

     (a) *(a+5)                                (b) a[5]                     (c) pa[5]                           (d) *(*pa + 5) 

Consider the following program

        main()

        {

                unsigned int i=10;

                while(i>=0)

                {

                       printf("%u",i)

                       i--;

                }

       }

    How many times the loop will get executed

    (a)10                                (b)9                                (c)11                                (d) infinite

What is true about the following C Functions

        (a) Need not return any value                   (b) Should always return an integer

        (c) Should always return a float                (d) Should always return more than one value