Improving with some C++ suggestions (not tested)

Using constants (uppercase), declaring variables when they are initialized, avoiding double checks with 'if' and 'while'...

Author: David Abián

plotclock.ino

@@ -170,84 +170,84 @@ void loop()
 
 } 
 
-// Writing numeral with bx by being the bottom left originpoint. Scale 1 equals a 20 mm high font.
+// Writing numeral with BX BY being the bottom left originpoint. Scale 1 equals a 20 mm high font.
 // The structure follows this principle: move to first startpoint of the numeral, lift down, draw numeral, lift up
-void number(float bx, float by, int num, float scale) {
+void number(const float BX, const float BY, const int NUM, const float SCALE) {
 
-  switch (num) {
+  switch (NUM) {
 
   case 0:
-    drawTo(bx + 12 * scale, by + 6 * scale);
+    drawTo(BX + 12 * SCALE, BY + 6 * SCALE);
     lift(0);
-    bogenGZS(bx + 7 * scale, by + 10 * scale, 10 * scale, -0.8, 6.7, 0.5);
+    bogenGZS(BX + 7 * SCALE, BY + 10 * SCALE, 10 * SCALE, -0.8, 6.7, 0.5);
     lift(1);
     break;
   case 1:
 
-    drawTo(bx + 3 * scale, by + 15 * scale);
+    drawTo(BX + 3 * SCALE, BY + 15 * SCALE);
     lift(0);
-    drawTo(bx + 10 * scale, by + 20 * scale);
-    drawTo(bx + 10 * scale, by + 0 * scale);
+    drawTo(BX + 10 * SCALE, BY + 20 * SCALE);
+    drawTo(BX + 10 * SCALE, BY + 0 * SCALE);
     lift(1);
     break;
   case 2:
-    drawTo(bx + 2 * scale, by + 12 * scale);
+    drawTo(BX + 2 * SCALE, BY + 12 * SCALE);
     lift(0);
-    bogenUZS(bx + 8 * scale, by + 14 * scale, 6 * scale, 3, -0.8, 1);
-    drawTo(bx + 1 * scale, by + 0 * scale);
-    drawTo(bx + 12 * scale, by + 0 * scale);
+    bogenUZS(BX + 8 * SCALE, BY + 14 * SCALE, 6 * SCALE, 3, -0.8, 1);
+    drawTo(BX + 1 * SCALE, BY + 0 * SCALE);
+    drawTo(BX + 12 * SCALE, BY + 0 * SCALE);
     lift(1);
     break;
   case 3:
-    drawTo(bx + 2 * scale, by + 17 * scale);
+    drawTo(BX + 2 * SCALE, BY + 17 * SCALE);
     lift(0);
-    bogenUZS(bx + 5 * scale, by + 15 * scale, 5 * scale, 3, -2, 1);
-    bogenUZS(bx + 5 * scale, by + 5 * scale, 5 * scale, 1.57, -3, 1);
+    bogenUZS(BX + 5 * SCALE, BY + 15 * SCALE, 5 * SCALE, 3, -2, 1);
+    bogenUZS(BX + 5 * SCALE, BY + 5 * SCALE, 5 * SCALE, 1.57, -3, 1);
     lift(1);
     break;
   case 4:
-    drawTo(bx + 10 * scale, by + 0 * scale);
+    drawTo(BX + 10 * SCALE, BY + 0 * SCALE);
     lift(0);
-    drawTo(bx + 10 * scale, by + 20 * scale);
-    drawTo(bx + 2 * scale, by + 6 * scale);
-    drawTo(bx + 12 * scale, by + 6 * scale);
+    drawTo(BX + 10 * SCALE, BY + 20 * SCALE);
+    drawTo(BX + 2 * SCALE, BY + 6 * SCALE);
+    drawTo(BX + 12 * SCALE, BY + 6 * SCALE);
     lift(1);
     break;
   case 5:
-    drawTo(bx + 2 * scale, by + 5 * scale);
+    drawTo(BX + 2 * SCALE, BY + 5 * SCALE);
     lift(0);
-    bogenGZS(bx + 5 * scale, by + 6 * scale, 6 * scale, -2.5, 2, 1);
-    drawTo(bx + 5 * scale, by + 20 * scale);
-    drawTo(bx + 12 * scale, by + 20 * scale);
+    bogenGZS(BX + 5 * SCALE, BY + 6 * SCALE, 6 * SCALE, -2.5, 2, 1);
+    drawTo(BX + 5 * SCALE, BY + 20 * SCALE);
+    drawTo(BX + 12 * SCALE, BY + 20 * SCALE);
     lift(1);
     break;
   case 6:
-    drawTo(bx + 2 * scale, by + 10 * scale);
+    drawTo(BX + 2 * SCALE, BY + 10 * SCALE);
     lift(0);
-    bogenUZS(bx + 7 * scale, by + 6 * scale, 6 * scale, 2, -4.4, 1);
-    drawTo(bx + 11 * scale, by + 20 * scale);
+    bogenUZS(BX + 7 * SCALE, BY + 6 * SCALE, 6 * SCALE, 2, -4.4, 1);
+    drawTo(BX + 11 * SCALE, BY + 20 * SCALE);
     lift(1);
     break;
   case 7:
-    drawTo(bx + 2 * scale, by + 20 * scale);
+    drawTo(BX + 2 * SCALE, BY + 20 * SCALE);
     lift(0);
-    drawTo(bx + 12 * scale, by + 20 * scale);
-    drawTo(bx + 2 * scale, by + 0);
+    drawTo(BX + 12 * SCALE, BY + 20 * SCALE);
+    drawTo(BX + 2 * SCALE, BY + 0);
     lift(1);
     break;
   case 8:
-    drawTo(bx + 5 * scale, by + 10 * scale);
+    drawTo(BX + 5 * SCALE, BY + 10 * SCALE);
     lift(0);
-    bogenUZS(bx + 5 * scale, by + 15 * scale, 5 * scale, 4.7, -1.6, 1);
-    bogenGZS(bx + 5 * scale, by + 5 * scale, 5 * scale, -4.7, 2, 1);
+    bogenUZS(BX + 5 * SCALE, BY + 15 * SCALE, 5 * SCALE, 4.7, -1.6, 1);
+    bogenGZS(BX + 5 * SCALE, BY + 5 * SCALE, 5 * SCALE, -4.7, 2, 1);
     lift(1);
     break;
 
   case 9:
-    drawTo(bx + 9 * scale, by + 11 * scale);
+    drawTo(BX + 9 * SCALE, BY + 11 * SCALE);
     lift(0);
-    bogenUZS(bx + 7 * scale, by + 15 * scale, 5 * scale, 4, -0.5, 1);
-    drawTo(bx + 5 * scale, by + 0);
+    bogenUZS(BX + 7 * SCALE, BY + 15 * SCALE, 5 * SCALE, 4, -0.5, 1);
+    drawTo(BX + 5 * SCALE, BY + 0);
     lift(1);
     break;
 
@@ -282,13 +282,13 @@ void number(float bx, float by, int num, float scale) {
     break;
 
   case 11:
-    drawTo(bx + 5 * scale, by + 15 * scale);
+    drawTo(BX + 5 * SCALE, BY + 15 * SCALE);
     lift(0);
-    bogenGZS(bx + 5 * scale, by + 15 * scale, 0.1 * scale, 1, -1, 1);
+    bogenGZS(BX + 5 * SCALE, BY + 15 * SCALE, 0.1 * SCALE, 1, -1, 1);
     lift(1);
-    drawTo(bx + 5 * scale, by + 5 * scale);
+    drawTo(BX + 5 * SCALE, BY + 5 * SCALE);
     lift(0);
-    bogenGZS(bx + 5 * scale, by + 5 * scale, 0.1 * scale, 1, -1, 1);
+    bogenGZS(BX + 5 * SCALE, BY + 5 * SCALE, 0.1 * SCALE, 1, -1, 1);
     lift(1);
     break;
 
@@ -297,148 +297,148 @@ void number(float bx, float by, int num, float scale) {
 
 
 
-void lift(char lift) {
-  switch (lift) {
+void lift(const char LIFT) {
+  switch (LIFT) {
     // room to optimize  !
 
   case 0: //850
 
-      if (servoLift >= LIFT0) {
-      while (servoLift >= LIFT0) 
+    if (servoLift >= LIFT0) {
+      do
       {
         servoLift--;
-        servo1.writeMicroseconds(servoLift);				
+        servo1.writeMicroseconds(servoLift);
         delayMicroseconds(LIFTSPEED);
-      }
-    } 
+      } while (servoLift >= LIFT0);
+    }
     else {
-      while (servoLift <= LIFT0) {
+      do
+      {
         servoLift++;
         servo1.writeMicroseconds(servoLift);
         delayMicroseconds(LIFTSPEED);
-
-      }
-
+      } while (servoLift < LIFT0);
     }
 
     break;
 
   case 1: //150
 
     if (servoLift >= LIFT1) {
-      while (servoLift >= LIFT1) {
+      do
+      {
         servoLift--;
         servo1.writeMicroseconds(servoLift);
         delayMicroseconds(LIFTSPEED);
-
-      }
-    } 
+      } while (servoLift >= LIFT1);
+    }
     else {
-      while (servoLift <= LIFT1) {
+      do
+      {
         servoLift++;
         servo1.writeMicroseconds(servoLift);
         delayMicroseconds(LIFTSPEED);
-      }
-
+      } while (servoLift < LIFT1);
     }
 
     break;
 
   case 2:
 
     if (servoLift >= LIFT2) {
-      while (servoLift >= LIFT2) {
+      do
+      {
         servoLift--;
         servo1.writeMicroseconds(servoLift);
         delayMicroseconds(LIFTSPEED);
-      }
-    } 
+      } while (servoLift >= LIFT2);
+    }
     else {
-      while (servoLift <= LIFT2) {
+      do
+      {
         servoLift++;
-        servo1.writeMicroseconds(servoLift);				
+        servo1.writeMicroseconds(servoLift);
         delayMicroseconds(LIFTSPEED);
-      }
+      } while (servoLift < LIFT2);
     }
+    
     break;
   }
 }
 
 
-void bogenUZS(float bx, float by, float radius, int start, int ende, float sqee) {
+void bogenUZS(const float BX, const float BY, const float RADIUS,
+              const int START, const int ENDE, const float SQEE) {
   float inkr = -0.05;
   float count = 0;
 
   do {
-    drawTo(sqee * radius * cos(start + count) + bx,
-    radius * sin(start + count) + by);
+    drawTo(SQEE * RADIUS * cos(START + count) + BX,
+           RADIUS * sin(START + count) + BY);
     count += inkr;
-  } 
-  while ((start + count) > ende);
+  }
+  while (START + count > ENDE);
 
 }
 
-void bogenGZS(float bx, float by, float radius, int start, int ende, float sqee) {
+void bogenGZS(const float BX, const float BY, const float RADIUS,
+              const int START, const int ENDE, const float SQEE) {
   float inkr = 0.05;
   float count = 0;
 
   do {
-    drawTo(sqee * radius * cos(start + count) + bx,
-    radius * sin(start + count) + by);
+    drawTo(SQEE * RADIUS * cos(START + count) + BX,
+           RADIUS * sin(START + count) + BY);
     count += inkr;
   } 
-  while ((start + count) <= ende);
+  while (START + count <= ENDE);
 }
 
 
-void drawTo(double pX, double pY) {
-  double dx, dy, c;
-  int i;
+void drawTo(const double pX, const double pY) {
 
   // dx dy of new point
-  dx = pX - lastX;
-  dy = pY - lastY;
+  double dx = pX - lastX;
+  double dy = pY - lastY;
   //path lenght in mm, times 4 equals 4 steps per mm
-  c = floor(4 * sqrt(dx * dx + dy * dy));
+  double c = floor(4 * sqrt(dx * dx + dy * dy));
 
   if (c < 1) c = 1;
 
-  for (i = 0; i <= c; i++) {
+  for (int i = 0; i <= c; i++) {
     // draw line point by point
     set_XY(lastX + (i * dx / c), lastY + (i * dy / c));
-
   }
 
   lastX = pX;
   lastY = pY;
 }
 
-double return_angle(double a, double b, double c) {
+double return_angle(const double a, const double b, const double c) {
   // cosine rule for angle between c and a
   return acos((a * a + c * c - b * b) / (2 * a * c));
 }
 
-void set_XY(double Tx, double Ty) 
+void set_XY(const double Tx, const double Ty) 
 {
   delay(1);
-  double dx, dy, c, a1, a2, Hx, Hy;
 
   // calculate triangle between pen, servoLeft and arm joint
   // cartesian dx/dy
-  dx = Tx - O1X;
-  dy = Ty - O1Y;
+  double dx = Tx - O1X;
+  double dy = Ty - O1Y;
 
   // polar lemgth (c) and angle (a1)
-  c = sqrt(dx * dx + dy * dy); // 
-  a1 = atan2(dy, dx); //
-  a2 = return_angle(L1, L2, c);
+  double c = sqrt(dx * dx + dy * dy); // 
+  double a1 = atan2(dy, dx); //
+  double a2 = return_angle(L1, L2, c);
 
   servo2.writeMicroseconds(floor(((a2 + a1 - M_PI) * SERVOFAKTORLEFT) + SERVOLEFTNULL));
 
   // calculate joinr arm point for triangle of the right servo arm
   a2 = return_angle(L2, L1, c);
-  Hx = Tx + L3 * cos((a1 - a2 + 0.621) + M_PI); //36,5°
-  Hy = Ty + L3 * sin((a1 - a2 + 0.621) + M_PI);
+  double Hx = Tx + L3 * cos((a1 - a2 + 0.621) + M_PI); //36,5°
+  double Hy = Ty + L3 * sin((a1 - a2 + 0.621) + M_PI);
 
   // calculate triangle between pen joint, servoRight and arm joint
   dx = Hx - O2X;