Simple Math Operations Giving Unexpected Outputs

ebitdamonster · May 4, 2021, 1:57pm

Hey guys,

I am plotting a circle using two stepper motors. The X axis is relatively simple, stepping one step at a time. Here is the code I use to plot the circle:

void circle(int r){
  int r2 = sq(r);
  for (int i=1;i<r;i++){
    x.step(1);
    curx+=1;
    int yts = (sqrt(r2 - (curx * curx) ) );
    y.step(yts);
    cury += yts;
  }
}

I am a novice at this, and I suspect my problem has to do with the data type of int, and the limitations thereof. I have also tried using both long and signed long. Either way, I keep getting strange numbers for sq(300), usually between 25,000 and 35,000.

I understand that there is a maximum value for ints, but what data type should I be using to store numbers like 300^2: five digits?

wildbill · May 4, 2021, 1:59pm

long will do it. Just make sure that you use it everywhere you're currently using int.

ebitdamonster · May 4, 2021, 2:04pm

You're a magician!

Your comment made me realize that I was declaring the radius as an integer (I didn't think it'd be a problem since the usable drawing area is only 1000 steps, so a theoretical maximum radius of 1000), but I assume that an operation between a long and an int returns an int.

Changing the data type for the radius to long fixed the issue, and everything is working as expected now.

Thanks!

blh64 · May 4, 2021, 4:01pm

You assume incorrectly. If you declare r2 as long, it will work out as well. The compiler uses the smallest available size so once you involve a long, it all turns into a long for the operator, then the sqrt returns a float and it gets truncated into an int to assign to yts. You did not specify what type curx is which could also impact the results. For example, if curx was uint8_t, then the
(curx * curx) portion could be done with 8 bit miltiplication which would be wrong and then the long result promoted to a long to subtract from r2...

ebitdamonster · May 4, 2021, 4:32pm

Thanks for the reply.

I defined curx before setup as a long. I am, however, interested in what you said here:

sqrt returns a float and it gets truncated into an int to assign to yts.

Is this the nature of the sqrt() function? Is there a better way to go about this? Here is my updated code (although at the moment, it only draws 1/4 of a circle):

void circle(long r){
  Serial.println("Starting the circle.");
  long r2 = sq(r);
  Serial.println("Radius squared: ");
  Serial.println(r2);
  for (int i=0;i<r;i++){
    x.step(1);
    curx+=1;
    long expy = (sqrt(r2 - (sq(curx))))+1;
    y.step(expy-cury);
    cury = expy;
    Serial.println();
    Serial.print("  X: "+String(curx));
    Serial.print("  Y: "+String(cury));
  }
  delay(10000);
}

PieterP · May 4, 2021, 6:34pm

You don't need square roots at all, and everything can be done with integers, see Midpoint circle algorithm - Wikipedia.

ruilviana · May 4, 2021, 6:36pm

see if this scketch meets your need.

float curx = 0;
float cury = 0;
const float pi = 3.141592;
const float rad = pi / 180;
//-------------------------------------------------------------------
void setup() {
  Serial.begin(115200);
  circle(300);
}
//-------------------------------------------------------------------
void loop() {
}
//-------------------------------------------------------------------
void circle(long r) {
  Serial.println("Starting the circle.");
  for (float i = 0; i < 90.3; i += 0.3)
  {
    curx = sin(i * rad);
    cury = cos(i * rad);
    Serial.print("  ang. " + String(i) + "  ");
    Serial.print("  X: " + String((curx * r),0));
    Serial.println("  Y: " + String((cury * r),0 ));
    delay(10000);
  }
}

ebitdamonster · May 4, 2021, 5:17pm

Hey guys,

I'm working on plotting a circle using two stepper motors. One controls the X axis, the other controls the Y axis. Pretty simple setup.

Here's the section of my code that is intended to draw one quadrant of the circle:

void circle(long r){
  Serial.println("Starting the circle.");
  long r2 = sq(r);
  Serial.println("Radius squared: ");
  Serial.println(r2);
  for (int i=0;i<r;i++){
    x.step(1);
    curx+=1;
    long expy = (sqrt(r2 - (sq(curx))))+1;
    y.step(expy-cury);
    cury = expy;
    Serial.println();
    Serial.print("  X: "+String(curx));
    Serial.print("  Y: "+String(cury));
  }
  delay(10000);
}

The problem is that when I graph the outputted points, it's not circular, even though based on my understanding of the code, I feel like it should be.

I threw the datapoints in Excel just to visualize it, peradventure the machine I built was just imprecise. Plotting it in Excel confirmed the issue:

Is there something about the sqrt() function returning a float that could cause this much of an elongation in my circle?

I've been staring at this all afternoon, just need a different pair of eyes. TIA!

ebitdamonster · May 4, 2021, 5:19pm

Okay, let me point out my own idiocy before anyone else gets the chance.

The Excel graph is not square. Here's an update:

Question still remains though. Here are the datapoints:

ebitdamonster · May 4, 2021, 5:21pm

Here's one more example showing the irregularity:

As you can see, the points near (0, 300) are much more put together and evenly spaced than the points nearer (300, 0).

PaulRB · May 4, 2021, 5:55pm

Your code is stepping through values of X in a linear way. The Y values are not going to be linear, because the circumference of a circle is not a line.

So I'm not sure what you think is unexpected about this. What did you want to happen? What's the problem with the code you have?

ruilviana · May 4, 2021, 6:25pm

see if this scketch meets your need.

float curx = 0;
float cury = 0;
const float pi = 3.141592;
const float rad = pi / 180;
//-------------------------------------------------------------------
void setup() {
  Serial.begin(115200);
  circle(300);
}
//-------------------------------------------------------------------
void loop() {
}
//-------------------------------------------------------------------
void circle(long r) {
  Serial.println("Starting the circle.");
  for (float i = 0; i < 90.3; i += 0.3)
  {
    curx = sin(i * rad);
    cury = cos(i * rad);
    Serial.print("  ang. " + String(i) + "  ");
    Serial.print("  X: " + String((curx * r),0));
    Serial.println("  Y: " + String((cury * r),0 ));
    delay(10000);
  }
}

UKHeliBob · May 4, 2021, 7:04pm

Topics on the same subject merged

dlloyd · May 4, 2021, 8:54pm

Same here ...

westfw · May 5, 2021, 6:05am

You might want to research “Bresenham circle drawing algorithm”

ebitdamonster · May 9, 2021, 10:23pm

Alright, I figured it out guys. TL;DR: I'm kind of an idiot.

PaulRB was mostly right, but to put it more simply: I'm generating this circle by stepping through values of X, one at a time. At x=0, y=radius of the circle, the Y values change very slowly, hence the smoothness. At x=radius, y=0, I'm still only stepping X by one value at a time, but Y changes more per value of X, giving it a choppier look.

The question I asked was essentially flawed from the start. Thanks everyone for the responses.

system · September 6, 2021, 10:24pm

This topic was automatically closed 120 days after the last reply. New replies are no longer allowed.

Topic		Replies	Views
Data Types and Sqrt() Programming	2	647	May 4, 2021
Problem with simple math code. sqrt() and sq() and the long variable type Programming	8	18767	May 5, 2021
Too Much Math on One Line ? Programming	13	3157	May 5, 2021
Formula Help Programming	5	386	May 6, 2021
mathematical burden Programming	10	1295	May 6, 2021

Simple Math Operations Giving Unexpected Outputs

Related topics