Solution using Modulo

A simple solution that catches all cases.

degrees = (degrees + 360) % 360;  // +360 for implementations where mod returns negative numbers

Explanation

Positive: 1 to 180

If you mod any positive number between 1 and 180 by 360, you will get the exact same number you put in. Mod here just ensures these positive numbers are returned as the same value.

Negative: -180 to -1

Using mod here will return values in the range of 180 and 359 degrees.

Special cases: 0 and 360

Using mod means that 0 is returned, making this a safe 0-359 degrees solution.

You can multiply the result by (180/pi) to convert the magnitude to degrees. If it's negative then you would have to add 360 to it afterwards (assuming you want a range of 0 to 360.)

For example, -pi/2 becomes -90 after the multiplication, and adding that to 360 results in 270, which gives you the amount of degrees to rotate counter-clockwise from the positive x-direction to reach the point (which is what you're looking for I think.)

Try this:

double theta = Math.toDegrees(atan2(y, x));

if (theta < 0.0) {
    theta += 360.0;
}

From the Wikipedia page:

It is returning the shortest angle of rotation from the positive x direction to the point, where a positive angle indicates the counter-clockwise direction. Therefore it makes sense that it would only return values between 0 and 180, since anything greater than 180 can be 'better' approached by a smaller angle in the opposite direction.

Returning -90 instead of 270 also makes sense now, since moving 90 degrees clockwise is less than moving 270 degrees counter-clockwise to reach the same point. This also suggests that your interpretation has mixed up the positive and negative 90 degree directions but is otherwise fine.

atan2 is a mathematical function; it is stateless. There is nothing in it to “know” that you want an angle which is close to the angle from the previous frame, as opposed to an angle which is simply sufficient to identify the direction.

You must write your own logic to handle this case. There are several possible behaviors you could implement; here's the ones I've thought of. Note that I am not familiar with C#, XNA, or Farseer, so I have only pseudocode here, but all of these should work as long as you can retrieve the joint's current actual angle as well as the target angle.

1. The joint should spin the smallest amount to match the direction of the joystick. This means that if the user spins the stick faster than the joint can keep up, it will start turning the other direction to make a shorter motion. This can be implemented as:

   let currentStickDirection = atan2(RightStick.Y, RightStick.X)
   let currentJointDirection = currentJointAngle mod 2π
   let difference = ((currentStickDirection - currentJointDirection + π) mod 2π) - π
   jointTargetAngle = currentJointAngle + difference
   

   The addition and subtraction of π (a half-turn) combined with modulus puts the difference-between-angles in the range −π…+π, which is the “smallest amount to match” property.

   Note that if you are implementing, for example, a turret, then this might be undesirable as it makes it harder to strafe a particular arc as the player needs to make sure not to lead too much.

2. The joint should follow the motions of the stick. That is, if the user quickly makes multiple revolutions of the stick, the joint will follow and make multiple revolutions even if the user's movement is long over.

   To implement this, the logic is the same as above except that instead of using the joint's current actual angle, we use the joint's target angle (which can be simply a variable/field in your program, unrelated to the physics engine) as the state input.

   let currentStickDirection = atan2(RightStick.Y, RightStick.X)
   let currentJointDirection = jointTargetAngle mod 2π
   let difference = ((currentStickDirection - currentJointDirection + π) mod 2π) - π
   jointTargetAngle += difference
   

3. Same as option 2, but the joint will never make an unnecessary full revolution. This differs from option 1 in that the joint will always turn in the same direction as the input does.

   To implement this, use the code from option 2, but after all of the above we also remove extra ±2πs from the target angle:

    let revolutions = (jointTargetAngle - currentJointAngle) / 2π
    if (revolutions >= 1)
        jointTargetAngle -= floor(revolutions) * 2π
    else if (revolutions <= -1)
        jointTargetAngle -= ceil(revolutions) * 2π
   

Note that if the stick is near its center, then small motions, possibly including noise/vibration rather than user motion, will cause large changes in the computed angle. If you haven't already, you will probably want to add a “dead zone” around the center which disables the angle computation. This can be a simple distance condition, like pow(RightStick.Y, 2) + pow(RightStick.X, 2) < pow(deadZoneRadius, 2).

Another interesting option would be to reduce the “motor power” of the joint (I don't know what exact options Farseer provides in this area) depending on the computed distance, so that small pushes on the stick can be used to slowly swing the joint (note that then the imprecision of direction matters less) and moving it to the limit does a fast swing. This would naturally reduce the effect of noise about the center, but unless you are using option 1 above (which does not depend on the previous target angle) and your joystick has perfect mechanical return-to-center, you will still want to have a deadzone.

Commentary: The two key principles here are:

1. Work with differences between angles, not absolute angles.
2. Make sure that (where appropriate for the application) you are treating any particular angle θ as equivalent to θ + 2π. This is the reason for all of the uses of modulo; the π offsets are used to control where we flip from positive to negative numbers, which affects the overall behavior of the algorithm, but not in a way which is dependent on the input range.

To translate degrees range 0..360 into radians range -Pi..Pi:

if(angle > 180)
   angle -= 360;
angle_radians = Math.toRadians(angle);

If your angle may be beyond standard range (you did not mentioned this), use integer modulo instead of loops

angle = angle % 360 

(check how modulo operator works with negative numbers in your language)

The atan function only gives half the unit circle between -pi/2 and +pi/2 (0 on x axis), there is another library function that can give the whole unit circle between -pi and + pi, atan2

I would think you are better of using atan2 to get the right quadrant rather than branching yourself, then just scale as you have been, something like

Math.atan2(y2 - y1, x2 - x1) * 180 / Math.PI + 180

The multiply by 180 over pi is just the scale from radians to degrees as in the question (but with the division by a division simplified), the +180 makes sure its always positive i.e. 0-360 deg rather than -180 to 180 deg

atan2 returns angles in the range (-π, π]. This covers the four quadrants. If you want a value in (0, 2π], it suffices to add 2π to the non-positive angles. For the range [0, 2π), add 2π to the negative only.

atan can only cover two quadrants.

Note that in many cases, you can very well work with (-π, π], adjusting the range is unnecessary