API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Dec 11th, 2018
62
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 20.54 KB | None | 0 0
raw download clone embed print report
  1. #include "kinematics.h"
  2.  
  3. #include <stdio.h>
  4. int FontSize = 1;
  5. double LL = 85;
  6. double readTaskSpace(Taskspace *t);
  7. double displayTaskSpace(Taskspace *t);
  8. double displayJointSpace(Jointspace *j);
  9. double displayRegisterSpace(Registerspace *r);
  10. void fonts(char l, Taskspace &input, Jointspace &OldAngles);
  11.  
  12. int InverseKinematics(Taskspace t, Jointspace &j);
  13. int ForwardKinematics(Jointspace j, Taskspace &t);
  14. int MoveTo(Taskspace& Input, Jointspace& OldAngles);
  15. int JointToRegister(Jointspace j, Registerspace &r);
  16. int getDeltaTheta(Jointspace &Old, Jointspace &Delta);
  17. int getDeltaTask(Taskspace& prev, Taskspace& next);
  18. int LineTo(Taskspace& prev, Jointspace& old);
  19. bool queryUser();
  20. int getLength(Taskspace task);
  21. int spe = 230; // Motor speed; should not be higher than 240
  22. Microbot Mike;
  23.  
  24.  
  25. int main()
  26. {
  27.  
  28.  
  29.  
  30.  
  31. bool Continue = true;
  32. // Local variable of the microbot class
  33. Taskspace Input; // Local variable for input of coordinates
  34. Jointspace OldAngles;
  35.  
  36.  
  37. Taskspace HOME;
  38. HOME.x = 150;
  39. HOME.y = 0;
  40. HOME.z = 0;
  41. HOME.p = -1.5708;
  42. HOME.r = 0;
  43. HOME.g = 0;
  44.  
  45. Taskspace STAR;
  46. STAR.x = 175;
  47. STAR.y = 200;
  48. STAR.z = 10;
  49. STAR.p = -1.5708;
  50. STAR.r = 0;
  51. STAR.g = 0;
  52.  
  53. Taskspace PICKUP;
  54. PICKUP.x = 45;
  55. PICKUP.y = -280;
  56. PICKUP.z = 200;
  57. PICKUP.p = -1.5708;
  58. PICKUP.r = 0;
  59. PICKUP.g = 0;
  60.  
  61.  
  62. InverseKinematics(HOME, OldAngles);
  63. //robot.SendClose(230, 0);
  64.  
  65. // sækja penna
  66. Input = PICKUP;
  67. MoveTo(Input, OldAngles);
  68. char x;
  69. scanf("%lf", &x);
  70. Input.z = 125;
  71. MoveTo(Input, OldAngles);
  72. scanf("%lf", &x);
  73. Mike.SendClose(230, 5);
  74. Input.g -= 25;
  75. MoveTo(Input, OldAngles);
  76. scanf("%lf", &x);
  77. Input.z += 150;
  78. MoveTo(Input, OldAngles);
  79.  
  80. LL = 210;
  81. MoveTo(HOME, OldAngles);
  82. Input = HOME;
  83. scanf("%lf", &x);
  84. Input.z -= 15;
  85. MoveTo(Input, OldAngles);
  86. Input.g -= 50;
  87. MoveTo(Input, OldAngles);
  88. scanf("%lf", &x);
  89. Input.z += 10;
  90. MoveTo(Input, OldAngles);
  91.  
  92.  
  93. InverseKinematics(HOME, OldAngles);
  94.  
  95.  
  96.  
  97. //byrjunarstaða
  98. Input = STAR;
  99. MoveTo(Input, OldAngles);
  100.  
  101.  
  102.  
  103.  
  104. while (Continue) {
  105.  
  106. char str[10];
  107.  
  108. printf("Enter a word:");
  109. scanf("%s", str);
  110.  
  111. for (int i = 0; i < sizeof(str); i++) {
  112. fonts(str[i], Input, OldAngles);
  113.  
  114. }
  115.  
  116.  
  117. Continue = queryUser();
  118. }
  119.  
  120.  
  121. MoveTo(HOME, OldAngles);
  122. Mike.SendClose(230, 0);
  123.  
  124. }
  125.  
  126. int MoveTo(Taskspace& Input, Jointspace& OldAngles) {
  127.  
  128. Registerspace delta; // Local variable for input of motor steps
  129. Jointspace Angles;
  130.  
  131. InverseKinematics(Input, Angles); // Get angles from those coordinates
  132.  
  133. getDeltaTheta(OldAngles, Angles); // subtract them from the old angles
  134.  
  135. JointToRegister(Angles, delta); // make the difference a registerspace
  136.  
  137. Mike.SendStep(spe, delta);
  138.  
  139. return 0;
  140. }
  141. bool queryUser() {
  142.  
  143. char x;
  144. printf("\n \n Would you like to have another go? (y/Y for yes) ");
  145. scanf(" %c", &x);
  146. if (x == 'y') {
  147. return true;
  148. }
  149. else
  150. {
  151. return false;
  152. }
  153.  
  154. }
  155.  
  156. double readTaskSpace(Taskspace *t) {
  157.  
  158. double x, y, z, p, r, g;
  159.  
  160. printf("Please input taskspace parameters \n");
  161. printf("x:");
  162. scanf("%lf", &x);
  163. printf("y:");
  164. scanf("%lf", &y);
  165. printf("z:");
  166. scanf("%lf", &z);
  167. printf("p:");
  168. scanf("%lf", &p);
  169. printf("r:");
  170. scanf("%lf", &r);
  171. printf("g:");
  172. scanf("%lf", &g);
  173.  
  174. t->x = x;
  175. t->y = -y;
  176. t->z = z;
  177. t->p = p * PI / 180;
  178. t->r = r * PI / 180;
  179. t->g = g;
  180.  
  181. return 0;
  182. }
  183.  
  184. double displayTaskSpace(Taskspace *t) {
  185. printf("\n These are the taskspace parameters \n");
  186. printf("x: %lf \n", t->x);
  187. printf("y: %lf \n", t->y);
  188. printf("z: %lf \n", t->z);
  189. printf("p: %lf \n", t->p);
  190. printf("r: %lf \n", t->r);
  191. printf("g: %lf \n", t->g);
  192. return 0;
  193. }
  194.  
  195. double displayJointSpace(Jointspace *j) {
  196. printf("\n These are the jointspace parameters \n");
  197. printf("Theta 1: %lf \n", j->t[1]);
  198. printf("Theta 2: %lf \n", j->t[2]);
  199. printf("Theta 3: %lf \n", j->t[3]);
  200. printf("Theta 4: %lf \n", j->t[4]);
  201. printf("Theta 5: %lf \n", j->t[5]);
  202. return 0;
  203. }
  204.  
  205. double displayRegisterSpace(Registerspace *r) {
  206. printf("\n These are the register parameters \n");
  207. printf("R 1: %i \n", r->r[1]);
  208. printf("R 2: %i \n", r->r[2]);
  209. printf("R 3: %i \n", r->r[3]);
  210. printf("R 4: %i \n", r->r[4]);
  211. printf("R 5: %i \n", r->r[5]);
  212. printf("R 6: %i \n", r->r[6]);
  213. return 0;
  214. }
  215.  
  216.  
  217. int InverseKinematics(Taskspace t, Jointspace &j) {
  218.  
  219. j.t[1] = atan2(t.y, t.x);
  220. double RR = sqrt(t.x * t.x + t.y * t.y);
  221. j.t[5] = t.p + t.r + R1 * j.t[1]; // kanski breyta gildi r1
  222. j.t[4] = t.p - t.r - R1 * j.t[1]; // kanski breyta gildi r1
  223. double R0 = RR - LL * cos(t.p);
  224. double Z0 = t.z - LL * sin(t.p) - H;
  225. double beta = atan2(Z0, R0);
  226. double alpha = atan(sqrt((4.0 * L * L) / (((R0 * R0) + (Z0 * Z0))) - 1.0));
  227. j.t[2] = beta + alpha;
  228. j.t[3] = beta - alpha;
  229. j.t[6] = t.g;
  230. return 0;
  231. }
  232.  
  233. int ForwardKinematics(Jointspace j, Taskspace &t) {
  234.  
  235. t.p = (j.t[5] + j.t[4]) / 2;
  236. t.r = (j.t[5] - j.t[4]) / 2;
  237. double RR = L * cos(j.t[2]) + L * cos(j.t[3]) + LL * cos(t.p);
  238. t.x = RR * cos(j.t[1]);
  239. t.y = RR * sin(j.t[1]);
  240. t.z = H + L * sin(j.t[2]) + L * sin(j.t[3]) + LL * sin(t.p);
  241. return 0;
  242. }
  243.  
  244.  
  245. int JointToRegister(Jointspace j, Registerspace &r) {
  246.  
  247. r.r[1] = (int)(j.t[1] * 1125);
  248. r.r[2] = (int)(j.t[2] * 1125);
  249. r.r[3] = (int)(j.t[3] * 661.2);
  250. r.r[4] = (int)(j.t[4] * 241);
  251. r.r[5] = (int)(j.t[5] * 241);
  252. r.r[6] = (int)(j.t[6] * 14.6 + r.r[3]);
  253. return 0;
  254. }
  255.  
  256. int getDeltaTheta(Jointspace &Old, Jointspace &Delta) {
  257.  
  258. for (int i = 1; i < 6; i++)
  259. {
  260. Delta.t[i] = Old.t[i] - Delta.t[i];
  261. Old.t[i] = Old.t[i] - Delta.t[i];
  262. }
  263. return 0;
  264. }
  265.  
  266.  
  267. // next becomes delta and prev becomes next
  268. int getDeltaTask(Taskspace &Prev, Taskspace &Next) {
  269.  
  270. Next.x = Prev.x - Next.x;
  271. Prev.x = Prev.x - Next.x;
  272.  
  273. Next.y = Prev.y - Next.y;
  274. Prev.y = Prev.y - Next.y;
  275.  
  276. Next.z = Prev.z - Next.z;
  277. Prev.z = Prev.z - Next.z;
  278.  
  279. Next.p = Prev.p - Next.p;
  280. Prev.p = Prev.p - Next.p;
  281.  
  282. Next.r = Prev.r - Next.r;
  283. Prev.r = Prev.r - Next.r;
  284.  
  285. Next.g = Prev.g - Next.g;
  286. Prev.g = Prev.g - Next.g;
  287.  
  288. return 0;
  289. }
  290.  
  291. int getLength(Taskspace task) {
  292. return (int)((task.x)*(task.x) + (task.y)*(task.y) + (task.z)*(task.z));
  293. }
  294.  
  295.  
  296. // inc will include the length of each increment in each direction
  297. // next will be empty
  298. int getIncrements(Taskspace& Next, Taskspace& inc, int div) {
  299. inc.x = Next.x / div;
  300. inc.y = Next.y / div;
  301. inc.z = Next.z / div;
  302. inc.p = Next.p / div;
  303. inc.r = Next.r / div;
  304. inc.g = Next.g / div;
  305. return 0;
  306. }
  307.  
  308. int incementNext(Taskspace& curr, Taskspace& inc) {
  309. curr.x = curr.x + inc.x;
  310.  
  311. curr.y = curr.y + inc.y;
  312.  
  313. curr.z = curr.z + inc.z;
  314.  
  315. curr.p = curr.p + inc.p;
  316.  
  317. curr.r = curr.r + inc.r;
  318.  
  319. curr.g = curr.g + inc.g;
  320.  
  321. return 0;
  322. }
  323.  
  324. int LineTo(Taskspace &next, Jointspace& OldAngles) {
  325. Taskspace curr;
  326. ForwardKinematics(OldAngles, curr);
  327.  
  328. Taskspace end = curr; // current er alltaf núverandi staðsetning á eftir verður end svo lokastaðsetning
  329. Taskspace inc; // inc er hversu langt hvert stökk er
  330. getDeltaTask(end, next); // end er loka staðsetningin og delta er heildar lengdin
  331. int s = getLength(next) / 25; // s er fjöldi skrefa sem þarf að taka -1
  332.  
  333. if (s == 0) { // það þarf bara að taka eitt skref, er það einfaldlega tekið
  334. MoveTo(end, OldAngles); // þarf kanski að spá í því hvað er að gerast við þessi taskspace (þarf að nota það?)
  335. return 0;
  336. }
  337.  
  338. getIncrements(next, inc, s); // bý til inc sem heldur utanum lengd hvers stökks í hverja átt fyrir sig
  339.  
  340. for (; s < 0; s--) // tek S mörg stökk sem eru inc á lengd hvert um sig.
  341. {
  342. MoveTo(curr, OldAngles);
  343. }
  344.  
  345. MoveTo(end, OldAngles); // síðasta stökkið fer alltaf á end
  346. }
  347.  
  348. void fonts(char l, Taskspace &Input, Jointspace &OldAngles) {
  349.  
  350. if (l == 'a') {
  351.  
  352. for (int i = 0; i < 1; i++)
  353. {
  354. Input.z = 0;
  355. MoveTo(Input, OldAngles);
  356. }
  357. for (int i = 0; i < 2 * FontSize; i++)
  358. {
  359. Input.x -= 25;
  360. MoveTo(Input, OldAngles);
  361. }
  362. for (int i = 0; i < FontSize; i++)
  363. {
  364. Input.y -= 25;
  365. MoveTo(Input, OldAngles);
  366. }
  367. for (int i = 0; i < 2 * FontSize; i++)
  368. {
  369. Input.x += 25;
  370. MoveTo(Input, OldAngles);
  371. }
  372. for (int i = 0; i < 1; i++)
  373. {
  374. Input.z = 10;
  375. MoveTo(Input, OldAngles);
  376. }
  377. for (int i = 0; i < FontSize; i++)
  378. {
  379. Input.x -= 25;
  380. MoveTo(Input, OldAngles);
  381. }
  382. for (int i = 0; i < 1; i++)
  383. {
  384. Input.z = 0;
  385. MoveTo(Input, OldAngles);
  386. }
  387. for (int i = 0; i < FontSize; i++)
  388. {
  389. Input.y += 25;
  390. MoveTo(Input, OldAngles);
  391. }
  392. //Next letter
  393. for (int i = 0; i < 1; i++)
  394. {
  395. Input.z = 10;
  396. MoveTo(Input, OldAngles);
  397. }
  398. for (int i = 0; i < 1; i++)
  399. {
  400. Input.x += 25;
  401. Input.y -= 50;
  402. MoveTo(Input, OldAngles);
  403. }
  404. }
  405. else if ( l == 'b') {
  406. for (int i = 0; i < 1; i++)
  407. {
  408. Input.z = 0;
  409. MoveTo(Input, OldAngles);
  410. }
  411. for (int i = 0; i < 2 * FontSize; i++)
  412. {
  413. Input.x -= 25;
  414. MoveTo(Input, OldAngles);
  415. }
  416. for (int i = 0; i < FontSize; i++)
  417. {
  418. Input.y -= 25;
  419. Input.x += 12.5;
  420. MoveTo(Input, OldAngles);
  421. }
  422. for (int i = 0; i < FontSize; i++)
  423. {
  424. Input.y += 25;
  425. Input.x += 12.5;
  426. MoveTo(Input, OldAngles);
  427. }
  428. for (int i = 0; i < FontSize; i++)
  429. {
  430. Input.y -= 25;
  431. Input.x += 12.5;
  432. MoveTo(Input, OldAngles);
  433. }
  434. for (int i = 0; i < FontSize; i++)
  435. {
  436. Input.y += 25;
  437. Input.x += 12.5;
  438. MoveTo(Input, OldAngles);
  439. }
  440. //Next letter
  441. for (int i = 0; i < 1; i++)
  442. {
  443. Input.z = 10;
  444. MoveTo(Input, OldAngles);
  445. }
  446. for (int i = 0; i < 1; i++)
  447. {
  448. Input.y -= 50;
  449. MoveTo(Input, OldAngles);
  450. }
  451. }
  452. else if (l == 'c') {
  453. for (int i = 0; i < FontSize; i++)
  454. {
  455. Input.y -= 25;
  456. MoveTo(Input, OldAngles);
  457. }
  458. for (int i = 0; i < 1; i++)
  459. {
  460. Input.z = 0;
  461. MoveTo(Input, OldAngles);
  462. }
  463. for (int i = 0; i < FontSize; i++)
  464. {
  465. Input.x -= 12.5;
  466. Input.y += 25;
  467. MoveTo(Input, OldAngles);
  468. }
  469. for (int i = 0; i < FontSize; i++)
  470. {
  471. Input.x -= 25;
  472. MoveTo(Input, OldAngles);
  473. }
  474. for (int i = 0; i < FontSize; i++)
  475. {
  476. Input.y -= 25;
  477. Input.x -= 12.5;
  478. MoveTo(Input, OldAngles);
  479. }
  480.  
  481. //Next letter
  482. for (int i = 0; i < 1; i++)
  483. {
  484. Input.z = 10;
  485. MoveTo(Input, OldAngles);
  486. }
  487. for (int i = 0; i < 1; i++)
  488. {
  489. Input.y -= 25;
  490. Input.x += 50;
  491. MoveTo(Input, OldAngles);
  492. }
  493. }
  494. else if (l == 'd') {
  495. for (int i = 0; i < 1; i++)
  496. {
  497. Input.z = 0;
  498. MoveTo(Input, OldAngles);
  499. }
  500. for (int i = 0; i < 2 * FontSize; i++)
  501. {
  502. Input.x -= 25;
  503. MoveTo(Input, OldAngles);
  504. }
  505. for (int i = 0; i < FontSize; i++)
  506. {
  507. Input.x += 25;
  508. Input.y -= 25;
  509. MoveTo(Input, OldAngles);
  510. }
  511. for (int i = 0; i < FontSize; i++)
  512. {
  513. Input.x += 25;
  514. Input.y += 25;
  515. MoveTo(Input, OldAngles);
  516. }
  517.  
  518. //Next letter
  519. for (int i = 0; i < 1; i++)
  520. {
  521. Input.z = 10;
  522. MoveTo(Input, OldAngles);
  523. }
  524. for (int i = 0; i < 1; i++)
  525. {
  526. Input.y -= 50;
  527. MoveTo(Input, OldAngles);
  528. }
  529. }
  530. else if (l == 'e') {
  531. for (int i = 0; i < 1; i++)
  532. {
  533. Input.z = 0;
  534. MoveTo(Input, OldAngles);
  535. }
  536. for (int i = 0; i < 2 * FontSize; i++)
  537. {
  538. Input.x -= 25;
  539. MoveTo(Input, OldAngles);
  540. }
  541. for (int i = 0; i < FontSize; i++)
  542. {
  543. Input.y -= 25;
  544. MoveTo(Input, OldAngles);
  545. }
  546. for (int i = 0; i < 1; i++)
  547. {
  548. Input.z = 10;
  549. MoveTo(Input, OldAngles);
  550. }
  551. for (int i = 0; i < FontSize; i++)
  552. {
  553. Input.x += 25;
  554. Input.y += 25;
  555. MoveTo(Input, OldAngles);
  556. }
  557. for (int i = 0; i < 1; i++)
  558. {
  559. Input.z = 0;
  560. MoveTo(Input, OldAngles);
  561. }
  562. for (int i = 0; i < FontSize; i++)
  563. {
  564. Input.y -= 12.5;
  565. MoveTo(Input, OldAngles);
  566. }
  567. for (int i = 0; i < 1; i++)
  568. {
  569. Input.z = 10;
  570. MoveTo(Input, OldAngles);
  571. }
  572. for (int i = 0; i < FontSize; i++)
  573. {
  574. Input.x += 25;
  575. Input.y += 12.5;
  576. MoveTo(Input, OldAngles);
  577. }
  578. for (int i = 0; i < 1; i++)
  579. {
  580. Input.z -= 10;
  581. MoveTo(Input, OldAngles);
  582. }
  583. for (int i = 0; i < FontSize; i++)
  584. {
  585. Input.y -= 25;
  586. MoveTo(Input, OldAngles);
  587. }
  588.  
  589.  
  590. //Next letter
  591. for (int i = 0; i < 1; i++)
  592. {
  593. Input.z = 10;
  594. MoveTo(Input, OldAngles);
  595. }
  596. for (int i = 0; i < 1; i++)
  597. {
  598. Input.y -= 25;
  599. MoveTo(Input, OldAngles);
  600. }
  601. }
  602. else if (l == 'f') {
  603. for (int i = 0; i < 1; i++)
  604. {
  605. Input.z = 0;
  606. MoveTo(Input, OldAngles);
  607. }
  608. for (int i = 0; i < 2 * FontSize; i++)
  609. {
  610. Input.x -= 25;
  611. MoveTo(Input, OldAngles);
  612. }
  613. for (int i = 0; i < FontSize; i++)
  614. {
  615. Input.y -= 25;
  616. MoveTo(Input, OldAngles);
  617. }
  618. for (int i = 0; i < 1; i++)
  619. {
  620. Input.z = 10;
  621. MoveTo(Input, OldAngles);
  622. }
  623. for (int i = 0; i < FontSize; i++)
  624. {
  625. Input.x += 25;
  626. Input.y += 25;
  627. MoveTo(Input, OldAngles);
  628. }
  629. for (int i = 0; i < 1; i++)
  630. {
  631. Input.z = 0;
  632. MoveTo(Input, OldAngles);
  633. }
  634. for (int i = 0; i < FontSize; i++)
  635. {
  636. Input.y -= 12.5;
  637. MoveTo(Input, OldAngles);
  638. }
  639.  
  640.  
  641. //Next letter
  642. for (int i = 0; i < 1; i++)
  643. {
  644. Input.z = 10;
  645. MoveTo(Input, OldAngles);
  646. }
  647. for (int i = 0; i < 1; i++)
  648. {
  649. Input.y -= 37.5;
  650. Input.x += 25;
  651. MoveTo(Input, OldAngles);
  652. }
  653. }
  654. else if (l == 'g') {
  655. for (int i = 0; i < 1; i++)
  656. {
  657. Input.z = 0;
  658. MoveTo(Input, OldAngles);
  659. }
  660. for (int i = 0; i < 2 * FontSize; i++)
  661. {
  662. Input.x -= 25;
  663. MoveTo(Input, OldAngles);
  664. }
  665. for (int i = 0; i < FontSize; i++)
  666. {
  667. Input.y -= 25;
  668. MoveTo(Input, OldAngles);
  669. }
  670. for (int i = 0; i < 1; i++)
  671. {
  672. Input.z = 10;
  673. MoveTo(Input, OldAngles);
  674. }
  675. for (int i = 0; i < FontSize; i++)
  676. {
  677. Input.x += 50;
  678. Input.y += 25;
  679. MoveTo(Input, OldAngles);
  680. }
  681. for (int i = 0; i < 1; i++)
  682. {
  683. Input.z = 0;
  684. MoveTo(Input, OldAngles);
  685. }
  686. for (int i = 0; i < FontSize; i++)
  687. {
  688. Input.y -= 25;
  689. MoveTo(Input, OldAngles);
  690. }
  691. for (int i = 0; i < FontSize; i++)
  692. {
  693. Input.x -= 25;
  694. MoveTo(Input, OldAngles);
  695. }
  696. for (int i = 0; i < FontSize; i++)
  697. {
  698. Input.y += 12.5;
  699. MoveTo(Input, OldAngles);
  700. }
  701.  
  702.  
  703. //Next letter
  704. for (int i = 0; i < 1; i++)
  705. {
  706. Input.z = 10;
  707. MoveTo(Input, OldAngles);
  708. }
  709. for (int i = 0; i < 1; i++)
  710. {
  711. Input.y -= 37.5;
  712. Input.x += 25;
  713. MoveTo(Input, OldAngles);
  714. }
  715. }
  716. else if (l == 'h') {
  717. for (int i = 0; i < 1; i++)
  718. {
  719. Input.z = 0;
  720. MoveTo(Input, OldAngles);
  721. }
  722. for (int i = 0; i < 2 * FontSize; i++)
  723. {
  724. Input.x -= 25;
  725. MoveTo(Input, OldAngles);
  726. }
  727. for (int i = 0; i < 1; i++)
  728. {
  729. Input.z = 10;
  730. MoveTo(Input, OldAngles);
  731. }
  732. for (int i = 0; i < FontSize; i++)
  733. {
  734. Input.x += 25;
  735. MoveTo(Input, OldAngles);
  736. }
  737. for (int i = 0; i < 1; i++)
  738. {
  739. Input.z = 0;
  740. MoveTo(Input, OldAngles);
  741. }
  742. for (int i = 0; i < FontSize; i++)
  743. {
  744. Input.y -= 25;
  745. MoveTo(Input, OldAngles);
  746. }
  747. for (int i = 0; i < 1; i++)
  748. {
  749. Input.z = 10;
  750. MoveTo(Input, OldAngles);
  751. }
  752. for (int i = 0; i < FontSize; i++)
  753. {
  754. Input.x -= 25;
  755. MoveTo(Input, OldAngles);
  756. }
  757. for (int i = 0; i < 1; i++)
  758. {
  759. Input.z = 0;
  760. MoveTo(Input, OldAngles);
  761. }
  762.  
  763. for (int i = 0; i < 2 * FontSize; i++)
  764. {
  765. Input.x += 25;
  766. MoveTo(Input, OldAngles);
  767. }
  768.  
  769.  
  770.  
  771. //Next letter
  772. for (int i = 0; i < 1; i++)
  773. {
  774. Input.z = 10;
  775. MoveTo(Input, OldAngles);
  776. }
  777. for (int i = 0; i < 1; i++)
  778. {
  779. Input.y -= 25;
  780. MoveTo(Input, OldAngles);
  781. }
  782. }
  783. else if (l == 'i') {
  784. for (int i = 0; i < 2 * FontSize; i++)
  785. {
  786. Input.x -= 25;
  787. MoveTo(Input, OldAngles);
  788. }
  789. for (int i = 0; i < 1; i++)
  790. {
  791. Input.z = 0;
  792. MoveTo(Input, OldAngles);
  793. }
  794. for (int i = 0; i < FontSize; i++)
  795. {
  796. Input.y -= 25;
  797. MoveTo(Input, OldAngles);
  798. }
  799. for (int i = 0; i < 1; i++)
  800. {
  801. Input.z = 10;
  802. MoveTo(Input, OldAngles);
  803. }
  804. for (int i = 0; i < FontSize; i++)
  805. {
  806. Input.y += 12.5;
  807. MoveTo(Input, OldAngles);
  808. }
  809. for (int i = 0; i < 1; i++)
  810. {
  811. Input.z = 0;
  812. MoveTo(Input, OldAngles);
  813. }
  814. for (int i = 0; i < 2 * FontSize; i++)
  815. {
  816. Input.x += 25;
  817. MoveTo(Input, OldAngles);
  818. }
  819. for (int i = 0; i < 1; i++)
  820. {
  821. Input.z = 10;
  822. MoveTo(Input, OldAngles);
  823. }
  824. for (int i = 0; i < FontSize; i++)
  825. {
  826. Input.y += 12.5;
  827. MoveTo(Input, OldAngles);
  828. }
  829. for (int i = 0; i < 1; i++)
  830. {
  831. Input.z = 0;
  832. MoveTo(Input, OldAngles);
  833. }
  834. for (int i = 0; i < FontSize; i++)
  835. {
  836. Input.y -= 25;
  837. MoveTo(Input, OldAngles);
  838. }
  839.  
  840.  
  841. //Next letter
  842. for (int i = 0; i < 1; i++)
  843. {
  844. Input.z = 10;
  845. MoveTo(Input, OldAngles);
  846. }
  847. for (int i = 0; i < 1; i++)
  848. {
  849. Input.y -= 25;
  850. MoveTo(Input, OldAngles);
  851. }
  852. }
  853. else if (l == 'j') {
  854. for (int i = 0; i < FontSize; i++)
  855. {
  856. Input.x -= 25;
  857. MoveTo(Input, OldAngles);
  858. }
  859. for (int i = 0; i < 1; i++)
  860. {
  861. Input.z = 0;
  862. MoveTo(Input, OldAngles);
  863. }
  864. for (int i = 0; i < FontSize; i++)
  865. {
  866. Input.x += 25;
  867. MoveTo(Input, OldAngles);
  868. }
  869. for (int i = 0; i < 1; i++)
  870. {
  871. Input.y -= 25;
  872. MoveTo(Input, OldAngles);
  873. }
  874. for (int i = 0; i < 2 * FontSize; i++)
  875. {
  876. Input.x -= 25;
  877. MoveTo(Input, OldAngles);
  878. }
  879.  
  880.  
  881.  
  882. //Next letter
  883. for (int i = 0; i < 1; i++)
  884. {
  885. Input.z = 10;
  886. MoveTo(Input, OldAngles);
  887. }
  888. for (int i = 0; i < 1; i++)
  889. {
  890. Input.y -= 25;
  891. Input.x += 50;
  892. MoveTo(Input, OldAngles);
  893. }
  894.  
  895. }
  896. else if (l == 'k') {
  897. for (int i = 0; i < 1; i++)
  898. {
  899. Input.z = 0;
  900. MoveTo(Input, OldAngles);
  901. }
  902. for (int i = 0; i < 2 * FontSize; i++)
  903. {
  904. Input.x -= 25;
  905. MoveTo(Input, OldAngles);
  906. }
  907. for (int i = 0; i < 1; i++)
  908. {
  909. Input.z = 10;
  910. MoveTo(Input, OldAngles);
  911. }
  912. for (int i = 0; i < FontSize; i++)
  913. {
  914. Input.x += 25;
  915. MoveTo(Input, OldAngles);
  916. }
  917. for (int i = 0; i < 1; i++)
  918. {
  919. Input.z = 0;
  920. MoveTo(Input, OldAngles);
  921. }
  922. for (int i = 0; i < FontSize; i++)
  923. {
  924. Input.x -= 25;
  925. Input.y -= 25;
  926. MoveTo(Input, OldAngles);
  927. }
  928. for (int i = 0; i < 1; i++)
  929. {
  930. Input.z = 10;
  931. MoveTo(Input, OldAngles);
  932. }
  933. for (int i = 0; i < FontSize; i++)
  934. {
  935. Input.x += 25;
  936. Input.y += 25;
  937. MoveTo(Input, OldAngles);
  938. }
  939. for (int i = 0; i < 1; i++)
  940. {
  941. Input.z = 0;
  942. MoveTo(Input, OldAngles);
  943. }
  944. for (int i = 0; i < FontSize; i++)
  945. {
  946. Input.x += 25;
  947. Input.y -= 25;
  948. MoveTo(Input, OldAngles);
  949. }
  950.  
  951.  
  952. //Next letter
  953. for (int i = 0; i < 1; i++)
  954. {
  955. Input.z = 10;
  956. MoveTo(Input, OldAngles);
  957. }
  958. for (int i = 0; i < 1; i++)
  959. {
  960. Input.y -= 25;
  961. MoveTo(Input, OldAngles);
  962. }
  963. }
  964. else if (l == 'l') {
  965. for (int i = 0; i < 2 * FontSize; i++)
  966. {
  967. Input.x -= 25;
  968. MoveTo(Input, OldAngles);
  969. }
  970. for (int i = 0; i < 1; i++)
  971. {
  972. Input.z = 0;
  973. MoveTo(Input, OldAngles);
  974. }
  975. for (int i = 0; i < 2 * FontSize; i++)
  976. {
  977. Input.x += 25;
  978. MoveTo(Input, OldAngles);
  979. }
  980.  
  981. for (int i = 0; i < FontSize; i++)
  982. {
  983. Input.y -= 25;
  984. MoveTo(Input, OldAngles);
  985. }
  986.  
  987.  
  988.  
  989. //Next letter
  990. for (int i = 0; i < 1; i++)
  991. {
  992. Input.z = 10;
  993. MoveTo(Input, OldAngles);
  994. }
  995. for (int i = 0; i < 1; i++)
  996. {
  997. Input.y -= 25;
  998. MoveTo(Input, OldAngles);
  999. }
  1000. }
  1001. else if (l == 'm') {
  1002. for (int i = 0; i < 1; i++)
  1003. {
  1004. Input.z = 0;
  1005. MoveTo(Input, OldAngles);
  1006. }
  1007. for (int i = 0; i < 2 * FontSize; i++)
  1008. {
  1009. Input.x -= 25;
  1010. MoveTo(Input, OldAngles);
  1011. }
  1012. for (int i = 0; i < FontSize; i++)
  1013. {
  1014. Input.x += 25;
  1015. Input.y -= 12.5;
  1016. MoveTo(Input, OldAngles);
  1017. }
  1018.  
  1019. for (int i = 0; i < FontSize; i++)
  1020. {
  1021. Input.x -= 25;
  1022. Input.y -= 12.5;
  1023. MoveTo(Input, OldAngles);
  1024. }
  1025. for (int i = 0; i < 2*FontSize; i++)
  1026. {
  1027. Input.x += 25;
  1028. MoveTo(Input, OldAngles);
  1029. }
  1030.  
  1031. //Next letter
  1032. for (int i = 0; i < 1; i++)
  1033. {
  1034. Input.z = 10;
  1035. MoveTo(Input, OldAngles);
  1036. }
  1037. for (int i = 0; i < 1; i++)
  1038. {
  1039. Input.y -= 25;
  1040. MoveTo(Input, OldAngles);
  1041. }
  1042. }
  1043. else if (l == 'n') {
  1044. printf("I want to draw N \n");
  1045. }
  1046. else if (l == 'o') {
  1047. printf("I want to draw O \n");
  1048. }
  1049. else if (l == 'p') {
  1050. printf("I want to draw P \n");
  1051. }
  1052. else if (l == 'q') {
  1053. printf("I want to draw Q \n");
  1054. }
  1055. else if (l == 'r') {
  1056. printf("I want to draw R \n");
  1057. }
  1058. else if (l == 's') {
  1059. printf("I want to draw S \n");
  1060. }
  1061. else if (l == 't') {
  1062. printf("I want to draw T \n");
  1063. }
  1064. else if (l == 'u') {
  1065. printf("I want to draw U \n");
  1066. }
  1067. else if (l == 'v') {
  1068. printf("I want to draw V \n");
  1069. }
  1070. else if (l == 'W') {
  1071. printf("I want to draw V \n");
  1072. }
  1073. else if (l == 'X') {
  1074. printf("I want to draw X \n");
  1075. }
  1076. else if (l == 'y') {
  1077. printf("I want to draw Y \n");
  1078. }
  1079. else if (l == 'z') {
  1080. printf("I want to draw z \n");
  1081. }
  1082. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!