import serial
import time

class Printer3D:
    def __init__(self, port='/dev/ttyUSB0', baudrate=115200):
        """
        3D 프린터 연결 초기화
        port: 시리얼 포트 (Windows: COM3, Linux: /dev/ttyUSB0)
        baudrate: 통신 속도 (보통 115200 또는 250000)
        """
        self.ser = serial.Serial(port, baudrate, timeout=1)
        time.sleep(2)  # 연결 안정화 대기
        print(f"프린터 연결됨: {port}")
        
    def send_gcode(self, command):
        """G-code 명령 전송"""
        self.ser.write(f"{command}\n".encode())
        time.sleep(0.1)
        
        # 응답 읽기
        response = self.ser.readline().decode().strip()
        print(f"전송: {command} | 응답: {response}")
        return response
    
    def wait_for_ok(self):
        """프린터의 'ok' 응답 대기"""
        while True:
            response = self.ser.readline().decode().strip()
            if 'ok' in response.lower():
                return True
            time.sleep(0.1)
    
    def close(self):
        """연결 종료"""
        self.ser.close()
        print("프린터 연결 종료")

# 사용 예제
printer = Printer3D('/dev/ttyUSB0', 115200)
printer.send_gcode('G28')  # 홈 포지션으로 이동
printer.wait_for_ok()
printer.close()

class PrinterController(Printer3D):
    def __init__(self, port, baudrate=115200):
        super().__init__(port, baudrate)
        self.current_pos = {'X': 0, 'Y': 0, 'Z': 0}
        
    def home_all(self):
        """모든 축 홈 포지션으로"""
        print("🏠 홈 포지션으로 이동 중...")
        self.send_gcode('G28')
        self.wait_for_ok()
        self.current_pos = {'X': 0, 'Y': 0, 'Z': 0}
        
    def set_temperature(self, nozzle_temp, bed_temp=0):
        """온도 설정"""
        print(f"🔥 노즐 온도: {nozzle_temp}°C, 베드 온도: {bed_temp}°C")
        self.send_gcode(f'M104 S{nozzle_temp}')  # 노즐 온도 설정
        if bed_temp > 0:
            self.send_gcode(f'M140 S{bed_temp}')  # 베드 온도 설정
        
    def wait_temperature(self, nozzle_temp):
        """목표 온도 도달 대기"""
        print(f"⏳ 온도 도달 대기 중...")
        self.send_gcode(f'M109 S{nozzle_temp}')
        self.wait_for_ok()
        
    def move_to(self, x=None, y=None, z=None, speed=1500):
        """지정 위치로 이동"""
        command = 'G1'
        if x is not None:
            command += f' X{x}'
            self.current_pos['X'] = x
        if y is not None:
            command += f' Y{y}'
            self.current_pos['Y'] = y
        if z is not None:
            command += f' Z{z}'
            self.current_pos['Z'] = z
        command += f' F{speed}'
        
        self.send_gcode(command)
        
    def extrude(self, amount, speed=300):
        """필라멘트 압출"""
        self.send_gcode(f'G1 E{amount} F{speed}')
        
    def draw_square(self, size=50, z_height=0.2):
        """정사각형 그리기"""
        print(f"📐 {size}mm 정사각형 그리는 중...")
        
        # 시작 위치로 이동
        self.move_to(x=10, y=10, z=z_height)
        self.wait_for_ok()
        
        # 정사각형 그리기
        positions = [
            (10 + size, 10),
            (10 + size, 10 + size),
            (10, 10 + size),
            (10, 10)
        ]
        
        for x, y in positions:
            self.move_to(x=x, y=y)
            self.extrude(5)  # 이동하면서 필라멘트 압출
            self.wait_for_ok()
            
        print("✅ 정사각형 완성!")

# 실제 사용
controller = PrinterController('/dev/ttyUSB0')

# 초기화
controller.home_all()
controller.set_temperature(nozzle_temp=200, bed_temp=60)
controller.wait_temperature(200)

# 정사각형 그리기
controller.draw_square(size=50, z_height=0.2)

# 종료
controller.move_to(z=50)  # Z축 올리기
controller.send_gcode('M104 S0')  # 노즐 히터 끄기
controller.send_gcode('M140 S0')  # 베드 히터 끄기
controller.close()

import math

class GCodeGenerator:
    def __init__(self, filename='output.gcode'):
        self.filename = filename
        self.gcode_lines = []
        self.current_e = 0  # 현재 압출 위치
        
    def add_comment(self, comment):
        """주석 추가"""
        self.gcode_lines.append(f'; {comment}')
        
    def add_command(self, command):
        """G-code 명령 추가"""
        self.gcode_lines.append(command)
        
    def start_print(self, nozzle_temp=200, bed_temp=60):
        """프린트 시작 설정"""
        self.add_comment('=== 프린트 시작 ===')
        self.add_command('G28')  # 홈
        self.add_command('G92 E0')  # 압출기 리셋
        self.add_command(f'M104 S{nozzle_temp}')  # 노즐 온도
        self.add_command(f'M140 S{bed_temp}')  # 베드 온도
        self.add_command(f'M109 S{nozzle_temp}')  # 온도 대기
        self.add_command(f'M190 S{bed_temp}')
        self.add_command('G1 Z2.0 F3000')  # Z축 올리기
        self.add_comment('프라임 라인 그리기')
        self.add_command('G1 X10 Y10 Z0.3 F5000')
        self.add_command('G1 X100 Y10 E10 F1500')
        self.add_command('G92 E0')
        self.add_comment('')
        
    def end_print(self):
        """프린트 종료 설정"""
        self.add_comment('=== 프린트 종료 ===')
        self.add_command('G91')  # 상대 좌표
        self.add_command('G1 E-2 F2700')  # 리트랙션
        self.add_command('G1 Z10 F3000')  # Z축 올리기
        self.add_command('G90')  # 절대 좌표
        self.add_command('G1 X0 Y200 F3000')  # 앞으로 이동
        self.add_command('M104 S0')  # 노즐 히터 끄기
        self.add_command('M140 S0')  # 베드 히터 끄기
        self.add_command('M84')  # 모터 끄기
        
    def move_to(self, x, y, z=None, speed=3000, extrude=False):
        """위치로 이동"""
        command = 'G1'
        command += f' X{x:.3f} Y{y:.3f}'
        if z is not None:
            command += f' Z{z:.3f}'
        
        if extrude:
            # 이동 거리 계산
            distance = math.sqrt(x**2 + y**2)
            extrusion = distance * 0.1  # 간단한 압출량 계산
            self.current_e += extrusion
            command += f' E{self.current_e:.5f}'
            
        command += f' F{speed}'
        self.add_command(command)
        
    def draw_circle(self, center_x, center_y, radius, z_height=0.2, segments=36):
        """원 그리기"""
        self.add_comment(f'원 그리기: 중심({center_x}, {center_y}), 반지름 {radius}mm')
        
        for i in range(segments + 1):
            angle = (2 * math.pi * i) / segments
            x = center_x + radius * math.cos(angle)
            y = center_y + radius * math.sin(angle)
            
            if i == 0:
                self.move_to(x, y, z_height, extrude=False)
            else:
                self.move_to(x, y, extrude=True)
                
    def draw_rectangle(self, x, y, width, height, z_height=0.2):
        """직사각형 그리기"""
        self.add_comment(f'직사각형 그리기: ({x}, {y}), {width}x{height}mm')
        
        corners = [
            (x, y),
            (x + width, y),
            (x + width, y + height),
            (x, y + height),
            (x, y)
        ]
        
        for i, (px, py) in enumerate(corners):
            if i == 0:
                self.move_to(px, py, z_height, extrude=False)
            else:
                self.move_to(px, py, extrude=True)
                
    def draw_star(self, center_x, center_y, outer_radius, inner_radius, 
                  points=5, z_height=0.2):
        """별 그리기"""
        self.add_comment(f'{points}각 별 그리기: 중심({center_x}, {center_y})')
        
        for i in range(points * 2 + 1):
            angle = (2 * math.pi * i) / (points * 2) - math.pi / 2
            radius = outer_radius if i % 2 == 0 else inner_radius
            x = center_x + radius * math.cos(angle)
            y = center_y + radius * math.sin(angle)
            
            if i == 0:
                self.move_to(x, y, z_height, extrude=False)
            else:
                self.move_to(x, y, extrude=True)
                
    def draw_spiral(self, center_x, center_y, start_radius, end_radius, 
                    turns=3, z_height=0.2, segments=100):
        """나선 그리기"""
        self.add_comment(f'나선 그리기: {turns}회전')
        
        for i in range(segments + 1):
            progress = i / segments
            angle = 2 * math.pi * turns * progress
            radius = start_radius + (end_radius - start_radius) * progress
            x = center_x + radius * math.cos(angle)
            y = center_y + radius * math.sin(angle)
            
            if i == 0:
                self.move_to(x, y, z_height, extrude=False)
            else:
                self.move_to(x, y, extrude=True)
                
    def save(self):
        """G-code 파일로 저장"""
        with open(self.filename, 'w') as f:
            f.write('\n'.join(self.gcode_lines))
        print(f'✅ G-code 저장 완료: {self.filename}')
        print(f'📊 총 {len(self.gcode_lines)}줄 생성됨')

# 사용 예제
generator = GCodeGenerator('pattern.gcode')

# 프린트 시작
generator.start_print(nozzle_temp=200, bed_temp=60)

# 다양한 도형 그리기
generator.draw_rectangle(20, 20, 40, 30, z_height=0.2)
generator.draw_circle(100, 50, 20, z_height=0.2)
generator.draw_star(150, 50, 25, 12, points=5, z_height=0.2)
generator.draw_spiral(100, 120, 5, 30, turns=5, z_height=0.2)

# 프린트 종료
generator.end_print()

# 파일 저장
generator.save()

from flask import Flask, render_template, request, jsonify
import serial
import threading
import time

app = Flask(__name__)

class WebPrinterController:
    def __init__(self, port='/dev/ttyUSB0', baudrate=115200):
        self.port = port
        self.baudrate = baudrate
        self.ser = None
        self.is_connected = False
        self.status = {
            'temperature': {'nozzle': 0, 'bed': 0},
            'position': {'x': 0, 'y': 0, 'z': 0},
            'state': 'idle'
        }
        self.lock = threading.Lock()
        
    def connect(self):
        """프린터 연결"""
        try:
            self.ser = serial.Serial(self.port, self.baudrate, timeout=1)
            time.sleep(2)
            self.is_connected = True
            # 상태 모니터링 스레드 시작
            threading.Thread(target=self._monitor_status, daemon=True).start()
            return True
        except Exception as e:
            print(f"연결 실패: {e}")
            return False
            
    def disconnect(self):
        """연결 종료"""
        if self.ser:
            self.ser.close()
            self.is_connected = False
            
    def send_command(self, command):
        """명령 전송"""
        if not self.is_connected:
            return {'success': False, 'message': '프린터가 연결되지 않았습니다'}
            
        try:
            with self.lock:
                self.ser.write(f"{command}\n".encode())
                time.sleep(0.1)
                response = self.ser.readline().decode().strip()
                return {'success': True, 'response': response}
        except Exception as e:
            return {'success': False, 'message': str(e)}
            
    def _monitor_status(self):
        """상태 모니터링 (백그라운드)"""
        while self.is_connected:
            try:
                # 온도 확인
                self.send_command('M105')
                # 위치 확인
                self.send_command('M114')
                time.sleep(2)
            except:
                pass
                
    def home(self, axes=''):
        """홈 포지션"""
        command = f'G28 {axes}'
        return self.send_command(command)
        
    def move(self, x=None, y=None, z=None, speed=3000):
        """이동"""
        command = 'G1'
        if x is not None:
            command += f' X{x}'
        if y is not None:
            command += f' Y{y}'
        if z is not None:
            command += f' Z{z}'
        command += f' F{speed}'
        return self.send_command(command)
        
    def set_temperature(self, nozzle=None, bed=None):
        """온도 설정"""
        results = []
        if nozzle is not None:
            results.append(self.send_command(f'M104 S{nozzle}'))
        if bed is not None:
            results.append(self.send_command(f'M140 S{bed}'))
        return results

# 전역 컨트롤러 인스턴스
controller = WebPrinterController()

@app.route('/')
def index():
    """메인 페이지"""
    return '''
    
    
    
        <title>3D Printer Web Control</title>
        <meta name="viewport" content="width=device-width, initial-scale=1">
       
    
        <h1>🖨️ 3D Printer Web Control</h1>
        
        <div class="control-panel">
            <h2>연결 관리</h2>
            <button class="button" onclick="connect()">연결</button>
            <button class="button" onclick="disconnect()">연결 해제</button>
            <div class="status" id="connection-status">상태: 연결 안됨</div>
        </div>
        
        <div class="control-panel">
            <h2>이동 제어</h2>
            <button class="button" onclick="home()">🏠 홈</button>
            <button class="button" onclick="homeZ()">🏠 Z 홈</button>
            <br><br>
            X: <input type="number" id="move-x" value="0">
            Y: <input type="number" id="move-y" value="0">
            Z: <input type="number" id="move-z" value="0">
            <button class="button" onclick="move()">이동</button>
        </div>
        
        <div class="control-panel">
            <h2>온도 제어</h2>
            노즐: <input type="number" id="temp-nozzle" value="200">°C
            베드: <input type="number" id="temp-bed" value="60">°C
            <button class="button" onclick="setTemperature()">설정</button>
            <button class="button" onclick="coolDown()">냉각</button>
        </div>
        
        <div class="control-panel">
            <h2>커스텀 명령</h2>
            <input type="text" id="custom-command" placeholder="G-code 입력" style="width: 300px;">
            <button class="button" onclick="sendCustom()">전송</button>
            <div class="status" id="response"></div>
        </div>
        
        <script>
            function connect() {
                fetch('/api/connect', {method: 'POST'})
                    .then(r => r.json())
                    .then(data => {
                        document.getElementById('connection-status').innerText = 
                            data.success ? '상태: 연결됨 ✅' : '상태: 연결 실패 ❌';
                    });
            }
            
            function disconnect() {
                fetch('/api/disconnect', {method: 'POST'})
                    .then(r => r.json())
                    .then(data => {
                        document.getElementById('connection-status').innerText = 
                            '상태: 연결 해제됨';
                    });
            }
            
            function home() {
                fetch('/api/home', {method: 'POST'});
            }
            
            function homeZ() {
                fetch('/api/home?axes=Z', {method: 'POST'});
            }
            
            function move() {
                const x = document.getElementById('move-x').value;
                const y = document.getElementById('move-y').value;
                const z = document.getElementById('move-z').value;
                fetch('/api/move', {
                    method: 'POST',
                    headers: {'Content-Type': 'application/json'},
                    body: JSON.stringify({x: x, y: y, z: z})
                });
            }
            
            function setTemperature() {
                const nozzle = document.getElementById('temp-nozzle').value;
                const bed = document.getElementById('temp-bed').value;
                fetch('/api/temperature', {
                    method: 'POST',
                    headers: {'Content-Type': 'application/json'},
                    body: JSON.stringify({nozzle: nozzle, bed: bed})
                });
            }
            
            function coolDown() {
                fetch('/api/temperature', {
                    method: 'POST',
                    headers: {'Content-Type': 'application/json'},
                    body: JSON.stringify({nozzle: 0, bed: 0})
                });
            }
            
            function sendCustom() {
                const command = document.getElementById('custom-command').value;
                fetch('/api/command', {
                    method: 'POST',
                    headers: {'Content-Type': 'application/json'},
                    body: JSON.stringify({command: command})
                })
                .then(r => r.json())
                .then(data => {
                    document.getElementById('response').innerText = 
                        '응답: ' + data.response;
                });
            }
        </script>
    
    
    '''

@app.route('/api/connect', methods=['POST'])
def api_connect():
    success = controller.connect()
    return jsonify({'success': success})

@app.route('/api/disconnect', methods=['POST'])
def api_disconnect():
    controller.disconnect()
    return jsonify({'success': True})

@app.route('/api/home', methods=['POST'])
def api_home():
    axes = request.args.get('axes', '')
    result = controller.home(axes)
    return jsonify(result)

@app.route('/api/move', methods=['POST'])
def api_move():
    data = request.json
    result = controller.move(
        x=data.get('x'),
        y=data.get('y'),
        z=data.get('z')
    )
    return jsonify(result)

@app.route('/api/temperature', methods=['POST'])
def api_temperature():
    data = request.json
    results = controller.set_temperature(
        nozzle=data.get('nozzle'),
        bed=data.get('bed')
    )
    return jsonify({'success': True, 'results': results})

@app.route('/api/command', methods=['POST'])
def api_command():
    data = request.json
    result = controller.send_command(data['command'])
    return jsonify(result)

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000, debug=True)

class AutoBedLeveling:
    def __init__(self, printer):
        self.printer = printer
        self.probe_points = [
            (20, 20),   # 좌측 하단
            (180, 20),  # 우측 하단
            (180, 180), # 우측 상단
            (20, 180),  # 좌측 상단
            (100, 100)  # 중앙
        ]
        
    def probe_point(self, x, y):
        """특정 지점 프로빙"""
        self.printer.send_gcode(f'G1 X{x} Y{y} Z10 F3000')
        self.printer.send_gcode('G30')  # 프로브 실행
        # 프로브 결과 읽기
        response = self.printer.wait_for_response()
        # Z 높이 추출 (응답 파싱)
        return self.parse_z_height(response)
        
    def level_bed(self):
        """베드 레벨링 실행"""
        print("🔧 자동 베드 레벨링 시작...")
        heights = []
        
        for i, (x, y) in enumerate(self.probe_points):
            print(f"📍 포인트 {i+1}/5: ({x}, {y})")
            height = self.probe_point(x, y)
            heights.append(height)
            print(f"   높이: {height:.3f}mm")
            
        # 높이 차이 계산
        max_diff = max(heights) - min(heights)
        print(f"\n📊 최대 높이 차이: {max_diff:.3f}mm")
        
        if max_diff > 0.2:
            print("⚠️ 베드 레벨 조정이 필요합니다!")
            self.suggest_adjustments(heights)
        else:
            print("✅ 베드 레벨이 양호합니다!")
            
    def suggest_adjustments(self, heights):
        """조정 제안"""
        avg = sum(heights) / len(heights)
        corners = ['좌하', '우하', '우상', '좌상']
        
        print("\n🔧 조정 제안:")
        for i, (height, corner) in enumerate(zip(heights[:4], corners)):
            diff = height - avg
            if abs(diff) > 0.1:
                direction = "올리기" if diff < 0 else "내리기"
                print(f"   {corner} 코너: {abs(diff):.2f}mm {direction}")

import time
from datetime import datetime, timedelta

class PrintMonitor:
    def __init__(self, printer, gcode_file):
        self.printer = printer
        self.gcode_file = gcode_file
        self.total_lines = 0
        self.current_line = 0
        self.start_time = None
        
    def load_gcode(self):
        """G-code 파일 로드"""
        with open(self.gcode_file, 'r') as f:
            self.gcode_lines = [
                line.strip() 
                for line in f.readlines() 
                if line.strip() and not line.startswith(';')
            ]
        self.total_lines = len(self.gcode_lines)
        print(f"📄 G-code 로드 완료: {self.total_lines}줄")
        
    def print_with_monitoring(self):
        """모니터링하면서 프린트"""
        self.start_time = datetime.now()
        
        for i, line in enumerate(self.gcode_lines):
            self.current_line = i + 1
            
            # G-code 전송
            self.printer.send_gcode(line)
            self.printer.wait_for_ok()
            
            # 10줄마다 진행 상황 출력
            if i % 10 == 0:
                self.print_progress()
                
        print("\n🎉 프린트 완료!")
        self.print_summary()
        
    def print_progress(self):
        """진행 상황 출력"""
        progress = (self.current_line / self.total_lines) * 100
        elapsed = datetime.now() - self.start_time
        
        # 예상 남은 시간 계산
        if progress > 0:
            total_estimated = elapsed / (progress / 100)
            remaining = total_estimated - elapsed
        else:
            remaining = timedelta(0)
            
        # 진행 바 생성
        bar_length = 30
        filled = int(bar_length * progress / 100)
        bar = '█' * filled + '░' * (bar_length - filled)
        
        print(f"\r진행: [{bar}] {progress:.1f}% | "
              f"경과: {self.format_time(elapsed)} | "
              f"남음: {self.format_time(remaining)}", end='')
              
    def format_time(self, td):
        """시간 포맷팅"""
        total_seconds = int(td.total_seconds())
        hours = total_seconds // 3600
        minutes = (total_seconds % 3600) // 60
        seconds = total_seconds % 60
        return f"{hours:02d}:{minutes:02d}:{seconds:02d}"
        
    def print_summary(self):
        """프린트 요약"""
        elapsed = datetime.now() - self.start_time
        print(f"\n📊 프린트 요약:")
        print(f"   총 시간: {self.format_time(elapsed)}")
        print(f"   총 라인: {self.total_lines}")
        print(f"   평균 속도: {self.total_lines / elapsed.total_seconds():.1f} 줄/초")

# 사용 예제
monitor = PrintMonitor(printer, 'model.gcode')
monitor.load_gcode()
monitor.print_with_monitoring()

import RPi.GPIO as GPIO  # 라즈베리파이 사용시

class FilamentSensor:
    def __init__(self, printer, sensor_pin=17):
        self.printer = printer
        self.sensor_pin = sensor_pin
        self.is_printing = False
        
        # GPIO 설정
        GPIO.setmode(GPIO.BCM)
        GPIO.setup(sensor_pin, GPIO.IN, pull_up_down=GPIO.PUD_UP)
        GPIO.add_event_detect(
            sensor_pin, 
            GPIO.FALLING, 
            callback=self.on_filament_runout,
            bouncetime=300
        )
        
    def on_filament_runout(self, channel):
        """필라멘트 부족 감지"""
        if self.is_printing:
            print("\n🚨 필라멘트 부족 감지!")
            self.pause_print()
            self.notify_user()
            
    def pause_print(self):
        """프린트 일시정지"""
        print("⏸️ 프린트 일시정지 중...")
        self.printer.send_gcode('M600')  # 필라멘트 교체 명령
        # 또는 수동 일시정지
        self.printer.send_gcode('M25')  # SD 카드 프린트 일시정지
        self.printer.send_gcode('G91')  # 상대 좌표
        self.printer.send_gcode('G1 Z10 F300')  # Z축 올리기
        self.printer.send_gcode('G90')  # 절대 좌표
        
    def notify_user(self):
        """사용자 알림"""
        # 이메일, 푸시 알림 등
        print("📧 사용자에게 알림 전송")
        # 실제로는 이메일이나 텔레그램 봇 등을 사용
        
    def resume_print(self):
        """프린트 재개"""
        print("▶️ 프린트 재개")
        self.printer.send_gcode('M24')  # SD 카드 프린트 재개
        self.printer.send_gcode('G91')
        self.printer.send_gcode('G1 Z-10 F300')  # Z축 원위치
        self.printer.send_gcode('G90')

from PIL import Image, ImageDraw, ImageFont
import numpy as np

class TextTo3D:
    def __init__(self, generator):
        self.generator = generator
        
    def text_to_gcode(self, text, font_size=50, layer_height=0.2, 
                      extrusion_width=0.4):
        """텍스트를 G-code로 변환"""
        # 이미지로 텍스트 렌더링
        font = ImageFont.truetype('/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf', 
                                   font_size)
        
        # 텍스트 크기 계산
        dummy_img = Image.new('L', (1, 1))
        draw = ImageDraw.Draw(dummy_img)
        bbox = draw.textbbox((0, 0), text, font=font)
        text_width = bbox[2] - bbox[0]
        text_height = bbox[3] - bbox[1]
        
        # 실제 이미지 생성
        img = Image.new('L', (text_width + 20, text_height + 20), color=0)
        draw = ImageDraw.Draw(img)
        draw.text((10, 10), text, fill=255, font=font)
        
        # 이미지를 numpy 배열로 변환
        img_array = np.array(img)
        
        # G-code 생성 시작
        self.generator.add_comment(f'텍스트 프린트: {text}')
        self.generator.add_command('G92 E0')
        
        # 이미지를 스캔하면서 G-code 생성
        scale = 0.2  # 1픽셀 = 0.2mm
        
        for y in range(0, img_array.shape[0], 2):
            line_has_content = False
            start_x = None
            
            for x in range(img_array.shape[1]):
                if img_array[y, x] > 128:  # 밝은 픽셀
                    if not line_has_content:
                        start_x = x
                        line_has_content = True
                        # 이동 (압출 없음)
                        self.generator.move_to(
                            x * scale, 
                            y * scale, 
                            z=layer_height,
                            extrude=False
                        )
                    # 압출하면서 이동
                    self.generator.move_to(
                        x * scale, 
                        y * scale,
                        extrude=True
                    )
                elif line_has_content:
                    line_has_content = False
                    
        self.generator.add_comment('텍스트 프린트 완료')
        
    def create_3d_text(self, text, height=5):
        """3D 텍스트 생성 (여러 레이어)"""
        layers = int(height / 0.2)
        
        for layer in range(layers):
            z = layer * 0.2
            self.generator.add_comment(f'레이어 {layer + 1}/{layers}')
            self.text_to_gcode(text)
            
        print(f"✅ 3D 텍스트 생성 완료: {layers}개 레이어")

# 사용 예제
generator = GCodeGenerator('text_print.gcode')
text_printer = TextTo3D(generator)

generator.start_print()
text_printer.create_3d_text("HELLO 3D!", height=3)
generator.end_print()
generator.save()