Ein 3D-gedrucktes Eierboot für nur 15 US-Dollar. Rezept kochen

Published on April 18, 2017

Ein 3D-gedrucktes Eierboot für nur 15 US-Dollar. Rezept kochen

    Hallo an alle!

    Bild

    Ostern endet und das Thema des Druckens verschiedener Muster auf den Eiern wird ein wenig weniger relevant, aber dies macht den Eierstiefel nicht unwichtiger, für alle notwendig und immer das ganze Jahr hindurch :)

    Für diejenigen, die kein Eierboot kennen, ist dies eine Maschine, die auf jeden Kugelmarker zeichnen kann Objekte: Eier, Tennisbälle, Weihnachtsschmuck. Das Konzept des Mechanismus wurde im fernen 1990er Jahre von dem Designer Bruce Shapiro erfunden . Vor nicht allzu langer Zeit veröffentlichte die berühmte Firma Evil Mad Scientist Laboratories eine Version mit dem Namen The EggBot. Wir müssen Evil Mad Scientist Laboratories Tribut zollen, das sein Projekt geöffnet hatte und es Ihnen ermöglicht, die Software für andere Eierarbeiten zu verwenden, selbst in kommerziellen Projekten.

    Dies sind die Kunstwerke, die am Ausgang erhalten wurden:

    Bild


    Einfache Bilder können in einem beliebigen Vektoreditor gezeichnet werden, und komplexe geometrische Objekte können zum Beispiel auf Python erstellt werden.

    Hier ist ein Beispiel für ein solches Programm:
    # Generate a 3200 x 800 geometrical pattern for Eggbot plotting
    # See http://www.egg-bot.com/ for info on the Eggbot
    #
    # Dan Newman, 2 January 2011
    # dan dot newman at mtbaldy dot us
    # Public domain (http://creativecommons.org/licenses/publicdomain/)
    HEIGHT = float( 800.0 )
    WIDTH = float( 3200.0 )
    scale = WIDTH / ( 16.0 * 3 )  # 16 horizontal repeats
    epsilon = float(1.0e-5)
    # Relative moves for drawing the vertical elements
    DOWN  = [[0.0, scale], [scale, 2*scale], [0.0, scale], [-scale, 2*scale]]
    UP    = [[0.0, -scale], [scale, -2*scale], [0.0, -scale], [-scale, -2*scale]]
    # How to switch to going up when you stop going down after DOWN[i]
    DU_switch = [scale, -scale, -scale, scale]
    # Relative moves for drawing the horizontal elements (L2R = left-to-right)
    L2R = [[scale, 0.0], [2*scale, scale], [scale, 0.0], [2*scale, -scale]]
    R2L = [[-scale, 0.0], [-2*scale, scale], [-scale, 0.0], [-2*scale, -scale]]
    # How to switch to R2L after stopping in L2R at index i
    LR_switch = [scale, -scale, -scale, scale]
    # Compute the intersection of two lines
    # See eggbot_hatch.py for complete details
    def intersect( P1, P2, P3, P4 ):
    	'''
    	Determine if two line segments defined by the four points P1 & P2 and
    	P3 & P4 intersect.  If they do intersect, then return the fractional
    	point of intersection "sa" along the first line at which the
    	intersection occurs.
    	'''
    	# Precompute these values -- note that we're basically shifting from
    	#
    	#		P = P1 + s (P2 - P1)
    	#
    	# to
    	#
    	# 		P = P1 + s D
    	#
    	# where D is a direction vector.  The solution remains the same of
    	# course.  We'll just be computing D once for each line rather than
    	# computing it a couple of times.
    	D21x = P2[0] - P1[0]
    	D21y = P2[1] - P1[1]
    	D43x = P4[0] - P3[0]
    	D43y = P4[1] - P3[1]
    	# Denominator
    	d = D21x * D43y - D21y * D43x
    	# Return now if the denominator is zero
    	if d == 0:
    		return float( -1 )
    	# For our purposes, the first line segment given
    	# by P1 & P2 is the LONG hatch line running through
    	# the entire drawing.  And, P3 & P4 describe the
    	# usually much shorter line segment from a polygon.
    	# As such, we compute sb first as it's more likely
    	# to indicate "no intersection".  That is, sa is
    	# more likely to indicate an intersection with a
    	# much a long line containing P3 & P4.
    	nb = ( P1[1] - P3[1] ) * D21x - ( P1[0] - P3[0] ) * D21y
    	# Could first check if abs(nb) > abs(d) or if
    	# the signs differ.
    	sb = float( nb ) / float( d )
    	if ( sb < 0 ) or ( sb > 1 ):
    		return float( -1 )
    	na = ( P1[1] - P3[1] ) * D43x -  ( P1[0] - P3[0] ) * D43y
    	sa = float( na ) / float( d )
    	if ( sa < 0 ) or ( sa > 1 ):
    		return float( -1 )
    	return sa
    # Determine whether a line segment needs to be clipped to
    # fit within the drawing page
    def clip( x1, y1, x2, y2 ):
    	if ( x1 >= 0.0 ) and ( x1 <= WIDTH ) and ( x2 >= 0.0 ) and ( x2 <= WIDTH ) and \
    			( y1 >= 0.0 ) and ( y1 <= HEIGHT ) and ( y2 >= 0.0 ) and ( y2 <= HEIGHT ):
    		return float( -1.0 )
    	if ( x1 < 0.0 ) or ( x2 < 0.0 ):
    		s = intersect( [x1, y1], [x2, y2], [0.0, 0.0], [0.0, HEIGHT] )
    		if ( s > 0.0 ):
    			return s
    	if ( x1 > WIDTH ) or ( x2 > WIDTH ):
    		# We allow going an extra pixel across in case there is drawing error
    		s = intersect( [x1, y1], [x2, y2], [WIDTH+1.0, 0.0], [WIDTH+1.0, HEIGHT] )
    		if ( s > 0.0 ):
    			return s
    	if ( y1 < 0.0 ) or ( y2 < 0.0 ):
    		s = intersect( [x1, y1], [x2, y2], [0.0, 0.0], [WIDTH, 0.0] )
    		if ( s > 0.0 ):
    			return s
    	if ( y1 > HEIGHT ) or ( y2 > HEIGHT ):
    		s = intersect( [x1, y1], [x2, y2], [0.0, HEIGHT], [WIDTH, HEIGHT] )
    		if ( s > 0.0 ):
    			return s
    	return float( -1.0 )
    # Plot a collection of line segments
    def plot( points, color='black' ):
    	# First line segment
    	s = clip( points[0][0], points[0][1], points[1][0], points[1][1] )
    	if ( s < 0.0 ):
    		p = 'M %f,%f' % ( points[0][0], points[0][1] )
    	else:
    		p = 'M %f,%f' % ( points[0][0] + s * ( points[1][0] - points[0][0] ),
    						  points[0][1] + s * ( points[1][1] - points[0][1] ) )
    	x0 = points[1][0]
    	y0 = points[1][1]
    	p += ' L %f,%f' % ( x0, y0 )
    	# Intermediate line segments
    	for i in range(2, len( points ) - 1):
    		x0 = points[i][0]
    		y0 = points[i][1]
    		p += ' L %f,%f' % ( x0, y0 )
    	# Final line segment
    	x = points[-1][0]
    	y = points[-1][1]
    	s = clip( x0, y0, x, y )
    	if ( s < 0.0 ):
    		p += ' L %f,%f' % ( x, y )
    	else:
    		p += ' L %f,%f' % ( x0 + s * ( x - x0 ), y0 + s * ( y - y0 ) )
    	print '<path stroke="%s" stroke-width="1" fill="none" d="%s"/>' % ( color, p )
    # Draw the vertical elements
    def vertical( x, y, color, down, up ):
    	if ( y > ( scale + epsilon ) ):
    		i = len( down ) - 1
    		while ( y > ( scale + epsilon) ):
    			x -= down[i][0]
    			y -= down[i][1]
    			i -= 1
    			if ( i < 0 ):
    				i = len( down ) - 1
    	else:
    		i = -1
    	points = [[x, y]]
    	while ( y < ( HEIGHT - epsilon ) ):
    		i += 1
    		if ( i >= len( down ) ):
    			i = 0
    		x += down[i][0]
    		y += down[i][1]
    		points.append( [x, y] )
    	plot( points, color )
    	x += DU_switch[i]
    	points = [[x, y]]
    	while ( y > epsilon ):
    		x += up[i][0]
    		y += up[i][1]
    		points.append( [x, y] )
    		i -= 1
    		if ( i < 0 ):
    			i = len( up ) - 1
    	plot( points, color )
    # Draw the horizontal elements
    def horizontal( x, y, color, l2r, r2l ):
    	if ( x > ( scale + epsilon ) ):
    		i = len( l2r ) - 1
    		while ( x > ( scale + epsilon ) ):
    			x -= l2r[i][0]
    			y -= l2r[i][1]
    			i -= 1
    			if ( i < 0 ):
    				i = len( l2r ) - 1
    	else:
    		i = -1
    	points = [[x, y]]
    	while ( x < ( WIDTH - epsilon ) ):
    		i += 1
    		if ( i >= len( l2r ) ):
    			i = 0
    		x += l2r[i][0]
    		y += l2r[i][1]
    		points.append( [x, y] )
    	plot( points, color )
    	y += LR_switch[i]
    	points = [[x, y]]
    	while ( x > epsilon ):
    		x += r2l[i][0]
    		y += r2l[i][1]
    		points.append( [x, y] )
    		i -= 1
    		if ( i < 0 ):
    			i = len( r2l ) - 1
    	plot( points, color )
    print '<svg xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape" width="%d" height="%d">' % ( int( WIDTH ), int( HEIGHT ) )
    print '<g inkscape:groupmode="layer" inkscape:label="1 - vertical">'
    Color = 'green'
    x1 = 0.0
    y1 = 0.0
    x2 = 1.5 * scale
    y2 = 1.5 * scale
    while ( x1 < ( WIDTH - epsilon ) ):
    	vertical( x1, y1, 'green', DOWN, UP )
    	if ( x2 < ( WIDTH - epsilon ) ):
    		vertical( x2, y2, 'green', DOWN, UP )
    	x1 += 3 * scale
    	x2 += 3 * scale
    print '</g>'
    print '<g inkscape:groupmode="layer" inkscape:label="2 - horizontal">'
    x1 = 0.0
    y1 = 0.0
    x2 = 1.5 * scale
    y2 = 1.5 * scale
    while ( y1 < ( HEIGHT - epsilon ) ):
    	horizontal( x1, y1, 'blue', L2R, R2L)
    	if ( y2 < ( HEIGHT - epsilon ) ):
    		horizontal( x2, y2, 'blue', L2R, R2L)
    	y1 += 3 * scale
    	y2 += 3 * scale
    print '</g>'
    print '<g inkscape:groupmode="layer" inkscape:label="3 - border">'
    print '<path stroke="black" stroke-width="1" fill="none" d="M 0,0 l %d,0"/>' % ( int( WIDTH ) )
    print '<path stroke="black" stroke-width="1" fill="none" d="M 0,%d l %d,0"/>' % ( int( HEIGHT ), int( WIDTH ) )
    print '</g>'
    print '</svg>'


    Aber das Ergebnis ist bereits auf dem Ei:

    Bild


    Enthusiasten erzeugen während der Rotation gleichmäßige Bilder mit stroboskopischem Effekt:



    Beim Erstellen meines Eierboots habe ich mir nicht das Ziel gesetzt, $ 15 zu erreichen, aber das ist, was passiert ist :). Zum Vergleich: Der Original Eggbot Pro kostet 325 Dollar, was eine Größenordnung teurer ist. Die Hauptkosten eines Eierboots - Schrittmotoren. Ich habe das günstigste Modell verwendet - 28BYJ-48-12V, daher das endgültige Preisschild von 15 Dollar.

    Für die Vorbereitung meiner Eierarbeit benötigen Sie:

    1. 110 Gramm ABS- oder PLA-Kunststoff. Ich habe die schwarzen Teile mit ABS, dem gelben PLA, bedruckt. PLA ist schmerzlich schön beim Drucken auf Glas :)
    2. Elektronik auf Lager:

    • 1 x Chinesisches Arduino UNO c Aliexpress mit einem Kabel für einen Computer für 250 reiben.
    • 2 x 28BYJ-48-12V Schrittmotor + ULN2003 Schrittmotortreiber für 100 Unebenheiten.
    • 1 x SG90 Mikroservomotor 100 reiben.
    • 1 x 12V Netzteil (kann nicht gekauft werden, wenn vorhanden).

    3. Was wir nicht drucken können, aber wir können in fast jedem Baumarkt kaufen:

    • Frühling.
    • Bolzen, Schrauben, Muttern, Unterlegscheiben.
    • Gummidichtung (kann bei Flex gedruckt werden).
    • Lager 608.

    Wir legen den Kunststoff in den 3D-Drucker und bedrucken die Teile, deren Modelle ich sorgfältig hier abgelegt habe .

    Details darüber, was und wie viel gedruckt werden soll, wo genau die Elektronik zu finden ist, wie viel und welche Schrauben Sie hier suchen müssen .

    Diejenigen, die noch keinen 3D-Drucker gekauft haben, aber ihre Eier wirklich kochen möchten, kann ich alle Details ausdrucken und per Post senden. Ein persönlicher Kontakt, alles wird am besten! Ich garantiere es!

    Nach dem Drucken können Sie mit der Montage fortfahren. Die Montage des Geräts sieht folgendermaßen aus:

    Bild

    Damit Sie Erfolg haben, habe ich viel Zeit investiert und Anweisungen zum Zusammenbauen und Anschließen der Elektronik in Bildern vorbereitet. Anleitung hier herunterladen .

    Nach dem Drucken und Zusammenbau sollten Sie über ein solches Gerät verfügen:

    Bild

    Nach Abschluss des Zusammenbaus müssen Sie die Firmware in das Eierboot legen. Da das Gehirn des Geräts das übliche Arduino ist, sollten Sie keine Probleme damit haben.

    1. Laden Sie die Firmware hier herunter und entpacken Sie sie .
    2. Wir laden Arduino IDE , installieren und starten.
    3. Wir verbinden das eggboot mit dem Computer und wählen das Board-Modell und den COM-Port in der Arduino IDE aus.
    4. Öffnen Sie die Datei Eggduino.ino aus dem Ordner mit der Firmware und laden Sie sie in den Arduino.

    Inkscape mit einem Plugin, das von Evil Mad Scientist Laboratories geschrieben wurde, wird als Kontrollprogramm verwendet. Mit dem Plugin können Sie eggboot anpassen, manuell verwalten und Bilder zum Drucken senden. Ich habe das Plugin vorsichtig zu Inkscape hinzugefügt und das fertige Archiv hier platziert .

    Wenn Sie bereits Inkscape haben, es aber kein Plug-In gibt, können Sie es hier separat verwenden .

    Laden Sie Inkscape herunter, installieren Sie es und führen Sie es aus. Gehen Sie in das Menü mit Plugins und suchen Sie dort nach dem EggBot-Untermenü. Öffnen Sie das Plugin, stellen Sie die Höhe des Stiftes ein und heben Sie die Markierung auf dem Ei an.

    Wenn Sie beim Versuch, einen Bot zu steuern, über Inkscape verfügen, wird der Fehler "Verbindung mit EggBot fehlgeschlagen" angezeigt. Verzweifeln Sie nicht. Das Problem kann leicht gelöst werden. Schauen Sie in der Liste der angeschlossenen Geräte nach, wie ist der Name Ihrer Karte. Ersetzen Sie dann in der Datei ebb_serial.py des Plug-Ins für Inkscape in Zeile 52 den Text „USB-SERIAL CH340“ durch Ihren Namen.

    Ich habe auch eine kleine Sammlung mit Beispielen gesammelt und angelegt. Sie können es hier sehen .

    Als Ergebnis sollte das eggboot so funktionieren:


    Ich habe mein Projekt auf Githab gepostet . Gabel, Sternchen setzen, ändern und so weiter. Ich habe über thingiverse.com auch nicht vergessen .

    Vielen Dank für Ihre Aufmerksamkeit!