Laser Cut Bilanz
7 Schritt:Schritt 1: Wie funktioniert ein Nehmen Sie Arbeit? Schritt 2: Laser Cutter Specs Schritt 3: Sine Tests Schritt 4: Audio Tests auf Acryl Schritt 5: Audio Tests auf Papier Schritt 6: Audio Tests auf Holz Schritt 7: Erstellen Sie Ihr eigenes
Alle 12 Artikel anzeigen
Vor ein paar Monaten schrieb ich darüber, wie ich einen 3D-Drucker, jede MP3-Format in eine physikalische Platten zu verwandeln. Obwohl die gesamte Dokumentation für dieses Projekt finden Sie hier, und die 3D-Modelle könnten möglicherweise durch eine Online-Herstellungsdienst ausgedruckt, wusste ich, dass die Eintrittsbarriere für normale Leute, die sich bei dem Versuch, das Verfahren selbst war unerschwinglich hoch. Mit diesem Projekt wollte ich versuchen, die Idee der digital hergestellten Aufzeichnungen erstrecken sich relativ häufig und erschwingliche Maschinen und Materialien, damit (hoffentlich) mehr Menschen teilnehmen können, Experiment zu verwenden, und tatsächlich nutzen all diese Dokumentation Ich schreibe.
Diese Aufzeichnungen wurden auf einem Epilog 120 Watt Legend EXT einer theoretischen Genauigkeit von 1.200 dpi (der Schnitt Schnittfuge des Schnittes und einige Tricks, die ich verwendet, um zu vermeiden Absturz der Laserschneider sank die tatsächliche Präzision bis von ~ 6.1). Die Audio auf den Aufzeichnungen hat eine Farbtiefe zwischen 4-5 (typisch MP3 Audio ist 16 bit) und einer Abtastrate von bis zu etwa 4.5kHz (mp3 ist 44,1 kHz). Bisher habe ich erfolgreich schneiden Audio auf Holz (Abb 1-2), Acryl (Abb 3-4) und Papier (Figuren 5-6), und ich bin sicher, es gibt viele weitere Materialien, die funktionieren würde. Ich schrieb die Verarbeitung Skizze, die den Datensatz Schneidbahnen, so dass es für jeden Song, Material kann geändert werden, Schneidemaschine, Plattengröße und Plattenspieler-Geschwindigkeit (fahren Sie mit den Code herunterzuladen und zu lernen, wie Sie Ihre eigenen Unterlagen machen) erzeugt.
Sie sollten auch beachten, dass in diesem Instructable ich werde zeigen, wie gesagt habe ich ein Laserschneider für diesen Prozess, aber die Schneid Dateien verwende ich sind Standard- Vektor-Grafik im PDF-Format, so dass sie auf viele andere digitale Fertigung erweitert werden Werkzeuge. Zum Beispiel, ich bin neugierig zu sehen, ob es möglich ist, eine CNC-Fräse oder CNC Rasierklinge Papierschneider mit meinem Schnittdateien verwenden (eine Gruppe von Menschen waren in der Lage, auf dem Papier ausgeschnitten einige Sinuswellen mit einem Cameo in diesem Instructable) .
Unten sehen Sie einige meiner Endergebnisse, lesen Sie weiter, um zu sehen, wie sie gemacht wurden und wie Sie Ihre eigenen.
Joy Division - Love Will Tear Us Apart auf Plexiglas (download Vektordateien):
Radiohead - Idioteque auf Holz (download Vektordateien):
The Velvet Underground und Nico - Femme Fatale auf Ahorn (download Vektordateien):
The Velvet Underground - Mittwoch Morgen am Ahorn (download Vektordateien):
Schritt 1: Wie funktioniert ein Nehmen Sie Arbeit?
Ich habe ein wenig darüber, wie eine Aufzeichnung funktioniert und das Ausmaß der Vinylmikrorillen in meiner 3D gedruckte Aufzeichnung Projekt erläutert. Der Hauptunterschied zwischen diesen Laser geschnitten Aufzeichnungen und meine 3D-gedruckten Datensätze ist die Achse, die die Rillen auf geschnitten. Da kann ich die Leistung des Lasers nicht kontrollieren, während sie schneiden ein Vektorpfad werden die Laser-Cut Datensätze seitlich an der Oberfläche des Materials geschnitten. Dies bedeutet, dass die Nadel schwingt nur in der Ebene parallel zur Platte mit dem Plattenteller. Die 3D-Datensätze werden gedruckt "Schnitt" vertikal, dh die Nadel vibriert in der Ebene senkrecht zu den Plattenteller. Ich entschied mich, die Nuten für die 3D-gedruckten Datensätze vertikal zu modulieren, da die vertikale Achse ist die genaueste Achse an der Maschine (Auflösung von 16 Mikrometer).
Stereo (2-Kanal) Schallplatten sind sowohl vertikal als auch seitlich für zwei isolierte Audiokanäle schneiden, auf diese Weise ist es möglich, in eine Nut passen. Mono Vinyls seitlich schneiden nur ist dies, weil die vertikalen Schnitte kann verzerrt werden, vor allem, wenn Sie versuchen, um die Amplitude des Wellenform zu erhöhen, um den Dynamikbereich des Klangs zu steigern. Obwohl ich nicht wirklich eine Wahl in der Sache, ist es besser, einen mono Nut seitlich geschnitten.
Um Ihnen eine Vorstellung von der Größe der Nuten auf eine moderne Rekord Besuche das Bild oberhalb von Chris Supranowitz , ein Forscher an der Institut für Optik an der Universität von Rochester . Dies ist eine Nahaufnahme Bild einer Vinyl-Schallplatte mit einem Elektronenmikroskop. Die dunkle Objekte in den Nuten sind winzige Staubpartikel. Der Laserschneider kann nicht wie präzise Schnitte, da die Breite des Strahls zu groß ist, so dass die Rillen auf meine Platten sind etwa 1-2 Größenordnungen in jeder Dimension als diese grooves.Step 2 größer: Laser Cutter Specs
Die Laser in unserem Büro sind Epilog 120 Watt Legend 36EXT . Sie haben ein 36 "x24" Schneiden Bett, groß genug, um mehrere 12 "Datensätze gleichzeitig zu schneiden. Sie verfügen über eine maximale Auflösung von 1200 dpi in der x und y-Achse und 100 Kraft und Geschwindigkeit Einstellungen, um Schnitttiefe zu kontrollieren.
Bevor ich begann Schneiden nichts, habe ich diese Nummern, um die Auflösung würde ich in der Lage, zu erreichen berechnen. Zuerst wollte ich sicherstellen, dass ich in der Lage wäre, eine gute Abtastrate auf meinem Audio zu bekommen. Abtastrate ist die Menge an Samples pro Sekunde in einem Lied. In der Regel die Abtastrate 44,1 kHz (oder 44.100 Samples pro Sekunde). Bei einer Abtastrate von unter etwa 40 kHz die höheren Frequenzen eines Songs beginnen ihre Detail zu verlieren, aber abhängig von der Song Sie können bis zu 20 oder sogar 10 kHz Abtastrate, ohne zu viel eines Problems zu gehen.
Um die Abtastrate zu berechnen, habe ich die folgende Beziehung:
Abtastfrequenz = (Auflösung pro Zoll) * (Zoll pro Umdrehung) * (Umdrehungen pro Sekunde)
(Um die Abtastfrequenz zu maximieren wollen wir alle diese Nummern (res / inch, inch / U, U / s) so hoch wie möglich sein)
auch feststellen, wie der Sampling-Rate wird als die Nadel bewegt sich in Richtung der Mitte der Platte zu verringern (kleinere Zoll / Umdrehung)
Zunächst werde ich mit Umdrehungen pro Sekunde zu starten. Plattenspieler in der Regel spielen mit zwei verschiedenen Geschwindigkeiten: 33,3 und 45rpm. (Einige Plattenspieler haben auch eine 78er Geschwindigkeit, aber das ist weniger häufig und nur für sehr alte Datensätze verwendet wird). Wenn ich die höhere, 45rpm Geschwindigkeit kann ich Umdrehungen pro Sekunde zu berechnen wie folgt:
Umdrehungen pro Sekunde = (Umdrehungen pro Minute) / (Sekunden pro Minute)
Umdrehungen pro Sekunde = 45/60 = 0,75
Als nächstes wird Inch pro Umdrehung, diese Zahl hängt von dem Umfang der Scheibe, wo die Nadel trifft es. Die größte Größe Aufzeichnungen sind 12 "im Durchmesser (30 cm). Nach Angaben der RIAA-Standards , die äußerste Rille eines 12 "fällt Rekord bei einem Radius von 5,75" und der innersten Rille fällt bei etwa 2,25 ". Ich werde diese Nummern verwenden, um den Bereich von Abtastraten zu bestimmen, kann ich auf 33 und 45rpm erzielen. Der Umfang (der Abstand in Zoll von der Nadel während einer Umdrehung des Aufzeichnungs gereist) wird wie folgt berechnet:
Inch pro Umdrehung = 2 * pi * (Radius von Nadel)
max Inch pro Umdrehung = 2 * pi * 5,75 = ~ 36
min Inch pro Umdrehung = 2 * pi * 2,35 = ~ 15
Wir wissen bereits, dass die Auflösung pro Zoll des Laser-Cutter ist 1200 (1200 dpi in der x und y-Achse). So kombiniert dies alles, was wir bekommen:
Abtastfrequenz = (Auflösung pro Zoll) * (Zoll pro Umdrehung) * (Umdrehungen pro Sekunde)
max Abtastfrequenz bei 45 rpm = 1200 * 36 * 0,75 = ~ 32400 = 32.4kHz
min Abtastfrequenz bei 45 rpm = 1200 * 15 * 0,75 = ~ 13500 = 13.5kHz
Das ist ein ziemlich guter Ausgangspunkt. Wenn ich dies zu skalieren statt 45 33.3rpm (dies ermöglicht es mir, mehr Musik auf dem Album passen) die Abtastrate wird:
max Abtastfrequenz bei 33 rpm = 1200 * 36 * 0,5 = 21600 = ~ 21.6kHz
min Abtastfrequenz bei 33 rpm = 1200 * 15 * 0,5 = ~ 9000 = 9 kHz
Dies ist immer noch leicht genug ist, um eine erkennbare Lied wiederzugeben.
Das nächste, was ich brauchte, um darüber nachzudenken, war die Bit-Tiefe. Bit-Tiefe ist die Auflösung der Audiodaten. Die meisten Audio in diesen Tagen in 16-Bit, was bedeutet, jede Probe einen von 65536 (2 ^ 16) möglichen Werte haben. 8-Bit-Audio hat nur 256 (2 ^ 8) Schritte der Auflösung und klingt immer noch ziemlich nah an das Original. (Musik, die üblicherweise als "8-bit", wie die Musik in der frühen Nintendo-Spiele bezeichnet wird ist eigentlich 1-Bit-Auflösung, ist diese niedrige Auflösung verleiht ihm seine einzigartigen und sofort erkennbaren Klang, aber ich bin mit dem Ziel für etwas, das klingt wenig mehr organisch).
Wie ich im letzten Schritt, sagte, sind die Rillen auf diese Datensätze seitlich geschnitten. Die folgende Gleichung berechnet den horizontalen Abstand, dass die Nadel zu bewegen, wie es zeichnet die eine Welle von einer gegebenen Bit-Tiefe:
horizontale Verschiebung der Nadel = (2 ^ Bit-Tiefe) * (Präzision der x / y-Achsen)
wobei die Genauigkeit der x und y-Achsen ist 1200 dpi oder etwa 21 Mikrometer. Ich habe dies in der folgenden Tabelle berechnet:
Bit-Tiefe horizontale Verschiebung Schritte Auflösung
2 84um 4
3 168um 8
4 336um 16
5 672um 32
6 1.344mm 64
7 2.688mm 128
8 5.376mm 256
Die fett gedruckten Zeilen in der Tabelle sind die Zahlen, die ich wollte, um mit diesem Projekt zu schießen. Obwohl eine horizontale Verschiebung von etwa 0,5 mm ist recht groß im Vergleich zu einer normalen Aufzeichnung, ich glaube, irgendwo in diesem Bereich werden 3 work.Step: Sine Tests
Wie bei meinem 3D gedruckte Unterlagen, begann ich durch ausgedruckt einigen Sinustests um eine Vorstellung davon, welche Art von Frequenzbereich kann ich erreichen und zu testen, einige Parameter zu erhalten (Laserleistung, Schnittgeschwindigkeit, Material, Wellenamplitude). Ich benutzte Verarbeitung zu sinusförmigen Bahnen zu erzeugen, und schneiden diese ersten Tests auf weiß 3mm Acryl.
Hier ist der Code, den ich verwendet, Verarbeitung:
// Sinustest mit Verarbeitung
importieren processing.pdf. *;
int scaleNum = 72; // Skalierungsfaktor von Vektoren (default 72 dpi)
float theta; // Winkelgröße
schweben thetaIter = 88200 // wie viele Werte von theta pro Zyklus
float Radius; // Variable Radius von Nuten berechnen
Schwimmerdurchmesser = 11,8; // Durchmesser von Rekord in inches
schweben innerHole = 0,286; // Durchmesser von Mittelloch in inches
schweben innerRad = 2,2; // Radius innersten groovein Zoll
schweben outerRad = 5.75; // Radius äußersten Rille in inches
// Speicher für einen bestimmten Punkt in der Nut
schweben radCalc;
schweben xVal;
schweben yval;
float dpi = 1200; // dpi von Schneider
schweben MinDist = 4,0; // min Pixelabstand zwischen den Punkten in Vektorpfad (bis Schneider von freaking out zu verhindern) 0,25919998
schweben xValLast = 0,0;
schweben yValLast = 0,0;
// Parameter zu testen,
float Amplitude [] = {4,6,8}, // in Pixel
int Frequenz [] = {2000,1000,500,250}; // Zyklen pro Umdrehung
Leere setup () {
Größe (12 * scaleNum, 12 * scaleNum);
beginRecord (PDF, "test1.pdf"); // als PDF speichern
Hintergrund (255); // weißem Hintergrund
NOFILL (); // nicht Schleifen füllen
strokeWeight (0,001); // Haarbreite
// Sinuswellen zeichnen
schweben incrNum = TWO_PI / thetaIter; // calculcate inrementation Menge
Radius = outerRad * scaleNum; // berechnen äußersten Radius (5,75 ")
// Skalenpixelabstände
für (byte i = 0; i <3; i ++) {
Amplitude [i] = Amplitude [i] / dpi * scaleNum;
}
MinDist = MinDist / dpi * scaleNum;
Hub (255,0,0); // red
für (byte frequencyi = 0; frequencyi <4; frequencyi ++) {// vier Sinusfrequenzen
für (byte amplitudei = 0; amplitudei <3; amplitudei ++) {// drei seitliche Nut Amplituden
für (byte Kopien = 0; Kopien <1; Kopien ++) {// zwei Kopien
beginShape ();
int NumPoints = 0;
für (theta = 0; theta <TWO_PI; Theta + = incrNum) {// für Theta zwischen 0 und 2pi
// Neue Punkt berechnen
radCalc = Radius + Amplitude [amplitudei] * sin (Frequenz [frequencyi] * theta);
xVal = Breite / 2 + radCalc * cos (theta);
yval = Höhe / 2 + radCalc * sin (theta);
if((((xValLast-xVal)*(xValLast-xVal)+(yValLast-yVal)*(yValLast-yVal))>(minDist*minDist))||(theta==0)){
Vertex (xVal, yval);
// Store letzten Koordinaten in Vektorpfad
xValLast = xVal;
yValLast = yval;
NumPoints ++;
}
}
endShape (CLOSE);
println (NumPoints);
Radius - = 2 * Amplitude [amplitudei] + 0,02 * scaleNum; // trennen jede Kopie
}
Radius - = 0,02 * scaleNum;
}
Radius - = 0,01 * scaleNum;
}
// Ziehen Schnittlinien (100 Einheiten = 1 ")
Schlaganfall (0); in schwarz // zeichnen
Ellipse (Breite / 2, Höhe / 2, innerHole * scaleNum, innerHole * scaleNum); // 0,286 "Mittelloch
Ellipse (Breite / 2, Höhe / 2, Durchmesser * scaleNum, Durchmesser * scaleNum); // 12 "Durchmesser Außenkante
ENDRECORD ();
Ausgang();
// Sagen Sie mir, wenn es vorbei ist
println ("Fertig.");
}
und hier ist ein Video über die Ergebnisse: (Die 139hz Sinuswelle zu niedrig sein, um mit Laptop-Lautsprecher zu hören)
Ich war wirklich glücklich mit diesen ersten Tests. Dies ist etwas Lärm im Hintergrund, aber es ist sehr konstant und das Signal-Rausch-Verhältnis ist ziemlich gut. Amplituden von 4 und 6 hört sich gut über die hier getesteten Frequenzen, wenn die Frequenz höher wird, können Sie eine gute Menge an Verzerrung der Amplitude 8 Welle zu hören.
Verschiedene Laser und Marken der Laserschneider wird anders reagieren, aber diese Platte wurde bei 5000 freq mit 100 Geschwindigkeit geschnitten (auch wenn der Schneidkopf war sehr langsam aufgrund der Dichte der Punkte auf meinem Vektorpfad) und 12 Leistung (genug, um das zu ätzen Oberfläche, aber nicht den ganzen Weg durch) .Schritt 4 geschnitten: Audio Tests auf Acryl
Ich habe eine Tonne von Sinustests für meine 3D-gedruckte Aufzeichnung, aber ich wollte unbedingt in die Audio dafür viel früher so ging ich einfach für sie zu starten. Auch wenn auf einer bestimmten Ebene Ich wusste, dass dies ein bisschen ein Desaster werden, hier ist mein erster Versuch mit Audio:
Der Song ist Love Will Tear Us Apart von Joy Division. Meine Lieblings aller Datensätze I 3D-Druck war definitiv die Joy Division einer (der Song-Störung) , Ich mag die gruselige Atmosphäre die Verzerrung gibt es.
Dieser Laser geschnitten Joy Division Spur ist noch nicht ganz da (wenn auch dezent erkennbar). Sie können eine Menge von Knusprigkeit auf die Trommelschläge zu hören, wenn man genau auf dem Rekord aussehen könnte, würden Sie sehen, dass diese Bereiche der hohen Frequenzen wurden durch den Schneider in Vergessenheit geschmolzen. In diesem Versuch habe ich nicht machen jede Anstrengung, um eine maximale Frequenz der Schnitte gesetzt und die engere Schnitte durch diese Abschnitte benötigt offenbar verursacht der Laser zu lange auf das Material zu verweilen.
Ich habe gelernt, ein paar Dinge über die Laser-Cutter von diesem Versuch. Die ersten paar Versuche, die ich auf dieser Schnitt gemacht verursacht der Laser fast sofort einfrieren. Zuerst dachte ich, ich war eine Überlastung der Maschine mit Daten, aber dann merkte ich, dass die Maschine nicht gerne extrem dichte Vektorpfade zu empfangen. In der Tat fand ich, dass, wenn zwei Punkte auf einer Vektorpfad innerhalb etwa 6 Bildpunkte voneinander, wird der Laser zu beenden. Ich musste mein Code zum Konto für diese zu ändern. Hier ist der Code, den ich verwendet, Verarbeitung:
// Audiotests
// Von Amanda Ghassaei
// Januar 2013
//http://www.instructables.com/id/Laser-Cut-Record/
/ *
* Dieses Programm ist freie Software; es darf weitergegeben und / oder zu modifizieren
* Es unter den Bedingungen der GNU General Public License, wie von veröffentlicht
* Die Free Software Foundation; entweder gemäß Version 3 der Lizenz oder
* (Nach Ihrer Option) jeder späteren Version.
* /
importieren processing.pdf. *;
// Parameter
String filename = "lovewilltearusapart.txt";
float rpm = 33,3;
schweben Samplingrate = 44100;
float dpi = 1200; // dpi von Schneider
float Amplitude = 16; // in Pixel
int Frequenz = 500; // Zyklen pro Umdrehung
float Abstand = 10; // Abstand zwischen Nuten (in Pixel)
schweben MinDist = 6,0; // min Pixelabstand zwischen den Punkten in Vektorpfad (bis Schneider von freaking out zu verhindern) 0,25919998
Schwimmerdurchmesser = 11,8; // Durchmesser von Rekord in inches
schweben innerHole = 0,286; // Durchmesser von Mittelloch in inches
schweben innerRad = 5; // 2.2 // Radius innersten Rille in inches
schweben outerRad = 5.75; // Radius äußersten Rille in inches
boolean cutlines = false;
// Konstanten
schweben secPerMin = 60;
int scaleNum = 72; // Skalierungsfaktor von Vektoren (default 72 dpi)
// Speicher für einen bestimmten Punkt in der Nut
schweben radCalc;
schweben xVal;
schweben yval;
float theta; // Winkelgröße
schweben thetaIter = Abtastrate / 2 * secPerMin / rpm; // wie viele Werte von theta pro Zyklus
float Radius; // Variable Radius von Nuten berechnen
schweben xValLast = 0,0;
schweben yValLast = 0,0;
Leere setup () {
println (thetaIter);
Größe (36 * scaleNum, 24 * scaleNum);
beginRecord (PDF, Dateiname + ".pdf"); // als PDF speichern
Hintergrund (255); // weißem Hintergrund
NOFILL (); // nicht Schleifen füllen
strokeWeight (0,001); // Haarbreite
// Skalenpixelabstände
Amplitude = Amplitude / dpi * scaleNum;
MinDist = MinDist / dpi * scaleNum;
Abstand = Abstand / dpi * scaleNum;
// Sinuswellen zeichnen
schweben incrNum = TWO_PI / thetaIter; // calculcate Winkel inrementation Menge
schweben radIncrNum = (2 * Amplitude + Abstand) / thetaIter; // Radialerhöhungsbetrag
Radius = outerRad * scaleNum; // berechnen äußersten Radius (5,75 ")
Hub (255,0,0); // red
beginShape ();
// // Ziehen still Außennut
// Für (theta = 0; theta <TWO_PI; Theta + = incrNum) {// für Theta zwischen 0 und 2pi
// // Berechnung neuer Punkt
// RadCalc = Radius;
// XVal = Breite / 6 + radCalc * cos (theta);
// Yval = Höhe / 4-radCalc * sin (theta);
// If (((xValLast-xVal) * (xValLast-xVal) + (yValLast-yval) * (yValLast-yval))> (MinDist * MinDist)) {
// Vertex (xVal, yval);
// // Store letzten Koordinaten in Vektorpfad
// XValLast = xVal;
// YValLast = yval;
//}
// Radius - = radIncrNum; // abnehmendem Radius Formen Spirale
//}
float [] = processAudioData Songdata ();
int numGrooves = 0;
int index = 0;
while (Radius> innerRad * scaleNum) {
int NumPoints = 0;
für (theta = 0; theta <TWO_PI; Theta + = incrNum) {// für Theta zwischen 0 und 2pi
// Neue Punkt berechnen
radCalc = Radius + Songdata [index];
Index + = 2;
xVal = Breite / 6 + radCalc * cos (theta);
yval = Höhe / 4-radCalc * sin (theta);
if (((xValLast-xVal) * (xValLast-xVal) + (yValLast-yval) * (yValLast-yval))> (MinDist * MinDist)) {
Vertex (xVal, yval);
// Store letzten Koordinaten in Vektorpfad
xValLast = xVal;
yValLast = yval;
NumPoints ++;
}
Radius - = radIncrNum; // abnehmendem Radius bildet spiral
}
numGrooves ++;
println (numGrooves);
println (NumPoints);
}
endShape ();
if (Schnittlinien) {
// Ziehen Schnittlinien (100 Einheiten = 1 ")
Schlaganfall (0); in schwarz // zeichnen
Ellipse (Breite / 6, Höhe / 4, innerHole * scaleNum, innerHole * scaleNum); // 0,286 "Mittelloch
Ellipse (Breite / 6, Höhe / 4, Durchmesser * scaleNum, Durchmesser * scaleNum); // 12 "Durchmesser Außenkante
}
ENDRECORD ();
Ausgang();
// Sagen Sie mir, wenn es vorbei ist
println ("Fertig.");
}
float [] processAudioData () {
// Erhalten Daten aus der txt-Datei
String rawData [] = loadStrings (filename);
String rawDataString = rawData [0];
schweben audiodata [] = float (split (rawDataString, ',')); // durch Komma getrennt
// Normalisieren Audiodaten gegeben bitdepth
// Erste finden max val
schweben maxval = 0;
for (int i = 0; i <audioData.length; i ++) {
if (abs (audiodata [i])> maxval) {
maxval = abs (audiodata [i]);
}
}
// Normalize Amplitude max val
for (int i = 0; i <audioData.length; i ++) {
audiodata [i] * = Amplitude / maxval;
}
zurück audiodata;
}
Wie bei der 3D-gedruckte Aufzeichnung, zog ich den rohen Audiodaten von der ursprünglichen WAV-Datei mit Python vor, um Verarbeitung zu senden, dass Code finden Sie hier. Und wieder, wenn jemand einen Weg, um diesen Schritt zu umgehen weiß, Sie fühlen sich frei, um einen Kommentar abzugeben, ich würde viel lieber behalten alles in Bearbeitung. In meinem nächsten Test habe ich ein Limit auf der Winkelabstand zwischen aufeinanderfolgenden Punkten, in der Hoffnung, um das Schmelzen des Materials zu minimieren. Hier ist der Code:
if (((xValLast-xVal) * (xValLast-xVal) + (yValLast-yval) * (yValLast-yval))> (MinDist * MinDist) && radCalc * abs (thetaLast-theta)> minAngDist) {
Vertex (xVal, yval);
// Store letzten Koordinaten in Vektorpfad
xValLast = xVal;
yValLast = yval;
thetaLast = theta;
NumPoints ++;
}
... Und das Video:
Der Schnitt kam viel sauberer, und Sie können wesentlich weniger Verzerrungen auf der Audio hören, aber ich dachte, ich könnte es noch besser zu machen. In den nächsten Test ich die Abtastungen pro Umdrehung auf eine konstante Zahl (6000) und entfernt die minimale Winkelabstand Logik von meinem Code.
Bei 6000 Abtastungen pro Zyklus die Abtastfrequenz des Audio ist:
Proben / sec = Proben / U * U / min * min / sec
Proben / sec = 6000 * 45 * 1/60 = 4.5kHz
Hier ist der Code:
// Audiotests
// Von Amanda Ghassaei
// Januar 2013
//http://www.instructables.com/id/Laser-Cut-Record/
/ *
* Dieses Programm ist freie Software; es darf weitergegeben und / oder zu modifizieren
* Es unter den Bedingungen der GNU General Public License, wie von veröffentlicht
* Die Free Software Foundation; entweder gemäß Version 3 der Lizenz oder
* (Nach Ihrer Option) jeder späteren Version.
* /
importieren processing.pdf. *;
// Parameter
String filename = "lovewilltearusapart.txt";
float rpm = 33,3;
schweben Samplingrate = 44100;
float dpi = 1200; // dpi von Schneider
float Amplitude = 16; // in Pixel
float Abstand = 10; // Abstand zwischen Nuten (in Pixel)
schweben MinDist = 6,0; // min Pixelabstand zwischen den Punkten in Vektorpfad (bis Schneider von freaking out zu verhindern) 0,25919998
Schwimmerdurchmesser = 11,8; // Durchmesser von Rekord in inches
schweben innerHole = 0,286; // Durchmesser von Mittelloch in inches
schweben innerRad = 5; // 2.2 // Radius innersten Rille in inches
schweben outerRad = 5.75; // Radius äußersten Rille in inches
boolean cutlines = false; // die inneren und äußeren Umfänge geschnitten
// Konstanten
schweben secPerMin = 60;
int scaleNum = 72; // Skalierungsfaktor von Vektoren (default 72 dpi)
// Speicher für einen bestimmten Punkt in der Nut
schweben radCalc;
schweben xVal;
schweben yval;
float theta; // Winkelgröße
schweben thetaIter = 6000; // wie viele Werte von theta pro Zyklus
float Radius; // Variable Radius von Nuten berechnen
schweben xValLast = 0,0;
schweben yValLast = 0,0;
Leere setup () {
Größe (36 * scaleNum, 24 * scaleNum);
beginRecord (PDF, Dateiname + ".pdf"); // als PDF speichern
Hintergrund (255); // weißem Hintergrund
NOFILL (); // nicht Schleifen füllen
strokeWeight (0,001); // Haarbreite
// Skalenpixelabstände
Amplitude = Amplitude / dpi * scaleNum;
MinDist = MinDist / dpi * scaleNum;
Abstand = Abstand / dpi * scaleNum;
// Sinuswellen zeichnen
schweben incrNum = TWO_PI / thetaIter; // calculcate Winkel inrementation Menge
schweben radIncrNum = (2 * Amplitude + Abstand) / thetaIter; // Radialerhöhungsbetrag
Radius = outerRad * scaleNum; // berechnen äußersten Radius (5,75 ")
Hub (255,0,0); // red
beginShape ();
// // Ziehen still Außennut
// Für (theta = 0; theta <TWO_PI; Theta + = incrNum) {// für Theta zwischen 0 und 2pi
// // Berechnung neuer Punkt
// RadCalc = Radius;
// XVal = Breite / 6 + radCalc * cos (theta);
// Yval = Höhe / 4-radCalc * sin (theta);
// If (((xValLast-xVal) * (xValLast-xVal) + (yValLast-yval) * (yValLast-yval))> (MinDist * MinDist)) {
// Vertex (xVal, yval);
// // Store letzten Koordinaten in Vektorpfad
// XValLast = xVal;
// YValLast = yval;
//}
// Radius - = radIncrNum; // abnehmendem Radius Formen Spirale
//}
float [] = processAudioData Songdata ();
int numGrooves = 0;
int index = 0;
while (Radius> innerRad * scaleNum) {
int NumPoints = 0;
für (theta = 0; theta <TWO_PI; Theta + = incrNum) {// für Theta zwischen 0 und 2pi
// Neue Punkt berechnen
radCalc = Radius + Songdata [index];
Index + = (Samplingrate * secPerMin / rpm) / thetaIter; // vor zur nächsten Stelle in Audiodaten
xVal = Breite / 6 + radCalc * cos (theta);
yval = 3 * Höhe / 4-radCalc * sin (theta);
if (((xValLast-xVal) * (xValLast-xVal) + (yValLast-yval) * (yValLast-yval))> (MinDist * MinDist)) {
Vertex (xVal, yval);
// Store letzten Koordinaten in Vektorpfad
xValLast = xVal;
yValLast = yval;
NumPoints ++;
}
Radius - = radIncrNum; // abnehmendem Radius bildet spiral
}
numGrooves ++;
println (numGrooves);
println (NumPoints);
}
endShape ();
if (Schnittlinien) {
// Ziehen Schnittlinien (100 Einheiten = 1 ")
Schlaganfall (0); in schwarz // zeichnen
Ellipse (Breite / Höhe 6,3 * / 4, innerHole * scaleNum, innerHole * scaleNum); // 0,286 "Mittelloch
Ellipse (Breite / Höhe 6,3 * / 4, Durchmesser * scaleNum, Durchmesser * scaleNum); // 12 "Durchmesser Außenkante
}
ENDRECORD ();
Ausgang();
// Sagen Sie mir, wenn es vorbei ist
println ("Fertig.");
}
float [] processAudioData () {
// Erhalten Daten aus der txt-Datei
String rawData [] = loadStrings (filename);
String rawDataString = rawData [0];
schweben audiodata [] = float (split (rawDataString, ',')); // durch Komma getrennt
// Normalisieren Audiodaten gegeben bitdepth
// Erste finden max val
schweben maxval = 0;
for (int i = 0; i <audioData.length; i ++) {
if (abs (audiodata [i])> maxval) {
maxval = abs (audiodata [i]);
}
}
// Normalize Amplitude max val
for (int i = 0; i <audioData.length; i ++) {
audiodata [i] * = Amplitude / maxval;
}
zurück audiodata;
}
und das Video: Obwohl es ein wenig schwer zu wegen all der Skipping hören, kam der Ausschnitt viel sauberer zu diesem Test. Sie können auch zu hören, dass die Audio-Sounds verlangsamt, war dies ein Rundungs Thema in meinem Code, den ich später behandelt. In meinem nächsten Test verringerte ich die Amplitude der Welle, um 12px zu sehen, ob ich könnte die Nadel in der Rille zu bleiben.
float Amplitude = 12;
Es gibt immer noch ein paar Probleme. Vor allem wird der Datensatz aus dem Schneidvorgang verzogen. Auch die Geschwindigkeit der Audio noch verschraubt. In meinem letzten Version behoben ich die Geschwindigkeit Problem (es war ein Rundungsproblem) und versuchte Taping die Acryl auf dem Bett zu sehen, ob das mit der Schär helfen würde. Die Einstellungen, die ich auf dem Laserschneider verwendet werden, sind:
Lasereinstellungen (Epilog 120W)
100 Geschwindigkeit
5000freq
12 Kraft
In diesem Schnitt habe ich eigentlich die richtige Anwendung RIAA-Entzerrung, wie gut und verwendet einen Anti-Aliasing-Tiefpassfilter der Samplingrate / 2 = 2.25kHz.
Hier ist der endgültige Code:
// Audiotests
// Von Amanda Ghassaei
// Januar 2013
//http://www.instructables.com/id/Laser-Cut-Record/
/ *
* Dieses Programm ist freie Software; es darf weitergegeben und / oder zu modifizieren
* Es unter den Bedingungen der GNU General Public License, wie von veröffentlicht
* Die Free Software Foundation; entweder gemäß Version 3 der Lizenz oder
* (Nach Ihrer Option) jeder späteren Version.
* /
importieren processing.pdf. *;
// Parameter
String filename = "idioteque.txt";
float rpm = 45,0;
schweben Samplingrate = 44100;
float dpi = 1200; // dpi von Schneider
float Amplitude = 10; // in Pixel
float Abstand = 10; // Abstand zwischen Nuten (in Pixel)
schweben MinDist = 6,0; // min Pixelabstand zwischen den Punkten in Vektorpfad (bis Schneider von freaking out zu verhindern) 0,25919998
Schwimmerdurchmesser = 11,8; // Durchmesser von Rekord in inches
schweben innerHole = 0,286; // Durchmesser von Mittelloch in inches
schweben innerRad = 2,2; // 2.2 // Radius innersten Rille in inches
schweben outerRad = 5.75; // Radius äußersten Rille in inches
boolean cutlines = true; // die inneren und äußeren Umfänge geschnitten
// Konstanten
schweben secPerMin = 60;
int scaleNum = 72; // Skalierungsfaktor von Vektoren (default 72 dpi)
// Speicher für einen bestimmten Punkt in der Nut
schweben radCalc;
schweben xVal;
schweben yval;
float theta; // Winkelgröße
schweben thetaIter = 5880; // wie viele Werte von theta pro Zyklus
float Radius; // Variable Radius von Nuten berechnen
schweben xValLast = 0,0;
schweben yValLast = 0,0;
Leere setup () {
Größe (36 * scaleNum, 24 * scaleNum);
beginRecord (PDF, Dateiname + ".pdf"); // als PDF speichern
Hintergrund (255); // weißem Hintergrund
NOFILL (); // nicht Schleifen füllen
strokeWeight (0,001); // Haarbreite
// Skalenpixelabstände
Amplitude = Amplitude / dpi * scaleNum;
MinDist = MinDist / dpi * scaleNum;
Abstand = Abstand / dpi * scaleNum;
// Sinuswellen zeichnen
schweben incrNum = TWO_PI / thetaIter; // calculcate Winkel inrementation Menge
schweben radIncrNum = (2 * Amplitude + Abstand) / thetaIter; // Radialerhöhungsbetrag
Radius = outerRad * scaleNum; // berechnen äußersten Radius (5,75 ")
Hub (255,0,0); // red
beginShape ();
// Zeichne schweigen Außennut
für (theta = 0; theta <TWO_PI; Theta + = incrNum) {// für Theta zwischen 0 und 2pi
// Neue Punkt berechnen
radCalc = Radius;
xVal = Breite / 6 + radCalc * cos (theta);
yval = Höhe / 4-radCalc * sin (theta);
if (((xValLast-xVal) * (xValLast-xVal) + (yValLast-yval) * (yValLast-yval))> (MinDist * MinDist)) {
Vertex (xVal, yval);
// Store letzten Koordinaten in Vektorpfad
xValLast = xVal;
yValLast = yval;
}
Radius - = radIncrNum; // abnehmendem Radius bildet spiral
}
float [] = processAudioData Songdata ();
int numGrooves = 0;
int index = 0;
int indexIncr = int ((Samplingrate * secPerMin / rpm) / thetaIter);
while (Radius> innerRad * scaleNum && Index <songData.length-6000) {
int NumPoints = 0;
für (theta = 0; theta <TWO_PI; Theta + = incrNum) {// für Theta zwischen 0 und 2pi
// Neue Punkt berechnen
radCalc = Radius + Songdata [index];
Index + = indexIncr; // vor zur nächsten Stelle in Audiodaten
xVal = Breite / 6 + radCalc * cos (theta);
yval = Höhe / 4-radCalc * sin (theta);
if (((xValLast-xVal) * (xValLast-xVal) + (yValLast-yval) * (yValLast-yval))> (MinDist * MinDist)) {
Vertex (xVal, yval);
// Store letzten Koordinaten in Vektorpfad
xValLast = xVal;
yValLast = yval;
NumPoints ++;
}
Radius - = radIncrNum; // abnehmendem Radius bildet spiral
}
numGrooves ++;
println (numGrooves);
println (NumPoints);
}
// Zeichne stillen inneren gesperrt Nut
für (theta = 0; theta <TWO_PI; Theta + = incrNum) {// für Theta zwischen 0 und 2pi
// Neue Punkt berechnen
radCalc = Radius;
xVal = Breite / 6 + radCalc * cos (theta);
yval = Höhe / 4-radCalc * sin (theta);
if (((xValLast-xVal) * (xValLast-xVal) + (yValLast-yval) * (yValLast-yval))> (MinDist * MinDist)) {
Vertex (xVal, yval);
// Store letzten Koordinaten in Vektorpfad
xValLast = xVal;
yValLast = yval;
}
Radius - = radIncrNum; // abnehmendem Radius bildet spiral
}
für (theta = 0; theta <TWO_PI; Theta + = incrNum) {// für Theta zwischen 0 und 2pi
// Neue Punkt berechnen
xVal = Breite / 6 + Radius * cos (theta);
yval = Höhe / 4-Radius * sin (theta);
if (((xValLast-xVal) * (xValLast-xVal) + (yValLast-yval) * (yValLast-yval))> (MinDist * MinDist)) {
Vertex (xVal, yval);
// Store letzten Koordinaten in Vektorpfad
xValLast = xVal;
yValLast = yval;
}
}
endShape ();
if (Schnittlinien) {
// Ziehen Schnittlinien (100 Einheiten = 1 ")
Schlaganfall (0); in schwarz // zeichnen
Ellipse (Breite / 6, Höhe / 4, innerHole * scaleNum, innerHole * scaleNum); // 0,286 "Mittelloch
Ellipse (Breite / 6, Höhe / 4, Durchmesser * scaleNum, Durchmesser * scaleNum); // 12 "Durchmesser Außenkante
}
ENDRECORD ();
Ausgang();
// Sagen Sie mir, wenn es vorbei ist
println ("Fertig.");
}
float [] processAudioData () {
// Erhalten Daten aus der txt-Datei
String rawData [] = loadStrings (filename);
String rawDataString = rawData [0];
schweben audiodata [] = float (split (rawDataString, ',')); // durch Komma getrennt
// Normalisieren Audiodaten gegeben bitdepth
// Erste finden max val
schweben maxval = 0;
for (int i = 0; i <audioData.length; i ++) {
if (abs (audiodata [i])> maxval) {
maxval = abs (audiodata [i]);
}
}
// Normalize Amplitude max val
for (int i = 0; i <audioData.length; i ++) {
audiodata [i] * = Amplitude / maxval;
}
zurück audiodata;
}
und das Endprodukt: Es gab noch einige Verwerfungen, aber die Tempo-Fragen werden vollständig gelöst. Es ist interessant zu hören, wie viel die Audioqualität verschlechtert sich von der Außenseite der Scheibe in die Mitte der Scheibe - dies ist aufgrund gesenkt Oberflächengeschwindigkeit der Aufzeichnung, wie Sie in Richtung der Mitte (in Schritt 2 erklärt) zu bewegen.
Schritt 5: Audio Tests auf Papier
Weiter habe ich versucht, dies mit Papier, zuerst habe ich ein Blatt dicker schwarz (fast Karton) Papier. Ich habe den Song rebel rebel wie mein Test.
Die Einstellungen auf der Laser waren wie folgt:
Geschwindigkeit 100
Leistung 4
Frequenz 500
Die resultierenden Datensätze sah toll aus (siehe Bild oben), und man kann sogar den Song kommt durch hören, aber es hatte eine Menge Ärger mit Spring:
So nahm ich ein paar neue Papier, dieses Mal war es viel dicker, fast wie dünnem Karton. Ich habe einige Sinustests und festgestellt, dass die Einstellung der Laserleistung bis 7 war der tiefste ich konnte, ohne durch das Papier. Dann habe ich einen weiteren Test der Rebell Rebell, diesmal bei 7 Macht und mit der Amplitude der Welle schneiden abgesenkt bis 10 (von 12). Die Nadel immer noch nicht in der Nut selbst zu bleiben:
Ich habe auch versucht Defokussieren des Lasers aus dem Papier, um den Schnitt (noch amp 12) zu erweitern. Die innere Schnitt mehr defocused als der äußere, merken, wie die Nadel ist stabiler, aber die Audioqualität geringer.
Da die Defokussierung schien der einzige Weg, um die Nadel in die Rillen zu halten, habe ich versucht, Defokussieren des Lasers durch reproduzierbare Distanzen, um die perfekte Balance zwischen Nadelstabilität und geringe Geräuschentwicklung zu finden. Um diese I überall von 4 bis 16 Stücken von weißem Druckerpapier auf dem Karton platziert, während ich die Laserautofokus lief. Dies bedeutete, dass der Brennpunkt des Lasers wäre eigentlich ein Bruchteil eines Zolls über der Oberfläche des Karton sein. That test is shown below, the outer rings are defocused by 4 sheets, the next 7, 10, 13, and 16 sheets.
I concluded that about 10-12 sheets defocused was the absolute minimum needed to keep the needle stabilized in the groove. Step 6: Audio Tests on Wood
Finally, I cut some records on wood. Eventually I'd like to cut a record on a 12" wood round with a raw edge, kind of like
, you could cut the grooves right onto the rings of the tree. For now I have some nice maple sheet to cut, but I did my firsts tests on ply. I started by using similar settings that I used on the acrylic:
power = 12
speed = 100
freq = 500
amp = 12
This cut looked great, but the needle skipped a lot, I had to hold it in place to shoot this video. I went back and did some sine wave tests and found that 15 power was more stable, so I ran another audio test at 15 power:
This cut was much more stable, but skipping was still an issue, you can also hear the same tempo issues I was having with the acrylic (I was cutting all these records at the same time). Next I tested lowering the amplitude of the cut to 10:
I also tried defocusing the laser to widen the groove, keeping the amplitude at 12. The outer groove is slightly defocused, the inner grove is more heavily defocused:
Both defocusing and lowering the amplitude of the cut helped to minimize skipping, but the defocusing introduced more noise into the audio. For my final plywood test I lowered the amplitude to 10 and kept the laser focused, I also fixed the tempo issue in my code. Here is the result:
Unfortunately at this point I was using the last of our plywood stock, so I couldn't be too picky about how flat the ply was, but it still (surprisingly) plays fine(ish). Here's the code I used:
//audio tests
//by Amanda Ghassaei
//Jan 2013
//http://www.instructables.com/id/Laser-Cut-Record/
/ *
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
* /
import processing.pdf.*;
//parameters
String filename = "radiohead.txt";
float rpm = 45.0;
float samplingRate = 44100;
float dpi = 1200;//dpi of cutter
float amplitude = 10;//in pixels
float spacing = 10;//space between grooves (in pixels)
float minDist = 6.0;//min pixel spacing between points in vector path (to prevent cutter from freaking out) 0.25919998
float diameter = 11.8;//diameter of record in inches
float innerHole = 0.286;//diameter of center hole in inches
float innerRad = 2.2;//radius of innermost groove in inches
float outerRad = 5.75;//radius of outermost groove in inches
boolean cutlines = false;//cut the inner and outer perimeters
//constants
float secPerMin = 60;
int scaleNum = 72;//scale factor of vectors (default 72 dpi)
//storage for a given point in the groove
float radCalc;
float xVal;
float yVal;
float theta;//angle variable
float thetaIter = 5880;//how many values of theta per cycle
float radius;//variable to calculate radius of grooves
float xValLast = 0.0;
float yValLast = 0.0;
void setup(){
size(36*scaleNum,24*scaleNum);
beginRecord(PDF, filename + ".pdf");//save as PDF
background(255);//white background
noFill();//don't fill loops
strokeWeight(0.001);//hairline width
//scale pixel distances
amplitude = amplitude/dpi*scaleNum;
minDist = minDist/dpi*scaleNum;
spacing = spacing/dpi*scaleNum;
//draw sine waves
float incrNum = TWO_PI/thetaIter;//calculcate angular inrementation amount
float radIncrNum = (2*amplitude+spacing)/thetaIter;//radial incrementation amount
radius = outerRad*scaleNum;//calculate outermost radius (at 5.75")
stroke(255,0,0);//red
beginShape();
//draw silent outer groove
for(theta=0;theta<TWO_PI;theta+=incrNum){//for theta between 0 and 2pi
//calculate new point
radCalc = radius;
xVal = width/6+radCalc*cos(theta);
yVal = height/4-radCalc*sin(theta);
if(((xValLast-xVal)*(xValLast-xVal)+(yValLast-yVal)*(yValLast-yVal))>(minDist*minDist)){
vertex(xVal,yVal);
//store last coordinates in vector path
xValLast = xVal;
yValLast = yVal;
}
radius -= radIncrNum;//decreasing radius forms spiral
}
float[] songData = processAudioData();
int numGrooves = 0;
int index = 0;
int indexIncr = int((samplingRate*secPerMin/rpm)/thetaIter);
while(radius>innerRad*scaleNum && index < songData.length-thetaIter*indexIncr){
int numpoints = 0;
for(theta=0;theta<TWO_PI;theta+=incrNum){//for theta between 0 and 2pi
//calculate new point
radCalc = radius+songData[index];
index+=indexIncr;//go to next spot in audio data
xVal = width/6+radCalc*cos(theta);
yVal = height/4-radCalc*sin(theta);
if(((xValLast-xVal)*(xValLast-xVal)+(yValLast-yVal)*(yValLast-yVal))>(minDist*minDist)){
vertex(xVal,yVal);
//store last coordinates in vector path
xValLast = xVal;
yValLast = yVal;
numpoints++;
}
radius -= radIncrNum;//decreasing radius forms spiral
}
numGrooves++;
println(numGrooves);
println(numpoints);
}
//draw silent inner locked groove
for(theta=0;theta<TWO_PI;theta+=incrNum){//for theta between 0 and 2pi
//calculate new point
radCalc = radius;
xVal = width/6+radCalc*cos(theta);
yVal = height/4-radCalc*sin(theta);
if(((xValLast-xVal)*(xValLast-xVal)+(yValLast-yVal)*(yValLast-yVal))>(minDist*minDist)){
vertex(xVal,yVal);
//store last coordinates in vector path
xValLast = xVal;
yValLast = yVal;
}
radius -= radIncrNum;//decreasing radius forms spiral
}
for(theta=0;theta<TWO_PI;theta+=incrNum){//for theta between 0 and 2pi
//calculate new point
xVal = width/6+radius*cos(theta);
yVal = height/4-radius*sin(theta);
if(((xValLast-xVal)*(xValLast-xVal)+(yValLast-yVal)*(yValLast-yVal))>(minDist*minDist)){
vertex(xVal,yVal);
//store last coordinates in vector path
xValLast = xVal;
yValLast = yVal;
}
}
endShape();
if (cutlines){
//draw cut lines (100 units = 1")
stroke(0);//draw in black
ellipse(width/6,height/4,innerHole*scaleNum,innerHole*scaleNum);//0.286" center hole
ellipse(width/6,height/4,diameter*scaleNum,diameter*scaleNum);//12" diameter outer edge
}
endRecord();
exit();
//tell me when it's over
println("Finished.");
}
float[] processAudioData(){
//get data out of txt file
String rawData[] = loadStrings(filename);
String rawDataString = rawData[0];
float audioData[] = float(split(rawDataString,','));//separated by commas
//normalize audio data to given bitdepth
//first find max val
float maxval = 0;
for(int i=0;i<audioData.length;i++){
if (abs(audioData[i])>maxval){
maxval = abs(audioData[i]);
}
}
//normalize amplitude to max val
for(int i=0;i<audioData.length;i++){
audioData[i]*=amplitude/maxval;
}
return audioData;
}
Next I used the maple. Fortunately, noahw helped me track down a 13" wide curly maple board and cut it into a two flat sheets: one was about the thickness of a real vinyl record at about 1/16" and other a little thicker at 1/8". I sanded the maple sheets to about 1500grit and finished them before cutting. I did a few tests on a piece of scrap and found that the power setting I was using on the ply was cutting so deeply into the maple that I would not be able to cut both sides. I did a few more experiments with defocusing and actually did a full attempt using the song sunday morning by the velvet underground : In this test I defocused the laser by the width of 11 sheets of normal printer paper. I used the following laser settings:
power = 4
speed = 100
freq = 500
amp = 10
This cut came out a little noiser than I was hoping. Since the needle wasn't having any issues staying in the groove, I defocused by only 9 sheets of paper and kept the same power settings. On the other side of the sunday morning disc, I cut femme fatale :
While I was adjusting some tape to try to keep the wood lying flat in the middle of the cut, I accidentally bumped it to the side slightly. If you look closely at the video, you'll see where the error is, it caused the needle to skip a groove, but other than that the cut came out great.
This song helped me pin down an error in my code, if you listen closely during the chorus, you'll notice that the backing vocals are missing. When I looked back at the song, I noticed that the vocals are only found in the left channel of the track, so it seems that I was not combining the two channels before converting to a vector file. I think I've fixed the problem in my python script, but I'll have to run a test to know for sure. In the meantime, you can work around this problem by importing your stereo audio into Audacity, right clicking on the track and selecting "split stereo to mono", saving the file as a wav, opening that saved file in Audacity again, copying the track, and right clicking on each of the duplicate tracks to set one to left channel and one to right channel.Step 7: Make Your Own
You can convert your own audio files into vector cutting paths in ten easy steps:
1. Download Processing .
2. Download Python 2.5.4 .
3. Download Audacity .
4. Download the code from GitHub (you can download the zip file by clicking on the cloud button). Unzip and open the folder called LaserCutRecord.
5. Open an audio file of your choice with Audacity. Go to Effect>Equalization and select RIAA. Hit inverse and apply, you should now hear the higher frequencies of your track boosted.
6. Go to Effect>Low Pass Filter... and apply an anti-aliasing filter (a fancy word for a low pass filter) to your audio. You will have to choose the cutoff frequency according to the max sampling rate that you can get with your cutter. For example, my laser cutter melts anything above 2.5kHz at 45rpm, so I set my anti-aliasing filter cutoff to this same frequency. Set the drop off as high as possible, for me this was 48dB/octave, that way the filter will have a hard cutoff.
7. Use Effect>Amplify to amplify the signal as much as you can without noticeable effects of clipping (you will be able to get away with some clipping, and remember this is not crystal clear audio anyway). You may also want to mess around with Effect>>Compressor.
8. Make sure there are 2 sec of blank audio at the end of the track so that nothing gets clipped and keep the audio under 3:10. File>Export this file and save it in the "LaserCutRecord" folder as a wav file.
9. Open the Python file called "wavtotxt". Copy the file name of the file you just saved in the line:
fileName = "your_file_name_here.wav"
Hit Run>RunModule, after a minute or two you will have a .txt file saved in the Record Generator folder.
10. Open the Processing sketch. Change the name of the import file in the Processing sketch to your txt file name:
String filename = "your_file_name_here.txt";
Run the Processing sketch Sketch>Run. The Processing sketch will output several files, none larger than 700KB (I found that larger files were crashing the laser cutter). The last file will also contain the cut paths for the inner hole and outer edge of the record, you will need to set your laser cutter to cut these lines at a higher power, so that it cuts all the way through the material. Another very important note about cutting these files - the reason I had to split each song up into five parts is because I found that files larger than 800KB would crash my laser. When you are cutting out the sequential files, you MUST shut down the laser for a second to clear it's memory and then turn it back on before sending it a new 700KB file to cut, you will have problems if you forget this.
Once you've made cutting files, post them! You can upload files in the comments by clicking on "Rich Editor." Enjoy, and let me know if you have questions or need help getting this to work. I've tested this process Mac OS using the latest version of Processing. If you actually end up cutting your own record, please post the results in the comments, I'm really curious to see where this code ends up!
In case you are stuck trying to find a machine to cut your files, check this list of worldwide hackerspaces , these are places where anyone can go for little to no money and use tools in a collaborative work environment. If you are in school, you might ask the engineering or art departments if they have a machine than can cut vector files. Otherwise, I'd recommend checking out an online fabrication service such as Ponoko . Some people even build their own laser cutters, there are many builds documented right here on Instructables, we're even giving one away in our Epilog Challenge.
