├── .github └── FUNDING.yml ├── Codes ├── Arduino │ └── sketch_jun04c │ │ └── sketch_jun04c.ino ├── Processing │ └── laserengraver │ │ ├── Arduino Logo 300x300.png │ │ ├── README.md │ │ ├── grou.png │ │ ├── laser symbol.png │ │ ├── laserengraver.pde │ │ ├── ne555 klein neu.png │ │ └── ne555 last.png └── version2 │ └── version2.ino ├── LICENSE ├── README.md └── layout.PDF /.github/FUNDING.yml: -------------------------------------------------------------------------------- 1 | # These are supported funding model platforms 2 | 3 | github: neumi 4 | -------------------------------------------------------------------------------- /Codes/Arduino/sketch_jun04c/sketch_jun04c.ino: -------------------------------------------------------------------------------- 1 | 2 | int nextStepX = 1; 3 | int backStepX = 1; 4 | 5 | int nextStepY = 1; 6 | int backStepY = 1; 7 | 8 | int led = 50; 9 | 10 | int nikoDelay = 10; // 2ms for PCB photoresist!! 11 | 12 | int testDigInt; 13 | String contentString; 14 | 15 | 16 | 17 | void setup() { 18 | Serial.begin(57600); 19 | 20 | 21 | pinMode(9, OUTPUT); //enables for X axis 22 | pinMode(10, OUTPUT); //enables for X axis 23 | digitalWrite(9, HIGH); //enables for X axis 24 | digitalWrite(10, HIGH); //enables for X axis 25 | 26 | pinMode(3, OUTPUT); //enables for Y axis 27 | pinMode(2, OUTPUT); //enables for Y axis 28 | digitalWrite(3, HIGH); //enables for Y axis 29 | digitalWrite(2, HIGH); //enables for Y axis 30 | 31 | pinMode(13, OUTPUT); 32 | pinMode(12, OUTPUT); 33 | pinMode(11, OUTPUT); 34 | pinMode(8, OUTPUT); 35 | 36 | pinMode(7, OUTPUT); 37 | pinMode(6, OUTPUT); 38 | pinMode(5, OUTPUT); 39 | pinMode(4, OUTPUT); 40 | 41 | 42 | 43 | pinMode(52, INPUT); //switch 44 | pinMode(led, OUTPUT); //laser 45 | } 46 | 47 | void loop() { 48 | 49 | int x = map(analogRead(A0),0,1023,1,100); //get analog values from potentionometer joystick 50 | int y = map(analogRead(A1),0,1023,1,100); //get analog values from potentionometer joystick 51 | 52 | while (Serial.available() > 0) { // get 01010100110 sting from computer running processing 53 | String RawRead = Serial.readStringUntil('\n'); //write raw string until end of line 54 | String BackWay = RawRead.substring(300); //get the first 300 characters of input string 55 | 56 | //Serial.print("I Read: "); 57 | //Serial.println(BackWay); 58 | 59 | String testDigit = RawRead.substring(0,1); //i have absolutely no idea what this was for :D 60 | contentString = RawRead.substring(0,300); 61 | 62 | testDigInt = testDigit.toInt(); 63 | //Serial.print("testDig: "); 64 | //Serial.println(testDigInt); 65 | 66 | //Serial.print("String: "); 67 | //Serial.println(contentString); 68 | 69 | digitalWrite(3, HIGH); //enable stepper motor drivers 70 | digitalWrite(2, HIGH); //enable stepper motor drivers 71 | digitalWrite(9, HIGH); //enable stepper motor drivers 72 | digitalWrite(10, HIGH); //enable stepper motor drivers 73 | 74 | for (int i=0; i <= 300; i++){ //run threw the lines until the end of range 75 | //Serial.print(contentString[i]); 76 | 77 | 78 | if(contentString[i] == '1') { //when string contains a black pixel at the current point... 79 | digitalWrite(led, HIGH); //set laser high 80 | //Serial.println("1"); 81 | 82 | // not sure if the order is in the right way! maybe wait before doSepY(0); ?? but it workd this way! 83 | doStepY(0); // do next step 84 | delay(nikoDelay); // wait for the time the laser should burn 85 | } 86 | else { 87 | digitalWrite(led, LOW); // set/keep laser off 88 | //Serial.println("0"); 89 | doStepY(0); // do next step 90 | delay(2); //2ms for good running behaviour 91 | } 92 | } 93 | doStepX(1); // to step next for the laser mechanic 94 | 95 | 96 | for (int i=0; i <= 300; i++){ //get threw the lines in reversed orientation... 97 | //Serial.print(contentString[i]); 98 | 99 | //same procedure as last time 100 | if(BackWay[i] == '1') { 101 | digitalWrite(led, HIGH); 102 | //Serial.println("1"); 103 | doStepY(1); 104 | delay(nikoDelay); 105 | } 106 | else { 107 | digitalWrite(led, LOW); 108 | //Serial.println("0"); 109 | doStepY(1); 110 | delay(2); 111 | } 112 | } 113 | doStepX(1); // to step next for the laser mechanic 114 | 115 | Serial.write("k"); //write feedback for processing 116 | 117 | }// end of serial.available 118 | 119 | digitalWrite(9, LOW); //disable all motordrivers 120 | digitalWrite(10, LOW); //disable all motordrivers 121 | digitalWrite(3, LOW); //disable all motordrivers 122 | digitalWrite(2, LOW); //disable all motordrivers 123 | 124 | if(digitalRead(52) == HIGH) { //if button is pressed... 125 | digitalWrite(led, HIGH); // turn on laser 126 | }else digitalWrite(led, LOW); //if button is not pressed, turn off laser 127 | 128 | 129 | 130 | if(x > 60 || x < 40 || y > 60 || y < 40) { // if joystick is moved enough... 131 | if(x > 60) { // move axis when joystick is moved 132 | doStepX(1); 133 | //Serial.println("StepX 1"); 134 | } 135 | if(x < 40) { 136 | doStepX(0); 137 | //Serial.println("StepX 0"); 138 | } 139 | if(x > 40 && x < 60) { //set of X motor drivers, when joystick is not moved enough 140 | digitalWrite(9, LOW); 141 | digitalWrite(10, LOW); 142 | } 143 | else { //set on X motors, when joystick X axis is moved enough 144 | digitalWrite(9, HIGH); 145 | digitalWrite(10, HIGH); 146 | } 147 | 148 | if(y > 60) { //same for Y axis... 149 | doStepY(1); 150 | //Serial.println("StepY 1"); 151 | } 152 | if(y < 40) { 153 | doStepY(0); 154 | //Serial.println("StepY 0"); 155 | } 156 | if(y > 40 && y < 60) { 157 | digitalWrite(3, LOW); 158 | digitalWrite(2, LOW); 159 | } 160 | else { 161 | digitalWrite(3, HIGH); 162 | digitalWrite(2, HIGH); 163 | } 164 | 165 | delay(3); // for moveing the steppermotors not to fast, when joystick is moved 166 | } 167 | 168 | } 169 | 170 | void doStepX(int dirForX) { //stepper motor function for X axis 171 | if(dirForX == 1) { 172 | switch(nextStepX) { 173 | case 1: 174 | digitalWrite(13, HIGH); 175 | digitalWrite(12, LOW); 176 | digitalWrite(11, LOW); 177 | digitalWrite(8, LOW); 178 | nextStepX = 2; 179 | backStepX = 8; 180 | break; 181 | case 2: 182 | digitalWrite(13, HIGH); 183 | digitalWrite(12, HIGH); 184 | digitalWrite(11, LOW); 185 | digitalWrite(8, LOW); 186 | nextStepX = 3; 187 | backStepX = 1; 188 | break; 189 | case 3: 190 | digitalWrite(13, LOW); 191 | digitalWrite(12, HIGH); 192 | digitalWrite(11, LOW); 193 | digitalWrite(8, LOW); 194 | nextStepX = 4; 195 | backStepX = 2; 196 | break; 197 | case 4: 198 | digitalWrite(13, LOW); 199 | digitalWrite(12, HIGH); 200 | digitalWrite(11, HIGH); 201 | digitalWrite(8, LOW); 202 | nextStepX = 5; 203 | backStepX = 3; 204 | break; 205 | case 5: 206 | digitalWrite(13, LOW); 207 | digitalWrite(12, LOW); 208 | digitalWrite(11, HIGH); 209 | digitalWrite(8, LOW); 210 | nextStepX = 6; 211 | backStepX = 4; 212 | break; 213 | case 6: 214 | digitalWrite(13, LOW); 215 | digitalWrite(12, LOW); 216 | digitalWrite(11, HIGH); 217 | digitalWrite(8, HIGH); 218 | nextStepX = 7; 219 | backStepX = 5; 220 | break; 221 | case 7: 222 | digitalWrite(13, LOW); 223 | digitalWrite(12, LOW); 224 | digitalWrite(11, LOW); 225 | digitalWrite(8, HIGH); 226 | nextStepX = 8; 227 | backStepX = 6; 228 | break; 229 | case 8: 230 | digitalWrite(13, HIGH); 231 | digitalWrite(12, LOW); 232 | digitalWrite(11, LOW); 233 | digitalWrite(8, HIGH); 234 | nextStepX = 1; 235 | backStepX = 7; 236 | break; 237 | } 238 | }else { 239 | switch(backStepX) { 240 | case 1: 241 | digitalWrite(13, HIGH); 242 | digitalWrite(12, LOW); 243 | digitalWrite(11, LOW); 244 | digitalWrite(8, LOW); 245 | nextStepX = 2; 246 | backStepX = 8; 247 | break; 248 | case 2: 249 | digitalWrite(13, HIGH); 250 | digitalWrite(12, HIGH); 251 | digitalWrite(11, LOW); 252 | digitalWrite(8, LOW); 253 | nextStepX = 3; 254 | backStepX = 1; 255 | break; 256 | case 3: 257 | digitalWrite(13, LOW); 258 | digitalWrite(12, HIGH); 259 | digitalWrite(11, LOW); 260 | digitalWrite(8, LOW); 261 | nextStepX = 4; 262 | backStepX = 2; 263 | break; 264 | case 4: 265 | digitalWrite(13, LOW); 266 | digitalWrite(12, HIGH); 267 | digitalWrite(11, HIGH); 268 | digitalWrite(8, LOW); 269 | nextStepX = 5; 270 | backStepX = 3; 271 | break; 272 | case 5: 273 | digitalWrite(13, LOW); 274 | digitalWrite(12, LOW); 275 | digitalWrite(11, HIGH); 276 | digitalWrite(8, LOW); 277 | nextStepX = 6; 278 | backStepX = 4; 279 | break; 280 | case 6: 281 | digitalWrite(13, LOW); 282 | digitalWrite(12, LOW); 283 | digitalWrite(11, HIGH); 284 | digitalWrite(8, HIGH); 285 | nextStepX = 7; 286 | backStepX = 5; 287 | break; 288 | case 7: 289 | digitalWrite(13, LOW); 290 | digitalWrite(12, LOW); 291 | digitalWrite(11, LOW); 292 | digitalWrite(8, HIGH); 293 | nextStepX = 8; 294 | backStepX = 6; 295 | break; 296 | case 8: 297 | digitalWrite(13, HIGH); 298 | digitalWrite(12, LOW); 299 | digitalWrite(11, LOW); 300 | digitalWrite(8, HIGH); 301 | nextStepX = 1; 302 | backStepX = 7; 303 | break; 304 | } 305 | } 306 | 307 | } 308 | 309 | void doStepY(int dirForY) { //stepper motor function for Y axis 310 | if(dirForY == 1) { 311 | switch(nextStepY) { 312 | case 1: 313 | digitalWrite(7, HIGH); 314 | digitalWrite(6, LOW); 315 | digitalWrite(5, LOW); 316 | digitalWrite(4, LOW); 317 | nextStepY = 2; 318 | backStepY = 8; 319 | break; 320 | case 2: 321 | digitalWrite(7, HIGH); 322 | digitalWrite(6, HIGH); 323 | digitalWrite(5, LOW); 324 | digitalWrite(4, LOW); 325 | nextStepY = 3; 326 | backStepY = 1; 327 | break; 328 | case 3: 329 | digitalWrite(7, LOW); 330 | digitalWrite(6, HIGH); 331 | digitalWrite(5, LOW); 332 | digitalWrite(4, LOW); 333 | nextStepY = 4; 334 | backStepY = 2; 335 | break; 336 | case 4: 337 | digitalWrite(7, LOW); 338 | digitalWrite(6, HIGH); 339 | digitalWrite(5, HIGH); 340 | digitalWrite(4, LOW); 341 | nextStepY = 5; 342 | backStepY = 3; 343 | break; 344 | case 5: 345 | digitalWrite(7, LOW); 346 | digitalWrite(6, LOW); 347 | digitalWrite(5, HIGH); 348 | digitalWrite(4, LOW); 349 | nextStepY = 6; 350 | backStepY = 4; 351 | break; 352 | case 6: 353 | digitalWrite(7, LOW); 354 | digitalWrite(6, LOW); 355 | digitalWrite(5, HIGH); 356 | digitalWrite(4, HIGH); 357 | nextStepY = 7; 358 | backStepY = 5; 359 | break; 360 | case 7: 361 | digitalWrite(7, LOW); 362 | digitalWrite(6, LOW); 363 | digitalWrite(5, LOW); 364 | digitalWrite(4, HIGH); 365 | nextStepY = 8; 366 | backStepY = 6; 367 | break; 368 | case 8: 369 | digitalWrite(7, HIGH); 370 | digitalWrite(6, LOW); 371 | digitalWrite(5, LOW); 372 | digitalWrite(4, HIGH); 373 | nextStepY = 1; 374 | backStepY = 7; 375 | break; 376 | } 377 | }else { 378 | switch(backStepY) { 379 | case 1: 380 | digitalWrite(7, HIGH); 381 | digitalWrite(6, LOW); 382 | digitalWrite(5, LOW); 383 | digitalWrite(4, LOW); 384 | nextStepY = 2; 385 | backStepY = 8; 386 | break; 387 | case 2: 388 | digitalWrite(7, HIGH); 389 | digitalWrite(6, HIGH); 390 | digitalWrite(5, LOW); 391 | digitalWrite(4, LOW); 392 | nextStepY = 3; 393 | backStepY = 1; 394 | break; 395 | case 3: 396 | digitalWrite(7, LOW); 397 | digitalWrite(6, HIGH); 398 | digitalWrite(5, LOW); 399 | digitalWrite(4, LOW); 400 | nextStepY = 4; 401 | backStepY = 2; 402 | break; 403 | case 4: 404 | digitalWrite(7, LOW); 405 | digitalWrite(6, HIGH); 406 | digitalWrite(5, HIGH); 407 | digitalWrite(4, LOW); 408 | nextStepY = 5; 409 | backStepY = 3; 410 | break; 411 | case 5: 412 | digitalWrite(7, LOW); 413 | digitalWrite(6, LOW); 414 | digitalWrite(5, HIGH); 415 | digitalWrite(4, LOW); 416 | nextStepY = 6; 417 | backStepY = 4; 418 | break; 419 | case 6: 420 | digitalWrite(7, LOW); 421 | digitalWrite(6, LOW); 422 | digitalWrite(5, HIGH); 423 | digitalWrite(4, HIGH); 424 | nextStepY = 7; 425 | backStepY = 5; 426 | break; 427 | case 7: 428 | digitalWrite(7, LOW); 429 | digitalWrite(6, LOW); 430 | digitalWrite(5, LOW); 431 | digitalWrite(4, HIGH); 432 | nextStepY = 8; 433 | backStepY = 6; 434 | break; 435 | case 8: 436 | digitalWrite(7, HIGH); 437 | digitalWrite(6, LOW); 438 | digitalWrite(5, LOW); 439 | digitalWrite(4, HIGH); 440 | nextStepY = 1; 441 | backStepY = 7; 442 | break; 443 | } 444 | } 445 | 446 | } 447 | -------------------------------------------------------------------------------- /Codes/Processing/laserengraver/Arduino Logo 300x300.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Neumi/Arduino-Processing-Laser-CNC/cb4e138da124e715ef7f2b16231015357a9a92d4/Codes/Processing/laserengraver/Arduino Logo 300x300.png -------------------------------------------------------------------------------- /Codes/Processing/laserengraver/README.md: -------------------------------------------------------------------------------- 1 | # Arduino-Processing-Laser-CNC 2 | Arduino feat. Processing Laser CNC Project 3 | 4 | 11.01.2016 5 | 6 | Readme for Processing Code 7 | 8 | 9 | 10 | This readme will describe how to use the Processing sketch… 11 | 12 | Setting up Serial: 13 | At first you have to set up the serial connection between the Arduino and your computer or Processing sketch. For my computer it was Serial port nr 9, but for your setup it should be a different port. Find out by print the Serial.list(), before you run the processing sketch! When you found the port number, change it in the Processing sketch by me. 14 | 15 | Setting um pictures: 16 | Then you can import pictures to the program. The pictures can be in .jpg and .png formats and have to have a resolution of 300x300 pixels. Furthermore the pixels have to be totally black, because the algorithm is searching only for black pixels and only translates them into a ‚1‘ in the serial string. 17 | 18 | Running: 19 | While the laser is running, you have to keep the connection to the computer. After every two lines the Arduino sends a ‚give me a newline‘ in form of a ‚k‘ char! When Processing receives the newlines instruction, processing generates the string for the next two pixel lines and sends them to the Arduino. This repeats until the picture is completely transmitted. 20 | 21 | -------------------------------------------------------------------------------- /Codes/Processing/laserengraver/grou.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Neumi/Arduino-Processing-Laser-CNC/cb4e138da124e715ef7f2b16231015357a9a92d4/Codes/Processing/laserengraver/grou.png -------------------------------------------------------------------------------- /Codes/Processing/laserengraver/laser symbol.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Neumi/Arduino-Processing-Laser-CNC/cb4e138da124e715ef7f2b16231015357a9a92d4/Codes/Processing/laserengraver/laser symbol.png -------------------------------------------------------------------------------- /Codes/Processing/laserengraver/laserengraver.pde: -------------------------------------------------------------------------------- 1 | // doppeltest 2 | import processing.serial.*; 3 | Serial myPort; 4 | 5 | PImage img; // The source image 6 | int cols, rows; // Number of columns and rows in our system 7 | 8 | int line = 0; 9 | int val; 10 | boolean runthrew = false; 11 | 12 | int pixelSquare = 300; 13 | 14 | void setup() { 15 | size(300, 300); 16 | img = loadImage("Arduino Logo 300x300.png"); 17 | String portName = Serial.list()[9]; 18 | myPort = new Serial(this, portName, 57600); 19 | } 20 | 21 | void draw() { 22 | background(0, 102, 153); 23 | image(img, 0, 0); 24 | loadPixels(); 25 | stroke(0,0,255); 26 | line(line-1,0,line-1,300); 27 | textSize(20); 28 | fill(200,200,200); 29 | rect(0,0,110,25); 30 | fill(0,240,0); 31 | text("Line: ",10,20); 32 | text(line, 60,20); 33 | 34 | if(mousePressed) { 35 | myPort.write("0"); //anfangsbefehl 36 | } 37 | 38 | if ( myPort.available() > 0) { // If data is available, 39 | val = myPort.read(); // read it and store it in val 40 | 41 | if(line < 300) { 42 | 43 | if(val == 'k') { 44 | 45 | println(); 46 | println("Received Pulse! "); 47 | print("Line: "); 48 | println(line); 49 | 50 | newSection(); 51 | } 52 | } 53 | else { 54 | text("Ready!",20,20); 55 | } 56 | } 57 | 58 | 59 | 60 | } 61 | 62 | void newSection() { 63 | 64 | for ( int j = 0; j < 299; j++) { 65 | int x = line + pixelSquare; // x position 66 | int y = j + pixelSquare; // y position 67 | 68 | int loc = line + j * pixelSquare; // Pixel array location 69 | 70 | int c = img.pixels[loc]; 71 | 72 | if(c < -16000000) { 73 | print(1); 74 | myPort.write("1"); 75 | } 76 | else { 77 | print(0); 78 | myPort.write("0"); 79 | } 80 | } 81 | line = line + 1; 82 | myPort.write("0"); 83 | for ( int j = 299; j > 0; j--) { 84 | int x = line + pixelSquare; // x position 85 | int y = j + pixelSquare; // y position 86 | 87 | int loc = line + j * pixelSquare; // Pixel array location 88 | 89 | int c = img.pixels[loc]; 90 | 91 | if(c < -16000000) { 92 | print(1); 93 | myPort.write("1"); 94 | } 95 | else { 96 | print(0); 97 | myPort.write("0"); 98 | } 99 | } 100 | line = line + 1; 101 | 102 | 103 | myPort.write('\n'); 104 | 105 | } 106 | -------------------------------------------------------------------------------- /Codes/Processing/laserengraver/ne555 klein neu.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Neumi/Arduino-Processing-Laser-CNC/cb4e138da124e715ef7f2b16231015357a9a92d4/Codes/Processing/laserengraver/ne555 klein neu.png -------------------------------------------------------------------------------- /Codes/Processing/laserengraver/ne555 last.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Neumi/Arduino-Processing-Laser-CNC/cb4e138da124e715ef7f2b16231015357a9a92d4/Codes/Processing/laserengraver/ne555 last.png -------------------------------------------------------------------------------- /Codes/version2/version2.ino: -------------------------------------------------------------------------------- 1 | 2 | int nextStepX = 1; 3 | int backStepX = 1; 4 | 5 | int nextStepY = 1; 6 | int backStepY = 1; 7 | 8 | int laserTime = 3000; // 2000us for PCB photoresist!! 9 | int stepTime = 500; 10 | 11 | int stepPinX = 6; 12 | int dirPinX = 7; 13 | int stepPinY = 8; 14 | int dirPinY = 9; 15 | int laserPin = 13; 16 | 17 | String contentString; 18 | 19 | void setup() { 20 | Serial.begin(57600); 21 | 22 | pinMode(stepPinX, OUTPUT); 23 | pinMode(dirPinX, OUTPUT); 24 | pinMode(stepPinY, OUTPUT); 25 | pinMode(dirPinY, OUTPUT); 26 | pinMode(laserPin, OUTPUT); 27 | 28 | } 29 | 30 | void loop() { 31 | 32 | while (Serial.available() > 0) { 33 | String RawRead = Serial.readStringUntil('\n'); 34 | String BackWay = RawRead.substring(300); 35 | contentString = RawRead.substring(0, 300); 36 | 37 | for (int i = 0; i <= 300; i++) { 38 | if (contentString[i] == '1') { //when string contains a black pixel at the current point... 39 | digitalWrite(laserPin, HIGH); //set laser high 40 | doStepY(0); // do next step 41 | } 42 | else { 43 | digitalWrite(laserPin, LOW); // set/keep laser off 44 | doStepY(0); 45 | } 46 | } 47 | doStepX(1); 48 | 49 | for (int i = 0; i <= 300; i++) { //get threw the lines in reversed orientation... 50 | if (BackWay[i] == '1') { 51 | digitalWrite(laserPin, HIGH); 52 | doStepY(1); 53 | delayMicroseconds(laserTime); 54 | } 55 | else { 56 | digitalWrite(laserPin, LOW); 57 | doStepY(1); 58 | } 59 | } 60 | doStepX(1); // to step next for the laser mechanic 61 | Serial.write("k"); //write feedback for processing 62 | } 63 | } 64 | 65 | 66 | void doStepX(boolean dir) { 67 | digitalWrite(dirPinX, dir); 68 | digitalWrite(stepPinX, HIGH); 69 | delayMicroseconds(stepTime); 70 | digitalWrite(stepPinX, LOW); 71 | delayMicroseconds(stepTime); 72 | 73 | } 74 | void doStepY(boolean dir) { 75 | digitalWrite(dirPinY, dir); 76 | digitalWrite(stepPinY, HIGH); 77 | delayMicroseconds(stepTime); 78 | digitalWrite(stepPinY, LOW); 79 | delayMicroseconds(stepTime); 80 | } 81 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2016 Neumi 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Arduino-Processing-Laser-CNC 2 | Arduino feat. Processing Laser CNC Project 3 | 4 | 5 | Hey Ho, 6 | 7 | This is a project I made in 2015 and now publishing. 8 | The core of the Project is a hardware made out of two CD drive stepper motors an mechanics, two L298 motor drivers and an arduino Mega. 9 | 10 | The one axis controls the 150mw 405nm laser and the oder axis moves the table. 11 | 12 | The Processing codes generates strings from a .png or .jpg file and send them via serial to the Arduino, wich then moves the table and laser and triggers the laser in the moment, when a black pixel showing up in the string. 13 | Burning time is set in the Arduino code. Pictures are imported manually and have to be in the folder, where the processing sketch is located. 14 | 15 | I wrote some new stepper motor functions because I lost steps with the embedded Arduino lib. Its all some kind of sketchy, but it works perfectly fine and really fast. 16 | 17 | In future versions I might implement a transmission of gray scales to change the exposure time on the laser while the laser is operating. With this technique it might be possible to burn real grayscale pictures in different materials like wood, paper etc. 18 | 19 | 20 | Watch 21 | https://www.youtube.com/watch?v=gs4uoEPE4Lk 22 | for further information. 23 | 24 | If you like this project feel free to buy me a coffee! https://ko-fi.com/Buttons/Buy/1669O9K1BCOA 25 | 26 | Best regards, 27 | 28 | Neumi 29 | -------------------------------------------------------------------------------- /layout.PDF: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Neumi/Arduino-Processing-Laser-CNC/cb4e138da124e715ef7f2b16231015357a9a92d4/layout.PDF --------------------------------------------------------------------------------