PageRenderTime 30ms CodeModel.GetById 12ms RepoModel.GetById 0ms app.codeStats 1ms

/cnc.ino

https://gitlab.com/foxmjay/fox3dprinter
C++ | 941 lines | 535 code | 368 blank | 38 comment | 76 complexity | fd823a44c28c90c41589c381469aed81 MD5 | raw file
  1. //#include <LiquidCrystal.h>
  2. //#include <Servo.h>
  3. #include <TimerOne.h>
  4. //Servo myservo;
  5. int pos = 0; // variable to store the servo position
  6. int axisspeed = 10;
  7. int zaxisspeed = 10;
  8. int extrudspeed= 500;
  9. int xcoila1 = 2;
  10. int xcoila2 = 3;
  11. int xcoilb1 = 4;
  12. int xcoilb2 = 5;
  13. int ycoila1 = 6;
  14. int ycoila2 = 7;
  15. int ycoilb1 = 8;
  16. int ycoilb2 = 9;
  17. int zcoila1 = 10;
  18. int zcoila2 = 11;
  19. int zcoilb1 = 12;
  20. int zcoilb2 = 13;
  21. int ecoila1 = 46;
  22. int ecoila2 = 48;
  23. int ecoilb1 = 50;
  24. int ecoilb2 = 52;
  25. int x=0;
  26. int y=0;
  27. int z=0;
  28. int extrudOn = 0;
  29. //int xdir=1;
  30. //int ydir=0;
  31. //int zdir=0;
  32. //Servo myservo;
  33. String inputString = ""; // a string to hold incoming data
  34. String xstr = "";
  35. String ystr = "";
  36. String zstr = "";
  37. String tempstr = "";
  38. String extrudestr = "";
  39. int Sxlimit1 = HIGH;
  40. int Sylimit1 = HIGH;
  41. int Sxlimit2 = HIGH;
  42. int Sylimit2 = HIGH;
  43. int homed = 0;
  44. int limiterror = 0;
  45. int curTemp = 0;
  46. int tempSet = 29;
  47. int heatPin = 40;
  48. double tempC;
  49. boolean stringComplete = false; // whether the string is complete
  50. int turn = 0;
  51. void setup()
  52. {
  53. Timer1.initialize(100000); // set a timer of length 100000 microseconds (or 0.1 sec - or 10Hz => the led will blink 5 times, 5 cycles of on-and-off, per second)
  54. Timer1.attachInterrupt( extrudturn ); // attach the service routine here
  55. // myservo.attach(52);
  56. //myservo.write(90);
  57. pinMode(21, INPUT);
  58. pinMode(20, INPUT);
  59. pinMode(19, INPUT);
  60. pinMode(18, INPUT);
  61. pinMode(heatPin, OUTPUT);
  62. Sylimit1 = digitalRead(21);
  63. Sxlimit1 = digitalRead(20);
  64. Sylimit2 = digitalRead(19);
  65. Sxlimit2 = digitalRead(18);
  66. //myservo.attach(22);
  67. attachInterrupt(2, ylimit1On, LOW);
  68. attachInterrupt(4, ylimit2On, LOW);
  69. attachInterrupt(3, xlimit1On, LOW);
  70. attachInterrupt(5, xlimit2On, LOW);
  71. pinMode(xcoila1, OUTPUT);
  72. pinMode(xcoila2, OUTPUT);
  73. pinMode(xcoilb1, OUTPUT);
  74. pinMode(xcoilb2, OUTPUT);
  75. pinMode(ycoila1, OUTPUT);
  76. pinMode(ycoila2, OUTPUT);
  77. pinMode(ycoilb1, OUTPUT);
  78. pinMode(ycoilb2, OUTPUT);
  79. pinMode(zcoila1, OUTPUT);
  80. pinMode(zcoila2, OUTPUT);
  81. pinMode(zcoilb1, OUTPUT);
  82. pinMode(zcoilb2, OUTPUT);
  83. pinMode(ecoila1, OUTPUT);
  84. pinMode(ecoila2, OUTPUT);
  85. pinMode(ecoilb1, OUTPUT);
  86. pinMode(ecoilb2, OUTPUT);
  87. pinMode(13, OUTPUT);
  88. digitalWrite(13, LOW);
  89. xIdle();
  90. yIdle();
  91. zIdle();
  92. eIdle();
  93. //axisTest();
  94. homeing();
  95. Serial.begin(9600);
  96. inputString.reserve(200);
  97. xstr.reserve(5);
  98. ystr.reserve(5);
  99. zstr.reserve(5);
  100. tempstr.reserve(5);
  101. extrudestr.reserve(5);
  102. prepareHeater();
  103. //myservo.write(50);
  104. Serial.flush();
  105. Serial.println("Begin");
  106. }
  107. double Thermister(int RawADC) {
  108. double Temp;
  109. Temp = log(((10240000/RawADC) - 10000));
  110. Temp = 1 / (0.001129148 + (0.000234125 * Temp) + (0.0000000876741 * Temp * Temp * Temp));
  111. Temp = Temp - 273.15; // Convert Kelvin to Celcius
  112. return Temp;
  113. }
  114. void axisTest(){
  115. for (int i=0;i<50;i++){
  116. zbackward();
  117. }
  118. for (int i=0;i<100;i++){
  119. xforward();
  120. }
  121. for (int i=0;i<100;i++){
  122. xbackward();
  123. }
  124. for (int i=0;i<100;i++){
  125. yforward();
  126. }
  127. for (int i=0;i<100;i++){
  128. ybackward();
  129. }
  130. for (int i=0;i<50;i++){
  131. zforward();
  132. }
  133. }
  134. void xIdle(){
  135. digitalWrite(xcoila1, LOW);
  136. digitalWrite(xcoila2, LOW);
  137. digitalWrite(xcoilb1, LOW);
  138. digitalWrite(xcoilb2, LOW);
  139. }
  140. void yIdle(){
  141. digitalWrite(ycoila1, LOW);
  142. digitalWrite(ycoila2, LOW);
  143. digitalWrite(ycoilb1, LOW);
  144. digitalWrite(ycoilb2, LOW);
  145. }
  146. void zIdle(){
  147. digitalWrite(zcoila1, LOW);
  148. digitalWrite(zcoila2, LOW);
  149. digitalWrite(zcoilb1, LOW);
  150. digitalWrite(zcoilb2, LOW);
  151. }
  152. void eIdle(){
  153. digitalWrite(ecoila1, LOW);
  154. digitalWrite(ecoila2, LOW);
  155. digitalWrite(ecoilb1, LOW);
  156. digitalWrite(ecoilb2, LOW);
  157. }
  158. void homeing(){
  159. while ( Sxlimit1 == HIGH ){
  160. xbackward();
  161. }
  162. while ( Sylimit1 == HIGH ){
  163. ybackward();
  164. }
  165. for (int i=0;i<350;i++){
  166. xforward();
  167. }
  168. for (int i=0;i<350;i++){
  169. yforward();
  170. }
  171. Sylimit1 = HIGH;
  172. Sxlimit1 = HIGH;
  173. delay(100);
  174. }
  175. void prepareHeater(){
  176. heatOn();
  177. tempC = Thermister(analogRead(0)); // Read sensor
  178. while((int)tempC < tempSet){
  179. tempC = Thermister(analogRead(0)); // Read sensor
  180. Serial.println(" TEMP :" + String(tempSet) + " Cur TEMP:" + String ((int)tempC));
  181. delay(100);
  182. }
  183. }
  184. void eforward(){
  185. digitalWrite(ecoila1, LOW);
  186. digitalWrite(ecoila2, LOW);
  187. digitalWrite(ecoilb1, LOW);
  188. digitalWrite(ecoilb2, LOW);
  189. if (extrudOn==0){
  190. return ;
  191. }
  192. if (turn > 3){
  193. turn = 0;
  194. }
  195. if(turn == 0){
  196. digitalWrite(ecoila1, HIGH);
  197. }
  198. if(turn == 1){
  199. digitalWrite(ecoila2, HIGH);
  200. }
  201. if(turn == 2){
  202. digitalWrite(ecoilb1, HIGH);
  203. }
  204. if(turn == 3){
  205. digitalWrite(ecoilb2, HIGH);
  206. }
  207. turn++;
  208. }
  209. void ebackward(){
  210. digitalWrite(ecoila1, LOW);
  211. digitalWrite(ecoila2, LOW);
  212. digitalWrite(ecoilb1, LOW);
  213. digitalWrite(ecoilb2, LOW);
  214. if (extrudOn==0){
  215. return ;
  216. }
  217. if (turn > 3){
  218. turn = 0;
  219. }
  220. if(turn == 3){
  221. digitalWrite(ecoila1, HIGH);
  222. }
  223. if(turn == 2){
  224. digitalWrite(ecoila2, HIGH);
  225. }
  226. if(turn == 1){
  227. digitalWrite(ecoilb1, HIGH);
  228. }
  229. if(turn == 0){
  230. digitalWrite(ecoilb2, HIGH);
  231. }
  232. turn++;
  233. }
  234. void extrudturn(){
  235. ebackward();
  236. }
  237. void ybackward(){
  238. digitalWrite(xcoila1, HIGH);
  239. digitalWrite(xcoila2, LOW);
  240. digitalWrite(xcoilb1, LOW);
  241. digitalWrite(xcoilb2, LOW);
  242. delay(axisspeed);
  243. digitalWrite(xcoila1, LOW);
  244. digitalWrite(xcoila2, HIGH);
  245. digitalWrite(xcoilb1, LOW);
  246. digitalWrite(xcoilb2, LOW);
  247. delay(axisspeed);
  248. digitalWrite(xcoila1, LOW);
  249. digitalWrite(xcoila2, LOW);
  250. digitalWrite(xcoilb1, HIGH);
  251. digitalWrite(xcoilb2, LOW);
  252. delay(axisspeed);
  253. digitalWrite(xcoila1, LOW);
  254. digitalWrite(xcoila2, LOW);
  255. digitalWrite(xcoilb1, LOW);
  256. digitalWrite(xcoilb2, HIGH);
  257. delay(axisspeed);
  258. }
  259. void yforward(){
  260. digitalWrite(xcoila1, LOW);
  261. digitalWrite(xcoila2, LOW);
  262. digitalWrite(xcoilb1, LOW);
  263. digitalWrite(xcoilb2, HIGH);
  264. delay(axisspeed);
  265. digitalWrite(xcoila1, LOW);
  266. digitalWrite(xcoila2, LOW);
  267. digitalWrite(xcoilb1, HIGH);
  268. digitalWrite(xcoilb2, LOW);
  269. delay(axisspeed);
  270. digitalWrite(xcoila1, LOW);
  271. digitalWrite(xcoila2, HIGH);
  272. digitalWrite(xcoilb1, LOW);
  273. digitalWrite(xcoilb2, LOW);
  274. delay(axisspeed);
  275. digitalWrite(xcoila1, HIGH);
  276. digitalWrite(xcoila2, LOW);
  277. digitalWrite(xcoilb1, LOW);
  278. digitalWrite(xcoilb2, LOW);
  279. delay(axisspeed);
  280. }
  281. void xbackward(){
  282. digitalWrite(ycoila1, HIGH);
  283. digitalWrite(ycoila2, LOW);
  284. digitalWrite(ycoilb1, LOW);
  285. digitalWrite(ycoilb2, LOW);
  286. delay(axisspeed);
  287. digitalWrite(ycoila1, LOW);
  288. digitalWrite(ycoila2, HIGH);
  289. digitalWrite(ycoilb1, LOW);
  290. digitalWrite(ycoilb2, LOW);
  291. delay(axisspeed);
  292. digitalWrite(ycoila1, LOW);
  293. digitalWrite(ycoila2, LOW);
  294. digitalWrite(ycoilb1, HIGH);
  295. digitalWrite(ycoilb2, LOW);
  296. delay(axisspeed);
  297. digitalWrite(ycoila1, LOW);
  298. digitalWrite(ycoila2, LOW);
  299. digitalWrite(ycoilb1, LOW);
  300. digitalWrite(ycoilb2, HIGH);
  301. delay(axisspeed);
  302. }
  303. void xforward(){
  304. digitalWrite(ycoila1, LOW);
  305. digitalWrite(ycoila2, LOW);
  306. digitalWrite(ycoilb1, LOW);
  307. digitalWrite(ycoilb2, HIGH);
  308. delay(axisspeed);
  309. digitalWrite(ycoila1, LOW);
  310. digitalWrite(ycoila2, LOW);
  311. digitalWrite(ycoilb1, HIGH);
  312. digitalWrite(ycoilb2, LOW);
  313. delay(axisspeed);
  314. digitalWrite(ycoila1, LOW);
  315. digitalWrite(ycoila2, HIGH);
  316. digitalWrite(ycoilb1, LOW);
  317. digitalWrite(ycoilb2, LOW);
  318. delay(axisspeed);
  319. digitalWrite(ycoila1, HIGH);
  320. digitalWrite(ycoila2, LOW);
  321. digitalWrite(ycoilb1, LOW);
  322. digitalWrite(ycoilb2, LOW);
  323. delay(axisspeed);
  324. }
  325. /*void zforward(){
  326. myservo.write(19);
  327. }
  328. void zbackward(){
  329. myservo.write(30);
  330. }*/
  331. void zforward(){
  332. digitalWrite(zcoila1, HIGH);
  333. digitalWrite(zcoila2, LOW);
  334. digitalWrite(zcoilb1, LOW);
  335. digitalWrite(zcoilb2, LOW);
  336. delay(zaxisspeed);
  337. digitalWrite(zcoila1, LOW);
  338. digitalWrite(zcoila2, HIGH);
  339. digitalWrite(zcoilb1, LOW);
  340. digitalWrite(zcoilb2, LOW);
  341. delay(zaxisspeed);
  342. digitalWrite(zcoila1, LOW);
  343. digitalWrite(zcoila2, LOW);
  344. digitalWrite(zcoilb1, HIGH);
  345. digitalWrite(zcoilb2, LOW);
  346. delay(zaxisspeed);
  347. digitalWrite(zcoila1, LOW);
  348. digitalWrite(zcoila2, LOW);
  349. digitalWrite(zcoilb1, LOW);
  350. digitalWrite(zcoilb2, HIGH);
  351. delay(zaxisspeed);
  352. }
  353. void zbackward(){
  354. digitalWrite(zcoila1, LOW);
  355. digitalWrite(zcoila2, LOW);
  356. digitalWrite(zcoilb1, LOW);
  357. digitalWrite(zcoilb2, HIGH);
  358. delay(zaxisspeed);
  359. digitalWrite(zcoila1, LOW);
  360. digitalWrite(zcoila2, LOW);
  361. digitalWrite(zcoilb1, HIGH);
  362. digitalWrite(zcoilb2, LOW);
  363. delay(zaxisspeed);
  364. digitalWrite(zcoila1, LOW);
  365. digitalWrite(zcoila2, HIGH);
  366. digitalWrite(zcoilb1, LOW);
  367. digitalWrite(zcoilb2, LOW);
  368. delay(zaxisspeed);
  369. digitalWrite(zcoila1, HIGH);
  370. digitalWrite(zcoila2, LOW);
  371. digitalWrite(zcoilb1, LOW);
  372. digitalWrite(zcoilb2, LOW);
  373. delay(zaxisspeed);
  374. }
  375. void strgcode(){
  376. int i=0;
  377. int axis=-1;
  378. int op = -1;
  379. while(inputString[i] != '\0'){
  380. if(inputString[i]==' '){
  381. i++;
  382. continue;
  383. }
  384. if(inputString[i]=='X'){
  385. axis=0;
  386. i++;
  387. continue;
  388. }
  389. if(inputString[i]=='Y'){
  390. axis=1;
  391. i++;
  392. continue;
  393. }
  394. if(inputString[i]=='Z'){
  395. axis=2;
  396. i++;
  397. continue;
  398. }
  399. if(inputString[i]=='S'){
  400. op=0;
  401. i++;
  402. continue;
  403. }
  404. if(inputString[i]=='M'){
  405. op=1;
  406. i++;
  407. continue;
  408. }
  409. if(axis==0){
  410. xstr+=inputString[i];
  411. }
  412. if(axis==1){
  413. ystr+=inputString[i];
  414. }
  415. if(axis==2){
  416. zstr+=inputString[i];
  417. }
  418. if(op==0){
  419. tempstr+=inputString[i];
  420. }
  421. if(op==1){
  422. extrudestr+=inputString[i];
  423. }
  424. i++;
  425. }
  426. }
  427. void heatOn(){
  428. digitalWrite(heatPin, HIGH);
  429. }
  430. void heatOff(){
  431. digitalWrite(heatPin, LOW);
  432. }
  433. void loop()
  434. {
  435. //digitalWrite(13, HIGH);
  436. //delay(2000);
  437. //digitalWrite(13, LOW);
  438. tempC = Thermister(analogRead(0)); // Read sensor
  439. if((int)tempC < tempSet+3){
  440. heatOn();
  441. }else{
  442. if((int)tempC > tempSet+10){
  443. heatOff();
  444. }
  445. }
  446. //Serial.println("Idle "+ String(x) +" "+ String(y)+" "+ String(z) + " TEMP :" + String(tempSet) + " Cur TEMP:" + String ((int)tempC));
  447. if (stringComplete) {
  448. /*Serial.println(inputString);
  449. // clear the string:
  450. inputString = "";
  451. stringComplete = false; */
  452. strgcode();
  453. Serial.flush();
  454. int xdone=0;
  455. int ydone=0;
  456. int zdone=0;
  457. if(tempstr.compareTo("")!= 0){
  458. tempSet = tempstr.toInt();
  459. }
  460. if(extrudestr.compareTo("")!= 0){
  461. if(extrudestr.toInt() == 101){
  462. extrudOn = 1;
  463. }else{
  464. if(extrudestr.toInt()==103){
  465. extrudOn = 0;
  466. }
  467. }
  468. }
  469. //digitalWrite(13, Sxlimit1 );
  470. //if(tempstr.toInt())
  471. while(xdone==0 || ydone==0 || zdone==0){
  472. if (Sxlimit1 == LOW || Sylimit1 == LOW || Sxlimit2 == LOW || Sylimit2 == LOW ){
  473. xIdle();
  474. yIdle();
  475. zIdle();
  476. heatOff();
  477. Serial.println("Error "+ String(Sxlimit1)+" "+String(Sylimit1)+" "+ String(Sxlimit2)+" "+String(Sylimit2));
  478. while(1){
  479. }
  480. }
  481. if(xstr.compareTo("")!= 0){
  482. if(x<xstr.toInt()){
  483. xforward();
  484. x++;
  485. }else{
  486. if(x>xstr.toInt()){
  487. xbackward();
  488. x--;
  489. }else{
  490. xdone=1;
  491. }
  492. }
  493. }else{
  494. xdone=1;
  495. }
  496. if(ystr.compareTo("")!= 0){
  497. if(y<ystr.toInt()){
  498. yforward();
  499. y++;
  500. }else{
  501. if(y>ystr.toInt()){
  502. ybackward();
  503. y--;
  504. }else{
  505. ydone=1;
  506. }
  507. }
  508. }else{
  509. ydone=1;
  510. }
  511. if(zstr.compareTo("")!= 0){
  512. if(z<zstr.toInt()){
  513. for (int i=0;i<10;i++){
  514. zforward();
  515. }
  516. z++;
  517. }else{
  518. if(z>zstr.toInt()){
  519. for (int i=0;i<10;i++){
  520. zbackward();
  521. }
  522. z--;
  523. }else{
  524. zdone=1;
  525. }
  526. }
  527. }else{
  528. zdone=1;
  529. }
  530. }
  531. Serial.println("Done "+ String(xstr) +" "+ String(ystr)+" "+ String(zstr) + " TEMP :" + String(tempSet) + "Cur TEMP:" + String ((int)tempC));
  532. // clear the string:
  533. inputString = "";
  534. xstr="";
  535. ystr="";
  536. zstr="";
  537. tempstr="";
  538. extrudestr="";
  539. stringComplete = false;
  540. }
  541. }
  542. void xlimit1On(){
  543. Sxlimit1 = !Sxlimit1;
  544. }
  545. void ylimit1On(){
  546. Sylimit1 = !Sylimit1;
  547. }
  548. void xlimit2On(){
  549. Sxlimit2 = !Sxlimit2;
  550. }
  551. void ylimit2On(){
  552. Sylimit2 = !Sylimit2;
  553. }
  554. void serialEvent() {
  555. while (Serial.available()) {
  556. // get the new byte:
  557. char inChar = (char)Serial.read();
  558. // add it to the inputString:
  559. if (inChar == '\n') {
  560. inputString+='\0';
  561. stringComplete = true;
  562. return;
  563. }
  564. inputString += inChar;
  565. // if the incoming character is a newline, set a flag
  566. // so the main loop can do something about it:
  567. }
  568. }