Skip to content

Improving with some C++ suggestions (not tested) #7

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
wants to merge 1 commit into
base: master
Choose a base branch
from
Open
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
180 changes: 90 additions & 90 deletions plotclock.ino
Original file line number Diff line number Diff line change
Expand Up @@ -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;

Expand Down Expand Up @@ -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;

Expand All @@ -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;
Expand Down