orange3-example 0.1.1__py3-none-any.whl

orange3_example-0.1.1.dist-info/METADATA

@@ -0,0 +1,16 @@
+Metadata-Version: 2.1
+Name: orange3-example
+Version: 0.1.1
+Summary: Orange3 LLM 기반 사용자 정의 예제 위젯입니다.
+Home-page: https://github.com/whyz-dev/Orange3-Widget
+Author: Gangjun Jo
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Requires-Dist: Orange3>=3.32.0
+Requires-Dist: openai
+Requires-Dist: PyQt5
+Requires-Dist: python-dotenv
+Requires-Dist: opencv-python
+Requires-Dist: pyserial
+

orange3_example-0.1.1.dist-info/RECORD

@@ -0,0 +1,15 @@
+orangecontrib/__init__.py,sha256=84XsKoP1cFfb1oUmZbzKBx6Hqc7UkwjItzZipwK_i7A,93
+orangecontrib/orange3example/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+orangecontrib/orange3example/utils/llm.py,sha256=CseJ9lpW4XdO0yiE60_PgDZuOphSzGfuL_Cd5XBwaZE,3038
+orangecontrib/orange3example/utils/microbit.py,sha256=8jv2T7culVbPgznFiHpm-fK6ivrgO_PPKNAOguhqvwM,4360
+orangecontrib/orange3example/utils/webcam.py,sha256=mQuTS5QjfOibjurO4IewQ88E5eP1Mq3EqtZgZ44JqCc,391
+orangecontrib/orange3example/widgets/__init__.py,sha256=mDobVdLvR_YQfkOOD7YgjbdZbtHNUF9AdpTNas0d7oY,103
+orangecontrib/orange3example/widgets/owimagellm.py,sha256=-1Brg6sf_ufxp4IQwU9QTUyGjdjBfwxvpmzLRfud0fo,9178
+orangecontrib/orange3example/widgets/owllmtransformer.py,sha256=v9gO_jIov_Uy7VzaX5zAACLFIL-eow6FPh-JK7uOpgg,3271
+orangecontrib/orange3example/widgets/owmicrobit.py,sha256=_ry_mcyYlhh7BI1dmYJAmUbClvunW8CpFJ3sAoMhy0s,13334
+orangecontrib/orange3example/widgets/owwebcam.py,sha256=M5cU-Pw5nWkavY6XHr6OtUBOGT12gFqFmcZRXxD4PKo,2651
+orange3_example-0.1.1.dist-info/METADATA,sha256=Udv_OAdkZcjC0gYoR7VdBh3rWREp4AfipVlxkT7eiPc,470
+orange3_example-0.1.1.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+orange3_example-0.1.1.dist-info/entry_points.txt,sha256=8BEmcvuTJCQU2ftCGkpAmEzybJtX5cJrg-keHi0eVXA,135
+orange3_example-0.1.1.dist-info/top_level.txt,sha256=Iut-JTfT11SZHHm77_ZeszD7pZDWXcTweCbvrJpqDyQ,14
+orange3_example-0.1.1.dist-info/RECORD,,

orange3_example-0.1.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

orange3_example-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[orange.widgets]
+Example Widgets = orangecontrib.orange3example.widgets
+
+[orange3.addon]
+orange3example = orangecontrib.orange3example

orange3_example-0.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+orangecontrib

orangecontrib/__init__.py

@@ -0,0 +1,3 @@
+# in orangecontrib/__init__.py
+import pkg_resources
+pkg_resources.declare_namespace(__name__)

orangecontrib/orange3example/utils/llm.py

@@ -0,0 +1,83 @@
+import os
+from openai import OpenAI
+from dotenv import load_dotenv
+
+class LLM:
+    """GPT API를 호출하는 클래스"""
+    def __init__(self):
+        load_dotenv()
+        api_key = os.getenv("OPENAI_API_KEY")
+        self.openai_client = OpenAI(api_key=api_key)
+
+    def get_response(self, prompt, data_list):
+        """GPT의 응답을 받아서 그대로 반환"""
+        results = []
+
+        for data in data_list:
+            try:
+                response = self.openai_client.chat.completions.create(
+                    model="gpt-4o-mini",
+                    messages=[
+                        {"role": "system", "content": prompt},
+                        {"role": "user", "content": str(data)},
+                    ],
+                    temperature=0,
+                )
+                results.append(response.choices[0].message.content.strip())
+
+            except Exception as e:
+                results.append(f"Error: {str(e)}")  # 오류 발생 시 메시지 추가
+
+        return results
+
+    def get_multimodal_response(self, prompt, multimodal_data):
+        """멀티모달 데이터(이미지+텍스트)를 처리하는 메서드"""
+        try:
+            # 멀티모달 메시지 구성
+            messages = [{"role": "system", "content": prompt}]
+            
+            # 사용자 메시지 구성
+            user_content = []
+            
+            for item in multimodal_data:
+                if item["type"] == "image":
+                    # 이미지 데이터를 base64로 전송
+                    user_content.append({
+                        "type": "image_url",
+                        "image_url": {
+                            "url": f"data:image/png;base64,{item['data']}",
+                            "detail": "low"
+                        }
+                    })
+                elif item["type"] == "text":
+                    # 텍스트 데이터 추가
+                    if user_content and user_content[-1].get("type") == "text":
+                        # 이미 텍스트가 있으면 기존 텍스트에 추가
+                        user_content[-1]["text"] += f"\n{item['data']}"
+                    else:
+                        # 새로운 텍스트 블록 생성
+                        user_content.append({
+                            "type": "text",
+                            "text": item["data"]
+                        })
+            
+            # 사용자 메시지 추가
+            messages.append({
+                "role": "user",
+                "content": user_content
+            })
+            
+            # GPT-4o 모델로 멀티모달 요청
+            response = self.openai_client.chat.completions.create(
+                model="gpt-4o",
+                messages=messages,
+                temperature=0,
+                max_tokens=1000
+            )
+            
+            return [response.choices[0].message.content.strip()]
+            
+        except Exception as e:
+            return [f"멀티모달 처리 오류: {str(e)}"]
+
+    

orangecontrib/orange3example/utils/microbit.py

@@ -0,0 +1,130 @@
+import serial
+import time
+import serial.tools.list_ports
+import threading
+
+_connection = None
+_text_input_callback = None
+_is_listening = False
+
+
+def list_ports() -> list:
+    """사용 가능한 시리얼 포트 목록 반환"""
+    return [port.device for port in serial.tools.list_ports.comports()]
+
+
+def connect(port: str, baudrate: int = 115200, timeout: float = 1.0) -> str:
+    """포트에 연결 시도. 성공 시 포트명 반환."""
+    global _connection
+    if _connection:
+        _connection.close()
+    _connection = serial.Serial(port, baudrate=baudrate, timeout=timeout)
+    time.sleep(2)  # 연결 안정화 대기
+    return _connection.port
+
+
+def disconnect():
+    """연결 해제"""
+    global _connection, _is_listening
+    _is_listening = False
+    if _connection and _connection.is_open:
+        _connection.close()
+        _connection = None
+
+
+def is_connected() -> bool:
+    """현재 연결 여부 반환"""
+    global _connection
+    return _connection is not None and _connection.is_open
+
+
+def send_and_receive(message: str, wait_time: float = 2.0) -> str:
+    """메시지 전송 후 응답 수신"""
+    global _connection
+    if not _connection or not _connection.is_open:
+        raise RuntimeError("Microbit 연결이 되어 있지 않습니다. connect(port)를 먼저 호출하세요.")
+
+    _connection.reset_input_buffer()  # 🧹 이전 수신 버퍼 정리
+    _connection.write((message + '\n').encode('utf-8'))
+
+    time.sleep(wait_time)
+
+    if _connection.in_waiting > 0:
+        try:
+            response = _connection.readline().decode('utf-8', errors='ignore').strip()
+            return response if response else "[응답 없음]"
+        except Exception as e:
+            return f"[디코딩 오류: {str(e)}]"
+    else:
+        return "[타임아웃: 응답 없음]"
+
+
+def send_text(text: str) -> bool:
+    """텍스트를 마이크로비트로 즉시 전송"""
+    global _connection
+    if not _connection or not _connection.is_open:
+        print("Microbit 연결이 되어 있지 않습니다.")
+        return False
+    
+    try:
+        # 텍스트에 개행 문자 추가하여 전송
+        message = text.strip() + '\n'
+        _connection.write(message.encode('utf-8'))
+        _connection.flush()  # 버퍼 즉시 전송
+        print(f"전송됨: {text}")
+        return True
+    except Exception as e:
+        print(f"전송 오류: {str(e)}")
+        return False
+
+
+def start_text_listening(callback=None):
+    """마이크로비트로부터 텍스트 응답을 실시간으로 수신하는 리스너 시작"""
+    global _connection, _text_input_callback, _is_listening
+    
+    if not _connection or not _connection.is_open:
+        print("Microbit 연결이 되어 있지 않습니다.")
+        return False
+    
+    _text_input_callback = callback
+    _is_listening = True
+    
+    def listen_thread():
+        while _is_listening and _connection and _connection.is_open:
+            try:
+                if _connection.in_waiting > 0:
+                    response = _connection.readline().decode('utf-8', errors='ignore').strip()
+                    if response and _text_input_callback:
+                        _text_input_callback(response)
+                time.sleep(0.1)  # CPU 사용량 줄이기
+            except Exception as e:
+                print(f"리스닝 오류: {str(e)}")
+                break
+    
+    # 별도 스레드에서 리스닝 시작
+    listener = threading.Thread(target=listen_thread, daemon=True)
+    listener.start()
+    print("마이크로비트 응답 리스닝 시작됨")
+    return True
+
+
+def stop_text_listening():
+    """텍스트 응답 리스닝 중지"""
+    global _is_listening
+    _is_listening = False
+    print("마이크로비트 응답 리스닝 중지됨")
+
+
+def send_text_with_response(text: str, wait_time: float = 1.0) -> str:
+    """텍스트 전송 후 응답 대기"""
+    if send_text(text):
+        time.sleep(wait_time)
+        if _connection and _connection.in_waiting > 0:
+            try:
+                response = _connection.readline().decode('utf-8', errors='ignore').strip()
+                return response if response else "[응답 없음]"
+            except Exception as e:
+                return f"[응답 읽기 오류: {str(e)}]"
+        else:
+            return "[응답 없음]"
+    return "[전송 실패]"

orangecontrib/orange3example/utils/webcam.py

@@ -0,0 +1,23 @@
+import cv2
+
+cap = None
+
+def start_camera(index=0):
+    global cap
+    if cap is None:
+        cap = cv2.VideoCapture(index)
+
+
+def read_frame():
+    global cap
+    if cap is not None and cap.isOpened():
+        ret, frame = cap.read()
+        if ret:
+            return frame
+    return None
+
+def stop_camera():
+    global cap
+    if cap is not None:
+        cap.release()
+        cap = None

orangecontrib/orange3example/widgets/__init__.py

@@ -0,0 +1,4 @@
+from . import owllmtransformer
+from . import owmicrobit
+from . import owwebcam
+from . import owimagellm

orangecontrib/orange3example/widgets/owimagellm.py

@@ -0,0 +1,226 @@
+from Orange.widgets.widget import OWWidget, Input, Output
+from Orange.widgets import gui
+import Orange.data
+from PyQt5.QtWidgets import QTextEdit, QLabel, QVBoxLayout, QHBoxLayout
+from PyQt5.QtGui import QPixmap, QImage
+from PyQt5.QtCore import Qt
+import numpy as np
+import base64
+import io
+from PIL import Image
+from orangecontrib.orange3example.utils.llm import LLM
+
+class OWImageLLM(OWWidget):
+    name = "Image LLM"
+    description = "마이크로비트 이미지와 텍스트를 입력받아 멀티모달 LLM으로 처리하는 Orange3 위젯"
+    icon = "../icons/machine-learning-03-svgrepo-com.svg"
+    priority = 20
+
+    class Inputs:
+        image_data = Input("이미지 데이터", np.ndarray)
+        text_data = Input("텍스트 데이터", Orange.data.Table)
+
+    class Outputs:
+        llm_response = Output("LLM 응답", Orange.data.Table)
+
+    def __init__(self):
+        super().__init__()
+
+        # 이미지 표시 영역
+        self.image_label = QLabel("이미지가 입력되지 않았습니다")
+        self.image_label.setAlignment(Qt.AlignCenter)
+        self.image_label.setMinimumSize(200, 150)
+        self.image_label.setStyleSheet("border: 2px dashed #ccc;")
+        
+        # 프롬프트 입력 필드
+        self.prompt = "이 이미지와 텍스트를 분석해주세요."
+        self.prompt_input = QTextEdit(self.controlArea)
+        self.prompt_input.setPlainText(self.prompt)
+        self.prompt_input.setPlaceholderText("여기에 프롬프트를 입력하세요...")
+        self.prompt_input.setMinimumHeight(80)
+        
+        # 실행 버튼
+        self.process_button = gui.button(
+            self.controlArea, self, "멀티모달 분석 실행", callback=self.process
+        )
+        self.process_button.setDisabled(True)
+        
+        # 결과 출력 필드
+        self.result_display = QTextEdit()
+        self.result_display.setReadOnly(True)
+        self.result_display.setMinimumHeight(100)
+        
+        # 레이아웃 설정
+        control_layout = QVBoxLayout()
+        control_layout.addWidget(QLabel("입력 이미지:"))
+        control_layout.addWidget(self.image_label)
+        control_layout.addWidget(QLabel("프롬프트:"))
+        control_layout.addWidget(self.prompt_input)
+        control_layout.addWidget(self.process_button)
+        self.controlArea.layout().addLayout(control_layout)
+        
+        # 메인 영역에 결과 표시
+        self.mainArea.layout().addWidget(QLabel("LLM 응답 결과:"))
+        self.mainArea.layout().addWidget(self.result_display)
+        
+        # 데이터 저장 변수
+        self.image_data = None
+        self.text_data = None
+        self.has_image = False
+        self.has_text = False
+
+    @Inputs.image_data
+    def set_image_data(self, data):
+        """이미지 데이터 입력 처리"""
+        if data is not None and isinstance(data, np.ndarray):
+            self.image_data = data
+            self.has_image = True
+            self.display_image(data)
+            self.check_inputs()
+            # 이미지가 들어오면 자동으로 처리
+            if self.has_text:
+                self.process()
+        else:
+            self.image_data = None
+            self.has_image = False
+            self.image_label.setText("이미지가 입력되지 않았습니다")
+            self.image_label.setStyleSheet("border: 2px dashed #ccc;")
+            self.check_inputs()
+
+    @Inputs.text_data
+    def set_text_data(self, data):
+        """텍스트 데이터 입력 처리"""
+        if data is not None and isinstance(data, Orange.data.Table):
+            self.text_data = data
+            self.has_text = True
+            self.check_inputs()
+            # 텍스트가 들어오면 자동으로 처리
+            if self.has_image:
+                self.process()
+        else:
+            self.text_data = None
+            self.has_text = False
+            self.check_inputs()
+
+    def display_image(self, image_array):
+        """numpy 배열을 QPixmap으로 변환하여 표시"""
+        try:
+            # 이미지가 RGB 형식으로 전달되었으므로 그대로 사용
+            if len(image_array.shape) == 3 and image_array.shape[2] == 3:
+                # RGB 이미지를 PIL Image로 변환
+                pil_image = Image.fromarray(image_array.astype(np.uint8))
+            else:
+                # 그레이스케일 또는 다른 형식인 경우 RGB로 변환
+                pil_image = Image.fromarray(image_array.astype(np.uint8))
+                if len(pil_image.getbands()) == 1:
+                    pil_image = pil_image.convert('RGB')
+            
+            # QPixmap으로 변환
+            buffer = io.BytesIO()
+            pil_image.save(buffer, format='PNG')
+            qimage = QImage.fromData(buffer.getvalue())
+            pixmap = QPixmap.fromImage(qimage)
+            
+            # 이미지 크기 조정
+            pixmap = pixmap.scaled(200, 150, Qt.KeepAspectRatio, Qt.SmoothTransformation)
+            self.image_label.setPixmap(pixmap)
+            self.image_label.setStyleSheet("border: none;")
+            
+        except Exception as e:
+            self.image_label.setText(f"이미지 표시 오류: {str(e)}")
+            self.image_label.setStyleSheet("border: 2px dashed #ccc;")
+
+    def check_inputs(self):
+        """입력 데이터 상태 확인 및 버튼 활성화/비활성화"""
+        if self.has_image or self.has_text:
+            self.process_button.setDisabled(False)
+        else:
+            self.process_button.setDisabled(True)
+
+    def process(self):
+        """멀티모달 LLM 처리 실행"""
+        try:
+            self.prompt = self.prompt_input.toPlainText()
+            
+            # LLM 인스턴스 생성
+            llm = LLM()
+            
+            # 멀티모달 데이터 준비
+            multimodal_data = self.prepare_multimodal_data()
+            
+            # LLM API 호출
+            results = llm.get_multimodal_response(self.prompt, multimodal_data)
+            
+            # 결과를 Orange 데이터 테이블로 변환
+            domain = Orange.data.Domain([], metas=[Orange.data.StringVariable("LLM Response")])
+            response_data = Orange.data.Table(domain, [[str(result)] for result in results])
+            
+            # 출력 전송
+            self.Outputs.llm_response.send(response_data)
+            
+            # 결과 표시
+            self.result_display.setPlainText("\n".join(results))
+            
+        except Exception as e:
+            error_msg = f"처리 중 오류 발생: {str(e)}"
+            self.result_display.setPlainText(error_msg)
+            
+            # 오류 결과도 출력으로 전송
+            domain = Orange.data.Domain([], metas=[Orange.data.StringVariable("Error")])
+            error_data = Orange.data.Table(domain, [[error_msg]])
+            self.Outputs.llm_response.send(error_data)
+
+    def prepare_multimodal_data(self):
+        """멀티모달 데이터 준비"""
+        multimodal_content = []
+        
+        # 이미지 데이터가 있는 경우 base64로 인코딩
+        if self.has_image and self.image_data is not None:
+            try:
+                # 이미지를 base64로 인코딩
+                pil_image = Image.fromarray(self.image_data.astype(np.uint8))
+                buffer = io.BytesIO()
+                pil_image.save(buffer, format='PNG')
+                image_base64 = base64.b64encode(buffer.getvalue()).decode('utf-8')
+                
+                multimodal_content.append({
+                    "type": "image",
+                    "data": image_base64,
+                    "description": "마이크로비트에서 전송된 이미지"
+                })
+            except Exception as e:
+                multimodal_content.append({
+                    "type": "text",
+                    "data": f"이미지 처리 오류: {str(e)}"
+                })
+        
+        # 텍스트 데이터가 있는 경우
+        if self.has_text and self.text_data is not None:
+            try:
+                # string-meta 변수들을 텍스트로 변환
+                string_meta_indices = [
+                    idx for idx, var in enumerate(self.text_data.domain.metas)
+                    if isinstance(var, Orange.data.StringVariable)
+                ]
+                
+                if string_meta_indices:
+                    text_content = [
+                        " ".join(str(row.metas[idx]) for idx in string_meta_indices)
+                        for row in self.text_data
+                    ]
+                    multimodal_content.append({
+                        "type": "text",
+                        "data": "\n".join(text_content)
+                    })
+                else:
+                    multimodal_content.append({
+                        "type": "text",
+                        "data": "텍스트 데이터 없음"
+                    })
+            except Exception as e:
+                multimodal_content.append({
+                    "type": "text",
+                    "data": f"텍스트 처리 오류: {str(e)}"
+                })
+        
+        return multimodal_content

orangecontrib/orange3example/widgets/owllmtransformer.py

@@ -0,0 +1,79 @@
+from Orange.widgets.widget import OWWidget, Input, Output
+from Orange.widgets import gui
+import Orange.data
+from PyQt5.QtWidgets import QTextEdit  # QTextEdit 사용
+from orangecontrib.orange3example.utils.llm import LLM  # llm.py에서 LLM 클래스를 가져옴
+
+class OWLLMTransformer(OWWidget):
+    name = "LLM Transformer"
+    description = "GPT API를 통해 입력 데이터를 변환하는 Orange3 위젯"
+    icon = "../icons/machine-learning-03-svgrepo-com.svg"
+    priority = 10
+
+    class Inputs:
+        text_data = Input("입력 데이터", Orange.data.Table)
+
+    class Outputs:
+        transformed_data = Output("GPT 응답 데이터", Orange.data.Table)
+
+    def __init__(self):
+        super().__init__()
+
+        # 프롬프트 입력 필드를 크게 만들기 위해 QTextEdit 사용
+        self.prompt = "입력 데이터를 변환해주세요."
+        self.prompt_input = QTextEdit(self.controlArea)  # QTextEdit으로 프롬프트 입력창 확대
+        self.prompt_input.setPlainText(self.prompt)
+        self.prompt_input.setPlaceholderText("여기에 프롬프트를 입력하세요...")
+        self.prompt_input.setMinimumHeight(100)  # 높이 조정
+        self.controlArea.layout().addWidget(self.prompt_input)
+
+        # 변환 실행 버튼
+        self.transform_button = gui.button(
+            self.controlArea, self, "변환 실행", callback=self.process
+        )
+        self.transform_button.setDisabled(True)  # 초기에는 비활성화
+
+        # 🛠 결과 출력 필드 (QTextEdit 사용)
+        self.result_text = ""
+        self.result_display = QTextEdit()
+        self.result_display.setReadOnly(True)  # 읽기 전용 설정
+        self.mainArea.layout().addWidget(self.result_display)  # Orange3의 레이아웃에 추가
+
+        self.text_data = None
+
+    @Inputs.text_data
+    def set_data(self, data):
+        if isinstance(data, Orange.data.Table):
+            # 모든 string-meta 변수를 찾음
+            string_meta_indices = [
+                idx for idx, var in enumerate(data.domain.metas)
+                if isinstance(var, Orange.data.StringVariable)
+            ]
+            # 모든 string-meta 변수를 모아서 하나의 문자열로 합침
+            data = [
+                " ".join(str(row.metas[idx]) for idx in string_meta_indices)
+                for row in data
+            ]
+
+        self.text_data = data
+        self.transform_button.setDisabled(False)
+
+
+    def process(self):
+        """변환 실행 버튼을 눌렀을 때만 GPT API 호출"""
+        self.prompt = self.prompt_input.toPlainText()
+        
+        # 문자열 데이터를 위한 메타 데이터 설정
+        domain = Orange.data.Domain([], metas=[Orange.data.StringVariable("Transformed Text")])
+
+        # GPT API 호출
+        llm = LLM()
+        results = llm.get_response(self.prompt, self.text_data) 
+        transformed_data = Orange.data.Table(domain, [[str(result)] for result in results])
+
+        # 변환된 결과를 출력으로 보냄
+        self.Outputs.transformed_data.send(transformed_data)
+
+        # 결과 출력 UI 업데이트
+        self.result_text = "\n".join(results)  # 결과를 하나의 텍스트로 연결
+        self.result_display.setPlainText(self.result_text)

orangecontrib/orange3example/widgets/owmicrobit.py

@@ -0,0 +1,327 @@
+from Orange.widgets.widget import OWWidget, Input, Output
+from Orange.widgets import get_distribution
+import Orange.data
+
+from PyQt5.QtWidgets import QTextEdit, QPushButton, QComboBox, QLabel, QHBoxLayout, QWidget, QVBoxLayout
+from PyQt5.QtCore import QTimer
+from orangecontrib.orange3example.utils import microbit
+
+
+class OWMicrobit(OWWidget):
+    name = "Microbit Communicator"
+    description = "통신 포트를 통해 마이크로비트와 데이터를 주고받는 위젯"
+    icon = "../icons/machine-learning-03-svgrepo-com.svg"
+    priority = 20
+
+    class Inputs:
+        text_data = Input("입력 텍스트", Orange.data.Table)
+
+    class Outputs:
+        received_data = Output("수신 데이터", Orange.data.Table)
+
+    def __init__(self):
+        super().__init__()
+
+        self.text_data = None
+        self.received_text = ""
+        self.is_listening = False
+
+        # 포트 선택 UI
+        port_layout = QHBoxLayout()
+        port_widget = QWidget()
+        port_widget.setLayout(port_layout)
+
+        self.port_combo = QComboBox()
+        self.port_combo.setEditable(True)
+        port_layout.addWidget(self.port_combo)
+
+        self.refresh_button = QPushButton("🔄")
+        self.refresh_button.clicked.connect(self.refresh_ports)
+        port_layout.addWidget(self.refresh_button)
+
+        self.connect_button = QPushButton("연결")
+        self.connect_button.clicked.connect(self.connect_to_microbit)
+        port_layout.addWidget(self.connect_button)
+
+        self.status_label = QLabel("연결되지 않음")
+        port_layout.addWidget(self.status_label)
+
+        self.controlArea.layout().addWidget(port_widget)
+
+        # 전송 텍스트 입력
+        self.send_box = QTextEdit()
+        self.send_box.setPlaceholderText("마이크로비트로 보낼 텍스트를 입력하세요")
+        self.send_box.setMaximumHeight(80)
+        self.controlArea.layout().addWidget(self.send_box)
+
+        # 버튼 레이아웃
+        button_layout = QHBoxLayout()
+        
+        self.send_button = QPushButton("전송")
+        self.send_button.clicked.connect(self.send_to_microbit)
+        button_layout.addWidget(self.send_button)
+        
+        self.auto_send_checkbox = QPushButton("자동 전송")
+        self.auto_send_checkbox.setCheckable(True)
+        self.auto_send_checkbox.setChecked(True)
+        button_layout.addWidget(self.auto_send_checkbox)
+        
+        self.listen_button = QPushButton("응답 리스닝 시작")
+        self.listen_button.clicked.connect(self.toggle_listening)
+        button_layout.addWidget(self.listen_button)
+        
+        self.controlArea.layout().addLayout(button_layout)
+
+        # 수신 텍스트 표시
+        self.receive_box = QTextEdit()
+        self.receive_box.setReadOnly(True)
+        self.mainArea.layout().addWidget(self.receive_box)
+
+        # 로그 출력창
+        self.log_box = QTextEdit()
+        self.log_box.setReadOnly(True)
+        self.log_box.setMaximumHeight(100)
+        self.controlArea.layout().addWidget(self.log_box)
+
+        # 응답 리스닝을 위한 타이머 (더 빠른 주기로 변경)
+        self.response_timer = QTimer()
+        self.response_timer.timeout.connect(self.check_response)
+        self.response_timer.start(50)  # 50ms마다 응답 확인 (더 빠르게)
+
+        # 초기 포트 목록 로드
+        self.refresh_ports()
+
+    def log(self, text):
+        self.log_box.append(text)
+
+    def refresh_ports(self):
+        self.port_combo.clear()
+        self.log("🔄 포트 새로고침 중...")
+        if microbit:
+            try:
+                ports = microbit.list_ports()
+                if ports:
+                    self.port_combo.addItems(ports)
+                    self.log(f"사용 가능한 포트: {', '.join(ports)}")
+                else:
+                    self.log("사용 가능한 포트가 없습니다.")
+            except Exception as e:
+                self.log(f"포트 검색 실패: {str(e)}")
+        else:
+            self.log("microbit 모듈이 로드되지 않았습니다.")
+
+    def connect_to_microbit(self):
+        if not microbit:
+            self.status_label.setText("microbit 모듈 없음")
+            self.log("microbit 모듈이 없습니다.")
+            return
+
+        port = self.port_combo.currentText()
+        try:
+            microbit.connect(port)
+            self.status_label.setText(f"연결됨 ({port})")
+            self.log(f"{port} 포트에 연결되었습니다.")
+            
+            # 연결 후 자동으로 응답 리스닝 시작
+            if not self.is_listening:
+                self.start_listening()
+                
+        except Exception as e:
+            self.status_label.setText(f"연결 실패")
+            self.log(f"연결 실패: {str(e)}")
+
+    def toggle_listening(self):
+        """응답 리스닝 토글"""
+        if self.is_listening:
+            self.stop_listening()
+        else:
+            self.start_listening()
+
+    def start_listening(self):
+        """응답 리스닝 시작"""
+        if not microbit or not microbit.is_connected():
+            self.log("마이크로비트가 연결되지 않았습니다.")
+            return
+            
+        try:
+            # microbit 모듈의 리스닝 시작
+            if hasattr(microbit, 'start_text_listening'):
+                microbit.start_text_listening(self.on_microbit_response)
+                self.is_listening = True
+                self.listen_button.setText("응답 리스닝 중지")
+                self.log("응답 리스닝이 시작되었습니다.")
+            else:
+                self.log("응답 리스닝 기능을 사용할 수 없습니다.")
+        except Exception as e:
+            self.log(f"리스닝 시작 실패: {str(e)}")
+
+    def stop_listening(self):
+        """응답 리스닝 중지"""
+        try:
+            if hasattr(microbit, 'stop_text_listening'):
+                microbit.stop_text_listening()
+            self.is_listening = False
+            self.listen_button.setText("응답 리스닝 시작")
+            self.log("응답 리스닝이 중지되었습니다.")
+        except Exception as e:
+            self.log(f"리스닝 중지 실패: {str(e)}")
+
+    def on_microbit_response(self, response):
+        """마이크로비트로부터 응답을 받았을 때 호출되는 콜백"""
+        if not response or response.strip() == "":
+            return
+            
+        self.received_text = response
+        self.receive_box.setPlainText(response)
+        self.log(f"응답 수신: {response}")
+        
+        # 출력 데이터 전송
+        domain = Orange.data.Domain([], metas=[Orange.data.StringVariable("Received")])
+        out_table = Orange.data.Table(domain, [[response]])
+        self.Outputs.received_data.send(out_table)
+
+    def check_response(self):
+        """타이머 기반 응답 확인 (백업 방법)"""
+        if not microbit or not microbit.is_connected():
+            return
+            
+        try:
+            # microbit 모듈에서 직접 응답 확인
+            if hasattr(microbit, '_connection') and microbit._connection and microbit._connection.in_waiting > 0:
+                response = microbit._connection.readline().decode('utf-8', errors='ignore').strip()
+                if response:
+                    self.log(f"타이머로 응답 감지: {response}")
+                    self.on_microbit_response(response)
+                    
+            # 추가 디버깅: 연결 상태 확인
+            if hasattr(microbit, '_connection') and microbit._connection:
+                # 연결 상태 로그 (1초마다 한 번씩만)
+                if not hasattr(self, '_last_debug_time'):
+                    self._last_debug_time = 0
+                
+                import time
+                current_time = time.time()
+                if current_time - self._last_debug_time > 1.0:  # 1초마다
+                    self._last_debug_time = current_time
+                    if microbit._connection.in_waiting > 0:
+                        self.log(f"대기 중인 데이터: {microbit._connection.in_waiting} bytes")
+                        
+        except Exception as e:
+            # 오류를 로그에 기록
+            self.log(f"응답 확인 오류: {str(e)}")
+
+    @Inputs.text_data
+    def set_text_data(self, data):
+        if isinstance(data, Orange.data.Table):
+            self.text_data = data
+            try:
+                # string-meta 변수에서 텍스트 추출
+                string_meta_indices = [
+                    idx for idx, var in enumerate(data.domain.metas)
+                    if isinstance(var, Orange.data.StringVariable)
+                ]
+                
+                if string_meta_indices:
+                    text_content = [
+                        " ".join(str(row.metas[idx]) for idx in string_meta_indices)
+                        for row in data
+                    ]
+                    text = "\n".join(text_content)
+                else:
+                    # 일반 데이터에서 텍스트 추출
+                    try:
+                        text = str(data[0][0])
+                    except (IndexError, AttributeError):
+                        # 데이터가 비어있거나 다른 형태인 경우
+                        text = str(data)
+                
+                self.log(f"입력 데이터를 수신했습니다: {text}")
+                
+                # 자동 전송이 활성화되어 있으면 즉시 전송
+                if self.auto_send_checkbox.isChecked():
+                    self.send_text_to_microbit(text)
+                else:
+                    # 수동 전송 모드면 입력창에 표시
+                    self.send_box.setPlainText(text)
+                    
+            except Exception as e:
+                self.log(f"입력 텍스트 추출 실패: {e}")
+                # 오류가 발생해도 데이터를 표시
+                try:
+                    text = str(data)
+                    self.log(f"원본 데이터: {text}")
+                    if self.auto_send_checkbox.isChecked():
+                        self.send_text_to_microbit(text)
+                    else:
+                        self.send_box.setPlainText(text)
+                except Exception as e2:
+                    self.log(f"데이터 표시 실패: {e2}")
+
+    def send_text_to_microbit(self, text: str):
+        if not text:
+            self.receive_box.setPlainText("전송할 텍스트가 없습니다.")
+            self.log("전송할 텍스트가 없습니다.")
+            return
+
+        if not microbit:
+            self.receive_box.setPlainText("[Error] microbit 모듈이 없습니다.")
+            self.log("microbit 모듈이 없습니다.")
+            return
+
+        if not microbit.is_connected():
+            self.receive_box.setPlainText("먼저 포트를 연결하세요.")
+            self.log("포트가 연결되지 않았습니다.")
+            return
+
+        try:
+            # 즉시 전송 (응답 대기 없음)
+            if hasattr(microbit, 'send_text'):
+                success = microbit.send_text(text)
+                if success:
+                    self.log(f"전송됨: {text}")
+                    # 응답 대기 시작
+                    self.wait_for_response()
+                else:
+                    self.log("전송 실패")
+            else:
+                # 기존 방식으로 전송
+                response = microbit.send_and_receive(text)
+                self.receive_box.setPlainText(response)
+                self.log(f"보냄: {text}")
+                self.log(f"수신: {response}")
+                
+                domain = Orange.data.Domain([], metas=[Orange.data.StringVariable("Received")])
+                out_table = Orange.data.Table(domain, [[response]])
+                self.Outputs.received_data.send(out_table)
+                
+        except Exception as e:
+            self.receive_box.setPlainText(f"[Error] {str(e)}")
+            self.log(f"전송 중 오류 발생: {str(e)}")
+
+    def wait_for_response(self):
+        """응답 대기 타이머 시작"""
+        # 기존 타이머가 있으면 중지
+        if hasattr(self, 'response_wait_timer'):
+            self.response_wait_timer.stop()
+            
+        # 응답 대기 타이머 설정 (3초 후 타임아웃)
+        self.response_wait_timer = QTimer()
+        self.response_wait_timer.timeout.connect(self.check_response_timeout)
+        self.response_wait_timer.start(3000)  # 3초로 단축
+        self.log("응답 대기 시작 (3초 타임아웃)")
+
+    def check_response_timeout(self):
+        """응답 대기 타임아웃 체크"""
+        if hasattr(self, 'response_wait_timer'):
+            self.response_wait_timer.stop()
+        self.log("응답 대기 타임아웃 - 응답이 없습니다.")
+        self.receive_box.setPlainText("응답 대기 타임아웃")
+        
+        # 타임아웃 결과도 출력으로 전송
+        domain = Orange.data.Domain([], metas=[Orange.data.StringVariable("Timeout")])
+        timeout_data = Orange.data.Table(domain, [["응답 대기 타임아웃"]])
+        self.Outputs.received_data.send(timeout_data)
+
+    def send_to_microbit(self):
+        text = self.send_box.toPlainText().strip()
+        self.send_text_to_microbit(text)

orangecontrib/orange3example/widgets/owwebcam.py

@@ -0,0 +1,82 @@
+from Orange.widgets.widget import OWWidget
+from Orange.widgets import gui
+from PyQt5.QtWidgets import QLabel, QPushButton, QVBoxLayout
+from PyQt5.QtGui import QPixmap, QImage
+from PyQt5.QtCore import QTimer
+import numpy as np
+import cv2
+
+try:
+    from orangecontrib.orange3example.utils import webcam
+except ImportError:
+    webcam = None
+
+class OWWebcam(OWWidget):
+    name = "Webcam Viewer"
+    description = "웹캠을 실시간으로 표시하고 이미지를 output으로 전송하는 위젯"
+    icon = "../icons/machine-learning-03-svgrepo-com.svg"
+    priority = 30
+
+    # Output signal 정의
+    outputs = [("Image", np.ndarray)]
+
+    def __init__(self):
+        super().__init__()
+
+        self.image_label = QLabel("웹캠이 시작되지 않았습니다.")
+        self.controlArea.layout().addWidget(self.image_label)
+
+        self.start_button = QPushButton("웹캠 시작")
+        self.stop_button = QPushButton("중지")
+
+        self.controlArea.layout().addWidget(self.start_button)
+        self.controlArea.layout().addWidget(self.stop_button)
+
+        self.start_button.clicked.connect(self.start_webcam)
+        self.stop_button.clicked.connect(self.stop_webcam)
+
+        self.timer = QTimer()
+        self.timer.timeout.connect(self.update_frame)
+        
+        # 웹캠 상태 추적
+        self.webcam_active = False
+
+    def start_webcam(self):
+        if webcam:
+            webcam.start_camera()
+            self.timer.start(30)  # 약 30 FPS
+            self.webcam_active = True
+
+    def stop_webcam(self):
+        self.timer.stop()
+        if webcam:
+            webcam.stop_camera()
+        self.webcam_active = False
+        self.image_label.setText("웹캠이 중지되었습니다.")
+        # 웹캠 중지 시 output 클리어
+        self.send("Image", None)
+
+    def update_frame(self):
+        if not webcam or not self.webcam_active:
+            return
+        frame = webcam.read_frame()
+        if frame is None:
+            return
+            
+        # 화면에 표시 (BGR 형식 그대로 사용)
+        frame_qimage = cvt_frame_to_qimage(frame)
+        pixmap = QPixmap.fromImage(frame_qimage)
+        self.image_label.setPixmap(pixmap)
+        
+        # output으로 프레임 전송 (BGR -> RGB 변환)
+        # OpenCV는 BGR 형식으로 읽으므로 RGB로 변환
+        frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        self.send("Image", frame_rgb)
+
+
+def cvt_frame_to_qimage(frame):
+    h, w, ch = frame.shape
+    bytes_per_line = ch * w
+    # OpenCV는 BGR 형식이므로 BGR888 사용
+    image = QImage(frame.data, w, h, bytes_per_line, QImage.Format_BGR888)
+    return image