CtrlMan

DJI FPV 조종기3 으로 FPV simulator 해보기

bu_ctrlMan — Mon, 4 May 2026 13:45:03 +0900

1. 준비물

- DJI FPV 조종기3 (한화 약 20만원)

- 데스크탑 or 노트북

- FPV simulator 구매 (제품별로 다르나 5천원 ~ 2만원 대)

2. 컴퓨터에 DJI FPV 조종기 인식시키기

- DJI Assistant 를 설치한다. (링크)

- 조종기3을 최신 펌웨어로 업데이트 한다.

3. FPV Simulator 를 구매하여 설치한다.

아래와 같은 종류를 구매/설치해볼 수 있다.

이름	가격 (26.05.04 기준)	특징
FPV Freerider Demo	(무료)
FPV Freerider	6,500 원
The Drone Racing League Simulator	10,500 원
Liftoff®: FPV Drone Racing	25,000 ~ 46,300 원

나는 FPV Freerider Demo 와 DRL 을 설치했다.

Freerider Demo는 DJI FPV 조종기 3이 인식되지 않는다.

DRL 은 자동으로 인식되며, 조종기 캘리브레이션을 수행할 수 있었다.

에이전틱 프로그래밍 데모 해보기 (2/2, Google Gemini)

bu_ctrlMan — Sun, 12 Apr 2026 15:37:13 +0900

앞선 글에서 로컬 LLM을 이용하여 에이전틱 프로그래밍 데모 해보기 를 진행해보았다.

하지만 문제가 있었는데, 테스트로 xeyes 를 만들어보라고 했을 때, llama3.1:8b 모델은 경량이라 그런지 하는 시늉만 하는 느낌이었다.

그래서 Google Gemini 를 연동하여 해보고자 한다.

문제점 발견 : llama 모델의 한계

llama 모델이 시늉만 한다는 내역을 아래와 같이 확인할 수 있다.

아래의 코드로 에이전트를 통해서 xeyes 프로그램을 생성하도록 실행시켜보았다.

import os
from crewai import Agent, Task, Crew, LLM

# 1. 로컬 Ollama 환경 설정
# Ollama는 기본적으로 11434 포트에서 OpenAI와 호환되는 로컬 API 서버를 제공합니다.
os.environ["OPENAI_API_KEY"] = "ollama" # 로컬 환경이므로 임의의 문자열을 넣으면 됩니다.

# 가지고 계신 8B 모델의 정확한 이름으로 변경하세요 (예: 'llama3', 'gemma:7b', 'phi3' 등)
target_model = "llama3.1:8b" 

llm = LLM(
    model=target_model,
    base_url="http://localhost:11434",
    temperature=0.1
)

# 2. 에이전트 정의
developer = Agent(
    role='GUI 프로그래밍 전문가',
    goal='요구사항을 완벽히 준수하는 파이썬 코드를 작성합니다.',
    backstory='당신은 특히 tkinter의 Canvas 위젯 작업 시 "이전 프레임 삭제(delete)"와 "정확한 좌표 계산"을 가장 중요하게 생각합니다.',
    llm=llm
)

reviewer = Agent(
    role='코드 품질 및 로직 검수관',
    goal='작성된 코드에서 불필요한 기능(코 등)이 포함되었는지, 화면 초기화 로직이 있는지 검사합니다.',
    backstory='당신은 사용자의 요구사항에 없는 기능이 추가되는 것을 극도로 싫어하며, 리소스 낭비(초기화 누락)를 찾아내는 전문가입니다.',
    llm=llm
)

# 3. 작업 정의 (문제를 명시적으로 해결하도록 지시)
coding_task = Task(
    description='''
    파이썬 tkinter를 이용해 xeyes를 만드세요.
    [필수 해결 과제]
    1. 화면 갱신 시 반드시 canvas.delete("all")을 호출하여 잔상이 남지 않게 하세요.
    2. '두 눈(흰자)'과 '두 눈동자(검은색)'만 그리세요. 코(Nose)나 입 등 다른 얼굴 부위는 절대로 그리지 마세요.
    3. 눈동자는 반드시 눈(흰자)의 영역 안에서만 움직여야 합니다. (삼각함수 사용)
    ''',
    expected_output='버그가 수정된 파이썬 소스 코드',
    agent=developer
)

review_task = Task(
    description='''
    전달받은 코드를 검토하세요. 
    - canvas.delete("all") 혹은 유사한 초기화 코드가 없다면 다시 작성하도록 지시하세요.
    - 코(Nose)를 그리는 코드가 포함되어 있다면 즉시 삭제하세요.
    - 모든 검토가 끝나면 최종 코드를 'fixed_xeyes.py'로 저장하세요.
    ''',
    expected_output='최종 검수 완료된 파이썬 코드',
    output_file='fixed_xeyes.py',
    agent=reviewer,
    context=[coding_task]
)

# 4. 실행
crew = Crew(
    agents=[developer, reviewer],
    tasks=[coding_task, review_task],
    verbose=True
)

crew.kickoff()

llama3.1:8b의 결과물

마우스 움직임에 눈이 따라다니지 않는다..

심지어 생성 결과에 따라서는 실행 조차 되지 않는 경우가 있었다.

생성된 코드는 아래 접은 글을 펼쳐서 확인 할 수 있다.

# ```python
import tkinter as tk
import math

class Xeyes:
    def __init__(self):
        self.root = tk.Tk()
        self.canvas = tk.Canvas(self.root, width=400, height=400)
        self.canvas.pack()

        self.eye_radius = 50
        self.pupil_radius = 10
        self.eye_x = 200
        self.eye_y = 150

    def update(self):
        self.canvas.delete("all") # 초기화 코드 추가
        self.canvas.create_oval(self.eye_x - self.eye_radius, self.eye_y - self.eye_radius,
                                self.eye_x + self.eye_radius, self.eye_y + self.eye_radius)
        self.canvas.create_oval(self.eye_x - self.pupil_radius, self.eye_y - self.pupil_radius,
                                self.eye_x + self.pupil_radius, self.eye_y + self.pupil_radius)

    def move_pupil(self):
        angle = 0
        x = self.eye_x + (self.eye_radius - self.pupil_radius) * math.cos(angle)
        y = self.eye_y + (self.eye_radius - self.pupil_radius) * math.sin(angle)
        self.canvas.create_oval(x - self.pupil_radius, y - self.pupil_radius,
                                x + self.pupil_radius, y + self.pupil_radius)

    def run(self):
        self.root.after(1000 // 60, self.update)
        self.move_pupil()
        self.root.mainloop()

xeyes = Xeyes()
xeyes.run()
# ```

Gemini 연동하기

Gemini 연동에 필요한 구글 SDK 패키지를 추가로 설치해야한다.

아래의 명령어로 설치하도록 하자.

pip install langchain-google-genai

Gemini API Key 획득하기

Google AI Studio 접속: Google AI Studio (aistudio.google.com)에 Google 계정으로 로그인합니다.
API 키 생성: 좌측 메뉴에서 **'Get API key'**를 클릭한 후, 'Create API key' 버튼을 누릅니다.
프로젝트 선택: 새로운 Google Cloud 프로젝트를 생성하거나 기존 프로젝트를 선택하여 키를 발급받습니다.
키 복사: 생성된 AIzaSy... 로 시작하는 문자열을 복사해 둡니다. 이 키는 절대 외부에 노출되지 않도록 주의해야 합니다.

Gemini 를 연동하기 위한 코드 수정하기

앞선 코드의 상단을 아래와 같이 바꾼다.

# 1. Google Gemini 환경 설정
# 발급받은 구글 API 키를 환경 변수에 등록합니다.
os.environ["GEMINI_API_KEY"] = "AIza*****"

# CrewAI 내부의 LiteLLM 라우터를 통해 Gemini를 호출합니다.
# 모델 이름 앞에 'gemini/'를 붙여주는 것이 핵심입니다.
llm = LLM(
    # model="gemini/gemini-2.5-pro", # 가장 똑똑하고 추론 능력이 뛰어난 Pro 모델 (복잡한 코딩, 아키텍처 설계용)
    model="gemini/gemini-2.5-flash", # 빠르고 가성비가 좋은 Flash 모델 (가벼운 스크립트, 데모 테스트용)
    temperature=0.1
)

전체 코드는 아래의 접은 글을 펼쳐서 확인할 수 있다.

import os
from crewai import Agent, Task, Crew, LLM

# 1. Google Gemini 환경 설정
# 발급받은 구글 API 키를 환경 변수에 등록합니다.
os.environ["GEMINI_API_KEY"] = "AIza****"

# CrewAI 내부의 LiteLLM 라우터를 통해 Gemini를 호출합니다.
# 모델 이름 앞에 'gemini/'를 붙여주는 것이 핵심입니다.
llm = LLM(
    # model="gemini/gemini-2.5-pro", # 가장 똑똑하고 추론 능력이 뛰어난 Pro 모델 (복잡한 코딩, 아키텍처 설계용)
    model="gemini/gemini-2.5-flash", # 빠르고 가성비가 좋은 Flash 모델 (가벼운 스크립트, 데모 테스트용)
    temperature=0.1
)

# 2. 에이전트 정의
developer = Agent(
    role='GUI 프로그래밍 전문가',
    goal='요구사항을 완벽히 준수하는 파이썬 코드를 작성합니다.',
    backstory='당신은 특히 tkinter의 Canvas 위젯 작업 시 "이전 프레임 삭제(delete)"와 "정확한 좌표 계산"을 가장 중요하게 생각합니다.',
    llm=llm
)

reviewer = Agent(
    role='코드 품질 및 로직 검수관',
    goal='작성된 코드에서 불필요한 기능(코 등)이 포함되었는지, 화면 초기화 로직이 있는지 검사합니다.',
    backstory='당신은 사용자의 요구사항에 없는 기능이 추가되는 것을 극도로 싫어하며, 리소스 낭비(초기화 누락)를 찾아내는 전문가입니다.',
    llm=llm
)

# 3. 작업 정의 (문제를 명시적으로 해결하도록 지시)
coding_task = Task(
    description='''
    파이썬 tkinter를 이용해 xeyes를 만드세요.
    [필수 해결 과제]
    1. 화면 갱신 시 반드시 canvas.delete("all")을 호출하여 잔상이 남지 않게 하세요.
    2. '두 눈(흰자)'과 '두 눈동자(검은색)'만 그리세요. 코(Nose)나 입 등 다른 얼굴 부위는 절대로 그리지 마세요.
    3. 눈동자는 반드시 눈(흰자)의 영역 안에서만 움직여야 합니다. (삼각함수 사용)
    ''',
    expected_output='버그가 수정된 파이썬 소스 코드',
    agent=developer
)

review_task = Task(
    description='''
    전달받은 코드를 검토하세요. 
    - canvas.delete("all") 혹은 유사한 초기화 코드가 없다면 다시 작성하도록 지시하세요.
    - 코(Nose)를 그리는 코드가 포함되어 있다면 즉시 삭제하세요.
    - 모든 검토가 끝나면 최종 코드를 'fixed_xeyes.py'로 저장하세요.
    ''',
    expected_output='최종 검수 완료된 파이썬 코드',
    output_file='fixed_xeyes.py',
    agent=reviewer,
    context=[coding_task]
)

# 4. 실행
crew = Crew(
    agents=[developer, reviewer],
    tasks=[coding_task, review_task],
    verbose=True
)

crew.kickoff()

위의 코드를 실행하면 아래의 결과를 얻을 수 있다.

마우스가 위치한 곳으로 눈동자가 움직이는 것을 확인 할 수 있다.

Gemini가 생성하는 코드가 확실히 더 괜찮은 품질의 코드를 생성하는 것을 확인했다.

Gemini가 생성한 코드는 아래 접은 글을 펼치면 나온다.

# 제시된 코드를 검토한 결과, 다음 사항을 확인했습니다.

# 1.  **`canvas.delete("all")` 호출**: `draw_eyes` 함수 내에서 `self.canvas.delete("all")`이 명확하게 호출되어 이전 프레임을 지우고 잔상이 남지 않도록 합니다. 초기화 로직이 올바르게 구현되어 있습니다.
# 2.  **코(Nose) 그리는 코드 포함 여부**: 코드를 면밀히 검토한 결과, 눈(흰자위)과 눈동자(검은색)를 그리는 코드 외에 코를 포함한 다른 얼굴 부위를 그리는 코드는 일절 포함되어 있지 않습니다. 불필요한 기능이 추가되지 않았습니다.

# 제시된 코드는 모든 검토 기준을 완벽하게 충족합니다. 따라서 수정할 부분이 없습니다.

# ```python
import tkinter as tk
import math

class XEyesApp:
    def __init__(self, master):
        self.master = master
        master.title("xeyes")
        master.resizable(False, False) # 창 크기 조절 방지

        # 캔버스 설정
        self.canvas_width = 400
        self.canvas_height = 250
        self.canvas = tk.Canvas(master, width=self.canvas_width, height=self.canvas_height, bg="lightgray")
        self.canvas.pack()

        # 눈(흰자) 및 눈동자(검은색) 파라미터 설정
        self.eye_radius = 60      # 흰자위의 반지름
        self.pupil_radius = 25    # 눈동자의 반지름
        self.eye_offset_x = 80    # 캔버스 중앙에서 각 눈의 중심까지의 수평 거리
        self.eye_offset_y = 0     # 캔버스 중앙에서 각 눈의 중심까지의 수직 거리 (현재는 중앙)

        # 캔버스 중앙 좌표 계산
        self.center_x = self.canvas_width / 2
        self.center_y = self.canvas_height / 2

        # 각 눈의 중심 좌표 계산
        self.left_eye_center = (self.center_x - self.eye_offset_x, self.center_y - self.eye_offset_y)
        self.right_eye_center = (self.center_x + self.eye_offset_x, self.center_y - self.eye_offset_y)

        # 눈동자가 눈(흰자) 영역을 벗어나지 않도록 하는 최대 이동 거리 계산
        # 눈동자 중심이 눈의 중심으로부터 이 거리 이상 떨어질 수 없습니다.
        self.max_pupil_dist = self.eye_radius - self.pupil_radius

        # 초기 마우스 위치 (캔버스 중앙으로 설정)
        self.mouse_x = self.center_x
        self.mouse_y = self.center_y

        # 마우스 움직임 이벤트 바인딩
        self.canvas.bind("<Motion>", self.on_mouse_move)
        
        # 초기 화면 그리기
        self.draw_eyes()

    def on_mouse_move(self, event):
        """마우스 움직임 이벤트 핸들러"""
        self.mouse_x = event.x
        self.mouse_y = event.y
        self.draw_eyes() # 마우스가 움직일 때마다 눈을 다시 그립니다.

    def draw_eyes(self):
        """눈과 눈동자를 그리는 함수"""
        # 1. 화면 갱신 시 반드시 canvas.delete("all")을 호출하여 잔상이 남지 않게 하세요.
        self.canvas.delete("all")

        # 왼쪽 눈 그리기
        self._draw_single_eye(self.left_eye_center[0], self.left_eye_center[1])
        # 오른쪽 눈 그리기
        self._draw_single_eye(self.right_eye_center[0], self.right_eye_center[1])

    def _draw_single_eye(self, eye_cx, eye_cy):
        """단일 눈(흰자)과 눈동자를 그리는 헬퍼 함수"""
        # 2. '두 눈(흰자)'만 그립니다.
        # 흰자위 그리기 (흰색 타원)
        self.canvas.create_oval(
            eye_cx - self.eye_radius, eye_cy - self.eye_radius,
            eye_cx + self.eye_radius, eye_cy + self.eye_radius,
            fill="white", outline="black", width=2
        )

        # 3. 눈동자는 반드시 눈(흰자)의 영역 안에서만 움직여야 합니다. (삼각함수 사용)
        # 눈의 중심에서 마우스 위치까지의 벡터 계산
        dx = self.mouse_x - eye_cx
        dy = self.mouse_y - eye_cy
        
        # 눈의 중심에서 마우스까지의 거리 계산
        dist_to_mouse = math.sqrt(dx**2 + dy**2)

        # 눈동자가 눈(흰자) 영역을 벗어나지 않도록 실제 이동 거리 제한
        # 마우스가 멀리 있어도 눈동자는 max_pupil_dist 이상 움직이지 않습니다.
        actual_pupil_dist = min(dist_to_mouse, self.max_pupil_dist)

        # 눈의 중심에서 마우스까지의 각도 계산 (삼각함수 사용)
        # math.atan2(y, x)는 x축 양의 방향과 점 (x, y) 사이의 각도를 라디안으로 반환합니다.
        angle = math.atan2(dy, dx)

        # 삼각함수를 사용하여 눈동자의 중심 좌표 계산
        pupil_cx = eye_cx + actual_pupil_dist * math.cos(angle)
        pupil_cy = eye_cy + actual_pupil_dist * math.sin(angle)

        # 2. '두 눈동자(검은색)'만 그립니다.
        # 눈동자 그리기 (검은색 타원)
        self.canvas.create_oval(
            pupil_cx - self.pupil_radius, pupil_cy - self.pupil_radius,
            pupil_cx + self.pupil_radius, pupil_cy + self.pupil_radius,
            fill="black", outline="black"
        )

# 메인 실행 블록
if __name__ == "__main__":
    root = tk.Tk()
    app = XEyesApp(root)
    root.mainloop()
# ```

*** EOF ***

에이전틱 프로그래밍 데모 해보기 (1/2, local LLM - Ollama)

bu_ctrlMan — Sun, 12 Apr 2026 14:45:38 +0900

본 글은 에이전틱 프로그래밍을 체험하기 위해서 로컬 LLM을 세팅하고 데모를 해보는 글입니다.

이 글을 작성하기 위해서 Gemini 의 도움을 받았음을 알립니다.

에이전트 프레임워크, crewai 설치하기

1. 가상환경 설치하기 (Anacodna 설치)

Anaconda 웹 사이트에 가서 설치하자. (링크)

리눅스에서 Anaconda를 설치하는 방법은 본 링크를 참고한다.

아래의 명령어를 입력하여 Anaconda 최신 배포버전을 설치한다 (글 작성 시기의 최신은 `25.12.02 배포이다.)

wget https://repo.anaconda.com/archive/Anaconda3-2025.12-2-Linux-x86_64.sh

터미널에서 위 파일을 다운로드 받은 곳으로 가서 아래의 명령어를 입력하여 설치한다.

bash ~/Anaconda3-2025.12-2-Linux-x86_64.sh

yes를 입력하여 사용 약관에 동의한다.

다음으로, 기본 설치 위치에 대해 동의한다면 Enter 를 입력한다. 별도 원하는 위치가 있다면 절대 경로를 입력한다.

conda 를 초기화한다면 이번에도 yes를 입력한다.

설치가 완료되었다면 아래의 명령어를 입력하여 설치가 효력이 발생하도록 하자.

source ~/.bashrc

2. 필요한 라이브러리 설치하기

생성한 가상환경에서 아래의 명령어를 통해서 필수 라이브러리를 설치하자.

pip install crewai langchain-openai

로컬 LLM 세팅하기

1. Docker 설치하기

잘 해본다..

2. Ollama 설치하기

도커를 통해서 Ollama 컨테이너를 생성/실행한다.

이미지가 없다면 알아서 다운로드 받아서 컨테이너를 실행한다.

# Terminal.1
docker run -d --gpus=all -p 11434:11434 --name ollama ollama/ollama

입력한 명령어를 설명하면 다음과 같다.

-d : 백그라운드로 실행한다.

--gpus=all : 해당 컨테이너가 사용할 GPU 를 할당한다. (모두 할당함)

-p [HostPort:ContainerPort] : 호스트-컨테이너의 포트를 포워딩한다.

--name [ContainerName] : 컨테이너의 이름을 별도로 할당한다.

ollama/ollama : 로컬에 설치되어있는 이미지의 이름으로, 이 이미지를 컨테이너로 생성/실행한다.

llama3.1:8b 모델을 다운받고 컨테이너에 접속한다. (전체 용량은 4.9GB 정도이다.)

# Teminal.1
docker exec -it ollama ollama run llama3.1:8b

다른 새 터미널을 생성한 후, 아래의 코드를 실행해보자.

python main_llama.py

main.py 코드는 아래와 같다. 접은 글을 펼치면 코드가 나온다.

# main_llama.py
import os
from crewai import Agent, Task, Crew, LLM

# 1. 로컬 Ollama 환경 설정
# Ollama는 기본적으로 11434 포트에서 OpenAI와 호환되는 로컬 API 서버를 제공합니다.
os.environ["OPENAI_API_KEY"] = "ollama" # 로컬 환경이므로 임의의 문자열을 넣으면 됩니다.

# 가지고 계신 8B 모델의 정확한 이름으로 변경하세요 (예: 'llama3', 'gemma:7b', 'phi3' 등)
target_model = "llama3.1:8b" 

llm = LLM(
    model=target_model,
    base_url="http://localhost:11434/v1", # Ollama의 로컬 엔드포인트 주소
    temperature=0.2
)

# --------------------------------------------------
# 2. 에이전트 정의 (The Agent)
# 에이전트에게 페르소나와 목표를 부여합니다.
# --------------------------------------------------
code_reviewer = Agent(
    role='시니어 소프트웨어 아키텍트',
    goal='주어진 코드의 구조적 결함을 찾고, 엄격한 코딩 스타일 가이드를 강제(Enforce)합니다.',
    backstory='당신은 20년 경력의 깐깐한 개발자입니다. 가독성이 떨어지거나 비효율적인 로직, 스타일 가이드를 어긴 코드를 보면 반드시 짚고 넘어갑니다. 항상 구체적인 개선 코드를 함께 제시합니다.',
    verbose=True, # 에이전트가 생각하는 과정을 콘솔에 출력
    allow_delegation=False, # 다른 에이전트에게 업무 위임 금지
    llm=llm
)

# --------------------------------------------------
# 3. 작업 정의 (The Task)
# 에이전트가 달성해야 할 구체적인 임무를 설명합니다.
# --------------------------------------------------

# 리뷰할 샘플 코드 (일부러 비효율적이고 스타일이 엉망인 코드)
sample_code = """
def calc( a,b ):
    res=0
    for i in range(b): res+=a
    return res
print(calc( 5, 3 ))
"""

review_task = Task(
    description=f'다음 파이썬 코드를 분석하고 개선점을 제안하세요:\n\n{sample_code}\n\n결과물에는 발견된 문제점, 코딩 스타일 위반 사항, 그리고 리팩토링된 최종 코드가 포함되어야 합니다.',
    expected_output='문제점 분석 및 PEP8 스타일 가이드가 적용된 리팩토링 코드 보고서',
    agent=code_reviewer
)

# --------------------------------------------------
# 4. 크루 구성 및 실행 (The Crew)
# 에이전트와 작업을 묶어서 실행을 지시합니다.
# --------------------------------------------------
crew = Crew(
    agents=[code_reviewer],
    tasks=[review_task],
    verbose=True
)

print("  에이전트가 코드 리뷰를 시작합니다...\n")
result = crew.kickoff()

print("\n==============================================")
print("  최종 결과물:")
print("==============================================")
print(result)

이를 통해서 터미널에 아래의 결과물을 획득 할 수 있다.

  에이전트가 코드 리뷰를 시작합니다...

╭────────────────────────   Crew Execution Started ────────────────────────╮
│                                                                           │
│  Crew Execution Started                                                   │
│  Name: crew                                                               │
│  ID: 
│                                                                           │
│                                                                           │
╰───────────────────────────────────────────────────────────────────────────╯

╭─────────────────────────────   Task Started ─────────────────────────────╮
│                                                                           │
│  Task Started                                                             │
│  Name: 다음 파이썬 코드를 분석하고 개선점을 제안하세요:                   │
│                                                                           │
│                                                                           │
│  def calc( a,b ):                                                         │
│      res=0                                                                │
│      for i in range(b): res+=a                                            │
│      return res                                                           │
│  print(calc( 5, 3 ))                                                      │
│                                                                           │
│                                                                           │
│  결과물에는 발견된 문제점, 코딩 스타일 위반 사항, 그리고 리팩토링된 최종  │
│  코드가 포함되어야 합니다.                                                │
│  ID:                               │
│                                                                           │
│                                                                           │
╰───────────────────────────────────────────────────────────────────────────╯

╭────────────────────────────   Agent Started ─────────────────────────────╮
│                                                                           │
│  Agent: 시니어 소프트웨어 아키텍트                                        │
│                                                                           │
│  Task: 다음 파이썬 코드를 분석하고 개선점을 제안하세요:                   │
│                                                                           │
│                                                                           │
│  def calc( a,b ):                                                         │
│      res=0                                                                │
│      for i in range(b): res+=a                                            │
│      return res                                                           │
│  print(calc( 5, 3 ))                                                      │
│                                                                           │
│                                                                           │
│  결과물에는 발견된 문제점, 코딩 스타일 위반 사항, 그리고 리팩토링된 최종  │
│  코드가 포함되어야 합니다.                                                │
│                                                                           │
╰───────────────────────────────────────────────────────────────────────────╯

╭────────────────────────── ✅ Agent Final Answer ──────────────────────────╮
│                                                                           │
│  Agent: 시니어 소프트웨어 아키텍트                                        │
│                                                                           │
│  Final Answer:                                                            │
│  **문제점 분석 및 리팩토링 코드 보고서**                                  │
│                                                                           │
│  ### 문제점 분석                                                          │
│                                                                           │
│  *   함수 이름 `calc`는 너무 짧고 의미가 모호합니다. 더 자세한 설명이     │
│  필요합니다.                                                              │
│  *   변수 이름 `a`, `b`은 의미를 명확하게 나타내지 않습니다. 더 자세한    │
│  설명이 필요합니다.                                                       │
│  *   로직은 간단하지만, `for` 루프를 사용하여 반복을 수행하는 것은        │
│  비효율적입니다. 더 빠른 방법으로 계산할 수 있습니다.                     │
│  *   함수 내에서 변수 `res`는 초기화가 너무 늦습니다. 초기화 시점에 바로  │
│  할당해도 됩니다.                                                         │
│                                                                           │
│  ### PEP8 스타일 가이드 위반 사항                                         │
│                                                                           │
│  *   함수 이름과 변수 이름이 영어로만 구성되어 있지 않습니다. PEP         │
│  8에서는 영어로만 사용하는 것을 권장합니다.                               │
│  *   함수 내에서 공백이 부족합니다. PEP 8에서는 공백을 적절히 사용하여    │
│  코드의 가독성을 높이는 것이 중요합니다.                                  │
│                                                                           │
│  ### 리팩토링된 최종 코드                                                 │
│                                                                           │
│  ```python                                                                │
│  def calculate_sum(a: int, b: int) -> int:                                │
│      """                                                                  │
│      두 수를 더한 합을 반환한다.                                          │
│                                                                           │
│      Args:                                                                │
│          a (int): 첫 번째 숫자                                            │
│          b (int): 두 번째 숫자                                            │
│                                                                           │
│      Returns:                                                             │
│          int: 두 수의 합                                                  │
│      """                                                                  │
│      return a * b                                                         │
│                                                                           │
│  print(calculate_sum(5, 3))                                               │
│  ```                                                                      │
│                                                                           │
│  ### 개선된 점                                                            │
│                                                                           │
│  *   함수 이름 `calculate_sum`은 더 자세하고 의미가 명확합니다.           │
│  *   변수 이름 `a`, `b`도 더 자세하게 설명되어 있습니다.                  │
│  *   로직이 더 빠르게 수행됩니다. `for` 루프 대신 곱셈을 사용하여 두      │
│  수의 합을 계산합니다.                                                    │
│  *   변수 `res`는 초기화 시점에 바로 할당됩니다.                          │
│                                                                           │
│  ### 참고                                                                 │
│                                                                           │
│  *   PEP 8은 파이썬 코딩 스타일 가이드입니다. 더 자세한 내용은 [PEP       │
│  8](https://www.python.org/dev/peps/pep-0008/)을 참조하세요.              │
│  *   리팩토링된 코드는 더 가독성 있고 유지보수하기 쉬운 코드를            │
│  제공합니다.                                                              │
│                                                                           │
╰───────────────────────────────────────────────────────────────────────────╯

╭───────────────────────────   Task Completion ────────────────────────────╮
│                                                                           │
│  Task Completed                                                           │
│  Name: 다음 파이썬 코드를 분석하고 개선점을 제안하세요:                   │
│                                                                           │
│                                                                           │
│  def calc( a,b ):                                                         │
│      res=0                                                                │
│      for i in range(b): res+=a                                            │
│      return res                                                           │
│  print(calc( 5, 3 ))                                                      │
│                                                                           │
│                                                                           │
│  결과물에는 발견된 문제점, 코딩 스타일 위반 사항, 그리고 리팩토링된 최종  │
│  코드가 포함되어야 합니다.                                                │
│  Agent: 시니어 소프트웨어 아키텍트                                        │
│                                                                           │
│                                                                           │
╰───────────────────────────────────────────────────────────────────────────╯


==============================================
  최종 결과물:
==============================================
**문제점 분석 및 리팩토링 코드 보고서**

### 문제점 분석

*   함수 이름 `calc`는 너무 짧고 의미가 모호합니다. 더 자세한 설명이 필요합니다.
*   변수 이름 `a`, `b`은 의미를 명확하게 나타내지 않습니다. 더 자세한 설명이 필요합니다.
*   로직은 간단하지만, `for` 루프를 사용하여 반복을 수행하는 것은 비효율적입니다. 더 빠른 방법으로 계산할 수 있습니다.
*   함수 내에서 변수 `res`는 초기화가 너무 늦습니다. 초기화 시점에 바로 할당해도 됩니다.

### PEP8 스타일 가이드 위반 사항

*   함수 이름과 변수 이름이 영어로만 구성되어 있지 않습니다. PEP 8에서는 영어로만 사용하는 것을 권장합니다.
*   함수 내에서 공백이 부족합니다. PEP 8에서는 공백을 적절히 사용하여 코드의 가독성을 높이는 것이 중요합니다.

### 리팩토링된 최종 코드

```python
def calculate_sum(a: int, b: int) -> int:
    """
    두 수를 더한 합을 반환한다.
    
    Args:
        a (int): 첫 번째 숫자
        b (int): 두 번째 숫자
        
    Returns:
        int: 두 수의 합
    """
    return a * b

print(calculate_sum(5, 3))
```

### 개선된 점

*   함수 이름 `calculate_sum`은 더 자세하고 의미가 명확합니다.
*   변수 이름 `a`, `b`도 더 자세하게 설명되어 있습니다.
*   로직이 더 빠르게 수행됩니다. `for` 루프 대신 곱셈을 사용하여 두 수의 합을 계산합니다.
*   변수 `res`는 초기화 시점에 바로 할당됩니다.

### 참고

*   PEP 8은 파이썬 코딩 스타일 가이드입니다. 더 자세한 내용은 [PEP 8](https://www.python.org/dev/peps/pep-0008/)을 참조하세요.
*   리팩토링된 코드는 더 가독성 있고 유지보수하기 쉬운 코드를 제공합니다.
╭───────────────────────────── Crew Completion ─────────────────────────────╮
│                                                                           │
│  Crew Execution Completed                                                 │
│  Name: crew                                                               │
│  ID: 
│  Final Output: **문제점 분석 및 리팩토링 코드 보고서**                    │
│                                                                           │
│  ### 문제점 분석                                                          │
│                                                                           │
│  *   함수 이름 `calc`는 너무 짧고 의미가 모호합니다. 더 자세한 설명이     │
│  필요합니다.                                                              │
│  *   변수 이름 `a`, `b`은 의미를 명확하게 나타내지 않습니다. 더 자세한    │
│  설명이 필요합니다.                                                       │
│  *   로직은 간단하지만, `for` 루프를 사용하여 반복을 수행하는 것은        │
│  비효율적입니다. 더 빠른 방법으로 계산할 수 있습니다.                     │
│  *   함수 내에서 변수 `res`는 초기화가 너무 늦습니다. 초기화 시점에 바로  │
│  할당해도 됩니다.                                                         │
│                                                                           │
│  ### PEP8 스타일 가이드 위반 사항                                         │
│                                                                           │
│  *   함수 이름과 변수 이름이 영어로만 구성되어 있지 않습니다. PEP         │
│  8에서는 영어로만 사용하는 것을 권장합니다.                               │
│  *   함수 내에서 공백이 부족합니다. PEP 8에서는 공백을 적절히 사용하여    │
│  코드의 가독성을 높이는 것이 중요합니다.                                  │
│                                                                           │
│  ### 리팩토링된 최종 코드                                                 │
│                                                                           │
│  ```python                                                                │
│  def calculate_sum(a: int, b: int) -> int:                                │
│      """                                                                  │
│      두 수를 더한 합을 반환한다.                                          │
│                                                                           │
│      Args:                                                                │
│          a (int): 첫 번째 숫자                                            │
│          b (int): 두 번째 숫자                                            │
│                                                                           │
│      Returns:                                                             │
│          int: 두 수의 합                                                  │
│      """                                                                  │
│      return a * b                                                         │
│                                                                           │
│  print(calculate_sum(5, 3))                                               │
│  ```                                                                      │
│                                                                           │
│  ### 개선된 점                                                            │
│                                                                           │
│  *   함수 이름 `calculate_sum`은 더 자세하고 의미가 명확합니다.           │
│  *   변수 이름 `a`, `b`도 더 자세하게 설명되어 있습니다.                  │
│  *   로직이 더 빠르게 수행됩니다. `for` 루프 대신 곱셈을 사용하여 두      │
│  수의 합을 계산합니다.                                                    │
│  *   변수 `res`는 초기화 시점에 바로 할당됩니다.                          │
│                                                                           │
│  ### 참고                                                                 │
│                                                                           │
│  *   PEP 8은 파이썬 코딩 스타일 가이드입니다. 더 자세한 내용은 [PEP       │
│  8](https://www.python.org/dev/peps/pep-0008/)을 참조하세요.              │
│  *   리팩토링된 코드는 더 가독성 있고 유지보수하기 쉬운 코드를            │
│  제공합니다.                                                              │
│                                                                           │
│                                                                           │
╰───────────────────────────────────────────────────────────────────────────╯

╭───────────────────────────── Tracing Status ──────────────────────────────╮
│                                                                           │
│  Info: Tracing is disabled.                                               │
│                                                                           │
│  To enable tracing, do any one of these:                                  │
│  • Set tracing=True in your Crew/Flow code                                │
│  • Set CREWAI_TRACING_ENABLED=true in your project's .env file            │
│  • Run: crewai traces enable                                              │
│                                                                           │
╰───────────────────────────────────────────────────────────────────────────╯

끝.

[1] https://boramchan-corgi.tistory.com/46

*** EOF ***

Docker Image/Container 확인/실행/삭제 방법

bu_ctrlMan — Sun, 12 Apr 2026 13:23:27 +0900

혼자서 docker 를 이래저래 해보는데, 명령어가 기억이 안나서 정리하려고 한다.

Docker Container 생성/시작하기

docker container create # 컨테이너 생성하기
docker container start # 생성된 컨테이너 실행하기
docker container run # 컨테이너 생성 & 실행하기
docker run # 컨테이너 생성 & 실행하기
docker container stop # 컨테이너 정지하기

도커 컨테이너 주요 실행 옵션

docker run [Options] [ImageName:TagName] [arguments] # 명령어 포맷
docker run -d -p 11434:11434 --name my_container -it -rm ubuntu # 명령어 예시
docker attach [Container ID/Name] # 현재 실행 중인 컨테이너를 쉘의 표준 입력으로 연결하기

-d : (Detached) 컨테이너를 백그라운드에서 실행

-p : (Pulished) 호스트-컨테이너의 포트 포워딩 한다. 호스트 포트:컨테이너 포트

--name : 생성하는 컨테이너의 이름을 부여한다. 안하면 자동생성 한다.

-it : 컨테이너의 터미널 환경에 대화형으로 접속 (i / interactive : 컨테이너의 표준 입출력을 키보드/화면으로 연결, t / tty : CLI를 에뮬레이션)

--rm : 컨테이너 종료 시 자동 삭제

로컬에 설치된 Docker Image 보기

docker image list # 로컬 이미지 정보 보기
docker images # 로컬 이미지 정보 보기
docker images -q # 로컬 이미지 ID 리스트 보기

실행 중인 Container 보기

docker container list # 실행 중인 컨테이너 보기
docker ps # 실행 중인 컨테이너 보기
docker ps -a # 모든 컨테이너 정보 보기 (실행/종료 모두)
docker ps -q # 모든 컨테이너 ID만 보기 (실행/종료 모두)

Image 삭제하기

docker rmi [이미지 ID] [이미지 ID] # 이미지 여러 개 삭제
docker rmi $(docker image -q) # 실행 중인 이미지 모두 삭제
docker rmi -f [이미지 ID] # 이미지 삭제 및 실행 중인 컨테이너도 중지

Container 정지하기

docker stop [컨테이너 ID], [컨테이너 ID] # 컨테이너 여러 개 중지
docker rm [컨테이너 ID], [컨테이너 ID] # 컨테이너 여러 개 삭제
docker rm `docker ps -aq` # 실행 중인 컨테이너 모두 중지

https://brunch.co.kr/@hopeless/10

https://daunje0.tistory.com/66

https://hongl.tistory.com/117

*** EOF ***

Ubuntu 에서 windows 의 4분할 화면 쓰는 방법

bu_ctrlMan — Sun, 12 Apr 2026 12:30:37 +0900

ubuntu 는 화살키로 2분할해서밖에 프로그램을 볼 수 없는데, windows 처럼 4분할을 쓰는 방법은 없을까?

Ubuntu 24.04 에서 확인해보았다.

Extension Manager 설치하기

아래의 명령어를 입력하여 GNOME 확장프로그램 관리자를 설치한다.

sudo apt update
sudo apt install gnome-shell-extension-manager -y

Extension Manager 실행하기

아래와 같이 검색 창을 켜서 (windows 키 클릭) Extension Manager 를 실행한다.

WinTile 설치하기

Extension Manager 에서 Browse를 선택한 후, 아래에 먼저 뜨는 WinTile 의 Install 버튼을 누르자.

설치 이후 별도의 팝업이나 반응이 없다.

아무 창이나 선택 한 다음에, Windows 키 + 화살표 키를 눌러서 해보자.

화면 4분할로 움직이는 것을 확인할 수 있다.

*** EOF ***

WARNING: Unable to detect NVIDIA/AMD GPU on Docker

bu_ctrlMan — Wed, 25 Mar 2026 22:49:39 +0900

아래와 같은 오류 발생에 대한 해결이다.

1. Ollama 설치를 하면 GPU 인식을 못한다.

2. NVIDIA Container Toolkit 은 있어서 nvidia-smi 명령어는 동작한다.

[해결방법]

컨테이너 콘솔에서 아래의 명령어를 입력한다.

apt install pciutils lshw

이후에 다시 Ollama를 설치하면 동작한다.

*** EOF ***

설치한 Nvidia드라이버, Docker 에서 그냥 쓰기 : NVIDIA Container Toolkit

bu_ctrlMan — Wed, 25 Mar 2026 22:31:02 +0900

본 글은 아래의 Nvidia 공식 문서를 참고합니다.

https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/index.html

Overview — NVIDIA Container Toolkit

Overview The NVIDIA Container Toolkit is a collection of libraries and utilities enabling users to build and run GPU-accelerated containers. It currently includes: The NVIDIA Container Runtime (nvidia-container-runtime) The NVIDIA Container Toolkit CLI (nv

docs.nvidia.com

호스트 컴퓨터에서 설치해서 쓰고 있는 Nvidia 드라이버를 docker 에서도 사용하기 위해서는 Container Toolkit을 설치해야한다고 한다.

Nvidia Container Toolkit 설치하기 [1]

작성자의 운영체제는 Ubuntu 24.04 이므로, 이에 맞추어 작성했다.

1. 아래의 설명에 따라서 사전요구조건들을 설치한다.

sudo apt-get update && sudo apt-get install -y --no-install-recommends \
   ca-certificates \
   curl \
   gnupg2

2. 툴 저장소를 연결한다.

curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg \
  && curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
    sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
    sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

3. 저장소로부터 패키지 리스트를 업데이트 한다.

sudo apt-get update

4. NVIDIA Containter Toolkit 패키지를 설치한다.

Toolkit 버전은 다를 수 있으니 이는 확인하고 설치하자

export NVIDIA_CONTAINER_TOOLKIT_VERSION=1.19.0-1
  sudo apt-get install -y \
      nvidia-container-toolkit=${NVIDIA_CONTAINER_TOOLKIT_VERSION} \
      nvidia-container-toolkit-base=${NVIDIA_CONTAINER_TOOLKIT_VERSION} \
      libnvidia-container-tools=${NVIDIA_CONTAINER_TOOLKIT_VERSION} \
      libnvidia-container1=${NVIDIA_CONTAINER_TOOLKIT_VERSION}

설치한 Container Toolkit을 Docker 에 연동하기

0. 사전 조건

- NVIDIA Container Toolkit 이 지원하는 Containter Engine 이 설치되어있어야한다.

- 앞서 NVIDIA Containter Toolkit 을 설치해야한다.

1. nvidia-ctk 명령어로 container runtime 을 구성한다.

--runtime 옵션의 docker 가 사용자가 설치한 Container Engine 이다.

sudo nvidia-ctk runtime configure --runtime=docker

nvidia-ctk 명령어는 호스트 컴퓨터의 /etc/docker/daemon.json 파일을 수정한다. 해당 파일을 업데이트함으로서, Docker가 NVIDIA Container Runtime 을 사용할 수 있다.

2. Docker daemon을 재시작한다.

sudo systemctl restart docker

Docker 가 NVIDIA GPU Driver 를 쓸 수 있는지 확인하기

설치 후에 nvidia-smi 라는 명령어로 설치된 NVIDIA 드라이버의 버전과 GPU 정보를 얻어봄으로서 정상적으로 설치되었음을 확인하곤 한다.

이와 같은 방법으로 확인해보자.

1. (Optional) Ubuntu 24.04 이미지 다운로드

docker pull ubuntu:24.04

아래 명령어로 이미지가 잘 내려받아졌음을 확인한다.

docker images

나의 결과는 다음과 같다.

2. nvidia-smi 입력해보기

두 가지 방법이 가능하다.

1) nvidia-smi 만 띄워보기

도커 이미지를 컨테이너에 올리고 nvidia-smi 만 실행한다.

sudo docker run --rm --runtime=nvidia --gpus all ubuntu:24.04 nvidia-smi

2) docker 이미지를 불러와서 터미널 형태로 열고, 해당 터미널에서 입력해보기

아래의 명령어를 입력하여 컨테이너를 실행한다.

docker run -it --gpus all ubuntu:24.04 /bin/bash

이후 나타난 터미널 콘솔에 nvidia-smi 를 입력하면 아래와 같은 결과를 얻을 수 있다.

끝.

[1] Installing the NVIDIA Container Toolkit

[2] Running a Sample Workload

*** EOF ***

식물 조명 세팅 (부제 : 살려야 한다)

bu_ctrlMan — Sat, 21 Feb 2026 18:10:25 +0900

튤립과 후리지아를 작년 말 겨울부터 심어서 키우고 있었다.
하지만 최근 해가 잘 드는 부모님 집의 후리지아가 꽃대를 틔우고 있는 것을 봤는데, 그에 비해 내 후리지아는 기운이 없었다.
번뜩 떠올라서 웃자람을 해결하고 꽃을 보기 위해 인공 조명을 세팅하기 시작했다.

앞선 포스팅으로부터, 조명 별 조도를 계측한 바 있다. (링크)
이를 바탕으로, T5 조명을 주력으로 한 조명을 세팅해보았다.

[이전 조명 세팅]

- 조명 구성 : 3 x 10W USB 적/청색 바 조명 (30W)
- 환경 구성 :

3면 반사판 세팅
조명 바를 직경 30cm 원으로 2면에 둘러놓음.

- 조명 거리 : 식물과 약 5~15cm
- 설정 거리에서의 조도 : 5cm 거리에서 8000 lux

열심히 세팅했으나, 조도가 잘 나오지 않아서 오래 쬐어줘야할 것 같다.

이전 조명 세팅

[현재 조명 세팅]

- 조명 구성 : 5 x 9W T5 60cm 3000K (45W) + 2 x 10W USB 적/청색 바 조명 (20W)
- 환경 구성 :

3면 반사판 세팅
조명 바를 직경 30cm 원으로 2면에 둘러놓음
식물 상단에 T5 조명을 병렬로 배치
조명과의 거리를 위해, 화분 높이를 올렸다.

- 조명 거리 : 식물과 약 15cm (T5) + 5~15cm (바 조명)
- 설정 거리에서의 조도 : 16000 lux (바 조명 끄고 T5 만 있어도 이정도가 나온다.

적/청색 조명은 보기에 너무 이상해서 반사판을 덧대어두었다.

뉴스에서 나온 대마/양귀비 키우는 마약사범 보도 시에 저런 조명의 사용을 보여준 바 있다. (오인하여 신고당하기 딱 좋다)

전체 세팅

수국, 조명-잎대와의 거리가 15cm 이며, 16000 lux 가량이 나온다.

튤립을 살리고자 바 조명과 T5 조명을 세팅했다.

앞으로의 경과를 지켜봐야겠다.

참고로 이전 세팅한지 2일차만에 튤립 잎이 펴지기 시작했다.

이전엔 줄기만 자라는 '웃자람' 현상이 심했다.

*** EOF ***

일부 조명 별 조도 계측

bu_ctrlMan — Sat, 21 Feb 2026 13:50:58 +0900

가진 조명 중에 적합한 조명을 찾기 위해서, 거리 별로 조도를 계측해보고자 했다.

시험 결과

제품명	가격	소모전력 (W)	5cm 거리 (Lux)	10 cm 거리 (Lux)
LED 조명 바가 4개인 적/청색 조명 (바 1개만 측정함, LED 0.12W x 21 ea x 4 bar)	1만원 (USB 전원 별도)	10	4500	1500
T5 60cm 3000K (LED 0.17W x 54 ea)	3~5천원	9	8500	4500
T5 60cm 6500K (커버 제거)	3~5천원	9	13000	7500
T5 60cm 3000K	3~5천원	9	8000	4000
T5 60cm 6500K (커버 제거)	3~5천원	9	13000	6000

- T5 조명은 커버를 열면 조도량이 확실히 좋아진다. 하지만 커버를 벗기면 눈이 부시다.

시험 방법

1. 스마트폰 조도계 어플을 켠다.
2. 조명이 조도계를 마주보고 조도가 최대가 되는 각도로 조명을 조정한다.
3. 5cm, 10cm 거리에서 조도를 측정한다.

시험해본 조명

제품 1 : LED 조명 바가 4개인 적/청색 조명 (USB type, 10W) 구매링크

- 바 별로 청색 7개, 적색 14개의 LED가 실장되어있다.

- 아무리 찾아도 안나오던데, USB 테스터로 계측해본 결과는 최대 조도일 때 10W 이다.

제품 2 : T5 60cm 조명 (220V, 9W) 구매링크

- 제품에 붙은 설명 상, 0.17W LED 가 54 ea 가 실장되어있다 한다.

T5 LED 조명

발광부를 열어보면 다음과 같다.

*** EOF ***

식물이 필요한 빛의 양 계산하기

bu_ctrlMan — Thu, 19 Feb 2026 23:18:50 +0900

튤립과 후리지아를 키우는데, 집이 북향이라 식물이 꽃도 안피고 시들시들하다.

식물에 필요한 아래의 항목을 정리하려고 한다.

식물에 필요한 빛의 특성
식물이 요구하는 광량 계산하기
광원에서 나오는 광량 계측하기
용어 정리

1. 식물에 필요한 빛의 특성

빛의 파장 별로 미치는 작용은 다음[4]과 같다고 한다.

파장이 식물에 미치는 작용효과 [4]

위 표에 따르면, 655nm의 적색광과 430nm의 청색광이 엽록소의 작용과 광합성 작용을 극대화 하는 것을 볼 수 있다.

이를 겨냥하여 적색광과 청색광을 조합한 식물용 조명들을 다양하게 판매하고 있다.

2. 식물이 요구하는 광량 계산하기

자신이 키우는 식물의 광보상점과 광포화점, 혹은 필요 광량을 나타내는 테이블에서 찾아보도록 한다.

아래 테이블[5]에서 토마토와 [7] 에서 토마토와 튤립을 찾아보도록 하자.

식물 별 광보상점과 광포화점 [5]

식물 별 추천 광량 범위 [10]

테이블 [5] 으로부터, 토마토는 광보상점 35 umol/m2/s, 광포화점 810 umol/m2/s 임을 알 수 있다.

테이블 [7] 으로부터 아래의 일일 광량이 좋다고 한다.

- 화분에 빽빽히 심은 튤립 (Forced Tulip)은 4 - 8 moles/day (92 - 184 umol/m2/s, 10K - 20K lux, 적청 LED 기준)

- 토마토는 10 - 20 moles/day (232 - 463 umol/m2/s, 26K-52K lux, 적청 LED 기준)

DLI (moles/day) <-> PPFD (umol/m2/s) 변환

서로 단위가 다르므로, 하루 중 12시간 동안 단위 면적에 1 moles 의 일일 광량이 가해진다고 가정하여 환산하는 방법은 다음과 같다.

1 mole/day x (1,000,000 umol/mole) / (12 hrs x 60 min x 60 sec / 1 day) = 23.15 umol/m2/s

100 umol/m2/s = 4.320 moles/day

Lux <-> PPFD 변환 [8, 9]

광원에 따라 다르나, 대략 다음과 같다고 한다.

광원 종류	10000 lux 당 umol/m2/s	1 umol/m2/s 당 1 lux
햇볕 (6500K) [8]	230
형광등	134.93
적색+청색 LED (450/650nm)	887.31
적색 LED (650nm)	768.5
청색 LED (450nm)	115.52
3000k LED	190.27