# Homebrew 설치 (이미 있다면 넘어가세요)
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# Elixir 설치
brew install elixir

# fwup 설치 (펌웨어 업데이트 도구)
brew install fwup

# squashfs 도구 설치 (파일 시스템 관련)
brew install squashfs

# Nerves 부트스트랩 설치
mix local.hex
mix local.rebar
mix archive.install hex nerves_bootstrap
      

# 필요한 패키지 설치
sudo apt-get update
sudo apt-get install build-essential automake autoconf git squashfs-tools ssh-askpass pkg-config curl

# Erlang 저장소 추가 및 설치
wget https://packages.erlang-solutions.com/erlang-solutions_2.0_all.deb
sudo dpkg -i erlang-solutions_2.0_all.deb
sudo apt-get update
sudo apt-get install esl-erlang elixir

# fwup 설치
sudo apt-get install fwup

# Nerves 부트스트랩 설치
mix local.hex
mix local.rebar
mix archive.install hex nerves_bootstrap
      

# 1. Chocolatey 패키지 매니저 설치 (PowerShell 관리자 권한으로)
Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))

# 2. Elixir 설치
choco install elixir

# 3. fwup 설치
choco install fwup

# 4. Nerves 부트스트랩 설치 (명령 프롬프트에서)
mix local.hex
mix local.rebar
mix archive.install hex nerves_bootstrap
      

# Elixir 버전 확인
elixir --version

# 출력 예시:
# Erlang/OTP 26 [erts-14.0] [source] [64-bit] [smp:8:8] [ds:8:8:10] [async-threads:1] [jit]
# Elixir 1.16.0 (compiled with Erlang/OTP 26)

# Nerves 부트스트랩 확인
mix nerves.info

# 출력 예시:
# Nerves environment
# ------------------------------
# Nerves Package: nerves_bootstrap
# Nerves Package: nerves
# ...
      

# 새 Nerves 프로젝트 생성
mix nerves.new hello_nerves

# 생성된 디렉토리로 이동
cd hello_nerves
      

# 지원되는 타겟 목록 확인
mix nerves.system.list
      

# Linux/macOS에서
export MIX_TARGET=rpi4

# Windows에서 (PowerShell)
$env:MIX_TARGET = "rpi4"
      

# 의존성 설치
mix deps.get
      

defmodule HelloNerves do
  @moduledoc """
  첫 번째 Nerves 애플리케이션
  """
  require Logger
  
  @doc """
  애플리케이션 시작 함수
  """
  def start(_type, _args) do
    # 로그 메시지 출력
    Logger.info("Hello from Nerves! 🎉")
    
    # 기본 정보 출력
    Logger.info("Running on #{Nerves.Runtime.KV.get_active_partition()}")
    Logger.info("Firmware version: #{Nerves.Runtime.KV.get("nerves_fw_version")}")
    
    # 5초마다 메시지 출력하는 태스크 시작
    Task.start(fn -> periodic_hello() end)
    
    # 슈퍼바이저 트리 시작
    children = []
    Supervisor.start_link(children, strategy: :one_for_one, name: HelloNerves.Supervisor)
  end
  
  defp periodic_hello do
    Logger.info("Still alive! System time: #{:os.system_time(:second)}")
    Process.sleep(5000)  # 5초 대기
    periodic_hello()     # 재귀 호출
  end
end
      

# 펌웨어 빌드
mix firmware
      

# SD 카드에 펌웨어 굽기
mix firmware.burn
      

def deps do
  [
    # 기존 의존성들...
    {:circuits_gpio, "~> 1.0"}  # GPIO 제어 라이브러리
  ]
end
      

mix deps.get
      

defmodule HelloNerves.Blinky do
  @moduledoc """
  LED를 깜빡이는 모듈
  """
  use GenServer
  require Logger
  alias Circuits.GPIO
  
  # 라즈베리 파이의 GPIO 핀 번호 (BCM 기준)
  # 라즈베리 파이 4의 경우 GPIO 23번 핀 사용
  @led_pin 23
  @on_duration 500   # LED ON 시간 (ms)
  @off_duration 500  # LED OFF 시간 (ms)
  
  def start_link(opts \\ []) do
    GenServer.start_link(__MODULE__, opts, name: __MODULE__)
  end
  
  @impl true
  def init(_opts) do
    # GPIO 핀 초기화
    {:ok, gpio} = GPIO.open(@led_pin, :output)
    
    # 초기 상태는 꺼진 상태
    GPIO.write(gpio, 0)
    
    # 타이머 시작
    schedule_toggle()
    
    Logger.info("Blinky started on GPIO pin #{@led_pin}")
    
    {:ok, %{gpio: gpio, state: 0}}
  end
  
  @impl true
  def handle_info(:toggle, %{gpio: gpio, state: state} = data) do
    # 현재 상태의 반대로 토글
    new_state = 1 - state
    GPIO.write(gpio, new_state)
    
    # 다음 토글 예약
    duration = if new_state == 1, do: @on_duration, else: @off_duration
    schedule_toggle(duration)
    
    {:noreply, %{data | state: new_state}}
  end
  
  defp schedule_toggle(duration \\ @on_duration) do
    Process.send_after(self(), :toggle, duration)
  end
end
      

def start(_type, _args) do
  # 로그 메시지 출력
  Logger.info("Hello from Nerves! 🎉")
  
  # 기본 정보 출력
  Logger.info("Running on #{Nerves.Runtime.KV.get_active_partition()}")
  Logger.info("Firmware version: #{Nerves.Runtime.KV.get("nerves_fw_version")}")
  
  # 5초마다 메시지 출력하는 태스크 시작
  Task.start(fn -> periodic_hello() end)
  
  # 슈퍼바이저 트리 시작
  children = [
    # Blinky 모듈 추가
    HelloNerves.Blinky
  ]
  Supervisor.start_link(children, strategy: :one_for_one, name: HelloNerves.Supervisor)
end
      

mix firmware
mix firmware.burn  # 또는 mix firmware.push nerves.local
      

defmodule HelloNerves.Button do
  use GenServer
  require Logger
  alias Circuits.GPIO
  
  # 버튼이 연결된 GPIO 핀 번호
  @button_pin 17
  
  def start_link(opts \\ []) do
    GenServer.start_link(__MODULE__, opts, name: __MODULE__)
  end
  
  @impl true
  def init(_opts) do
    # GPIO 핀을 입력 모드로 초기화
    # :input - 입력 모드
    # :pullup - 내부 풀업 저항 활성화
    {:ok, gpio} = GPIO.open(@button_pin, :input, pull_mode: :pullup)
    
    # 인터럽트 설정: 버튼 상태가 변경될 때마다 메시지 수신
    # :both - 상승 에지와 하강 에지 모두 감지
    GPIO.set_interrupts(gpio, :both)
    
    Logger.info("Button module initialized on GPIO pin #{@button_pin}")
    
    {:ok, %{gpio: gpio}}
  end
  
  # 인터럽트 메시지 처리
  @impl true
  def handle_info({:circuits_gpio, @button_pin, _timestamp, value}, state) do
    # 풀업 저항 사용 시 버튼을 누르면 0, 떼면 1이 됨
    button_state = if value == 0, do: "pressed", else: "released"
    Logger.info("Button #{button_state}!")
    
    # 버튼이 눌렸을 때 특정 작업 수행
    if value == 0 do
      do_something_when_pressed()
    end
    
    {:noreply, state}
  end
  
  defp do_something_when_pressed do
    # 버튼이 눌렸을 때 수행할 작업
    Logger.info("Performing action on button press...")
    # 예: LED 상태 토글, 데이터 저장, 네트워크 요청 등
  end
end
      

# mix.exs에 의존성 추가
def deps do
  [
    # 기존 의존성들...
    {:circuits_i2c, "~> 1.0"}
  ]
end
      

defmodule HelloNerves.BME280 do
  use GenServer
  require Logger
  alias Circuits.I2C
  
  # BME280 센서의 I2C 주소
  @sensor_address 0x76
  
  # BME280 레지스터 주소
  @reg_temp_msb 0xFA
  @reg_temp_lsb 0xFB
  @reg_temp_xlsb 0xFC
  @reg_ctrl_meas 0xF4
  
  def start_link(opts \\ []) do
    GenServer.start_link(__MODULE__, opts, name: __MODULE__)
  end
  
  @impl true
  def init(_opts) do
    # I2C 버스 열기 (라즈베리 파이에서는 보통 "i2c-1")
    {:ok, i2c} = I2C.open("i2c-1")
    
    # 센서 초기화
    initialize_sensor(i2c)
    
    # 주기적으로 온도 읽기 시작
    schedule_reading()
    
    Logger.info("BME280 sensor initialized on I2C bus")
    
    {:ok, %{i2c: i2c, last_temp: nil}}
  end
  
  @impl true
  def handle_info(:read_temperature, %{i2c: i2c} = state) do
    # 온도 읽기
    temp = read_temperature(i2c)
    Logger.info("Current temperature: #{temp}°C")
    
    # 다음 읽기 예약
    schedule_reading()
    
    {:noreply, %{state | last_temp: temp}}
  end
  
  # 현재 온도 값 가져오기 (외부 API)
  def get_temperature do
    GenServer.call(__MODULE__, :get_temperature)
  end
  
  @impl true
  def handle_call(:get_temperature, _from, %{last_temp: temp} = state) do
    {:reply, temp, state}
  end
  
  # 센서 초기화
  defp initialize_sensor(i2c) do
    # 측정 모드 설정 (온도, 압력, 습도 모두 활성화)
    I2C.write(i2c, @sensor_address, <<@reg_ctrl_meas, 0x27>>)
    Process.sleep(100)  # 초기화 대기
  end
  
  # 온도 읽기 (간단한 구현, 실제로는 보정 필요)
  defp read_temperature(i2c) do
    # 온도 데이터 읽기
    {:ok, <<msb>>} = I2C.write_read(i2c, @sensor_address, <<@reg_temp_msb>>, 1)
    {:ok, <<lsb>>} = I2C.write_read(i2c, @sensor_address, <<@reg_temp_lsb>>, 1)
    {:ok, <<xlsb>>} = I2C.write_read(i2c, @sensor_address, <<@reg_temp_xlsb>>, 1)
    
    # 원시 온도 값 계산 (실제로는 더 복잡한 보정 필요)
    raw_temp = (msb <<< 12) ||| (lsb <<< 4) ||| (xlsb >>> 4)
    
    # 간단한 변환 (실제 BME280은 더 복잡한 보정 필요)
    (raw_temp / 100.0) - 5.0  # 예시 변환, 실제와 다를 수 있음
  end
  
  # 주기적 읽기 예약
  defp schedule_reading do
    Process.send_after(self(), :read_temperature, 5000)  # 5초마다
  end
end
      </xlsb></lsb></msb>

# mix.exs에 의존성 추가
def deps do
  [
    # 기존 의존성들...
    {:circuits_spi, "~> 1.0"}
  ]
end
      

defmodule HelloNerves.OLED do
  use GenServer
  require Logger
  alias Circuits.SPI
  alias Circuits.GPIO
  
  # SPI 설정
  @spi_device "spidev0.0"
  @spi_speed_hz 8_000_000
  
  # GPIO 핀 설정
  @dc_pin 24    # 데이터/명령 선택 핀
  @reset_pin 25 # 리셋 핀
  
  # 디스플레이 설정
  @width 128
  @height 64
  
  def start_link(opts \\ []) do
    GenServer.start_link(__MODULE__, opts, name: __MODULE__)
  end
  
  @impl true
  def init(_opts) do
    # SPI 열기
    {:ok, spi} = SPI.open(@spi_device, speed_hz: @spi_speed_hz)
    
    # GPIO 핀 초기화
    {:ok, dc_gpio} = GPIO.open(@dc_pin, :output)
    {:ok, reset_gpio} = GPIO.open(@reset_pin, :output)
    
    # 디스플레이 초기화
    initialize_display(spi, dc_gpio, reset_gpio)
    
    # 버퍼 초기화 (모두 0으로)
    buffer = :binary.copy(<<0>>, @width * @height ÷ 8)
    
    # 테스트 텍스트 표시
    buffer = draw_text(buffer, "Hello, Nerves!", 0, 0)
    display_buffer(spi, dc_gpio, buffer)
    
    Logger.info("OLED display initialized")
    
    {:ok, %{spi: spi, dc_gpio: dc_gpio, reset_gpio: reset_gpio, buffer: buffer}}
  end
  
  # 텍스트 표시 (외부 API)
  def display_text(text, x \\ 0, y \\ 0) do
    GenServer.cast(__MODULE__, {:display_text, text, x, y})
  end
  
  @impl true
  def handle_cast({:display_text, text, x, y}, %{spi: spi, dc_gpio: dc_gpio, buffer: buffer} = state) do
    # 버퍼 클리어
    new_buffer = :binary.copy(<<0>>, @width * @height ÷ 8)
    
    # 텍스트 그리기
    new_buffer = draw_text(new_buffer, text, x, y)
    
    # 디스플레이에 표시
    display_buffer(spi, dc_gpio, new_buffer)
    
    {:noreply, %{state | buffer: new_buffer}}
  end
  
  # 디스플레이 초기화 (간소화된 버전)
  defp initialize_display(spi, dc_gpio, reset_gpio) do
    # 리셋
    GPIO.write(reset_gpio, 0)
    Process.sleep(10)
    GPIO.write(reset_gpio, 1)
    Process.sleep(100)
    
    # 초기화 명령 시퀀스 (SSD1306 기준)
    commands = [
      0xAE,   # 디스플레이 끄기
      0xD5, 0x80, # 클럭 설정
      0xA8, 0x3F, # 멀티플렉스 비율
      0xD3, 0x00, # 디스플레이 오프셋
      0x40,   # 시작 라인
      0x8D, 0x14, # 차지 펌프
      0x20, 0x00, # 메모리 모드
      0xA1,   # 세그먼트 리맵
      0xC8,   # COM 스캔 방향
      0xDA, 0x12, # COM 핀 설정
      0x81, 0xCF, # 콘트라스트
      0xD9, 0xF1, # 프리차지 기간
      0xDB, 0x40, # VCOMH 레벨
      0xA4,   # 전체 표시 끄기
      0xA6,   # 정상 표시
      0xAF    # 디스플레이 켜기
    ]
    
    # 명령 전송
    Enum.each(commands, fn cmd ->
      GPIO.write(dc_gpio, 0)  # 명령 모드
      SPI.transfer(spi, <<cmd>>)
    end)
  end
  
  # 버퍼를 디스플레이에 표시
  defp display_buffer(spi, dc_gpio, buffer) do
    # 페이지 주소 설정
    GPIO.write(dc_gpio, 0)  # 명령 모드
    SPI.transfer(spi, <<0x22, 0, 7>>)  # 페이지 주소 0-7
    
    # 열 주소 설정
    GPIO.write(dc_gpio, 0)  # 명령 모드
    SPI.transfer(spi, <<0x21, 0, 127>>)  # 열 주소 0-127
    
    # 데이터 전송
    GPIO.write(dc_gpio, 1)  # 데이터 모드
    SPI.transfer(spi, buffer)
  end
  
  # 텍스트 그리기 (매우 간소화된 버전)
  defp draw_text(buffer, text, x, y) do
    # 실제 구현에서는 폰트 데이터와 함께 텍스트를 비트맵으로 변환
    # 여기서는 간소화를 위해 더미 데이터 사용
    
    # 텍스트 길이에 비례하는 패턴 생성
    pattern = for _i <- 1..String.length(text), do: 0x7F
    pattern_binary = :binary.list_to_bin(pattern)
    
    # 버퍼의 특정 위치에 패턴 삽입 (실제로는 더 복잡함)
    buffer_size = byte_size(buffer)
    offset = y * (@width ÷ 8) + x
    
    if offset < buffer_size do
      pattern_size = byte_size(pattern_binary)
      copy_size = min(pattern_size, buffer_size - offset)
      
      <<:binary-size _::binary-size post::binary>> = buffer
      <<:binary pattern_binary::binary-size post::binary>>
    else
      buffer
    end
  end
end
      </:binary></:binary-size></cmd>

defmodule HelloNerves.Hardware do
  @moduledoc """
  하드웨어 추상화 레이어
  """
  
  # 하드웨어 구성 정보
  @hardware_config %{
    led: %{pin: 23, type: :output},
    button: %{pin: 17, type: :input, pull_mode: :pullup},
    relay: %{pin: 18, type: :output},
    # 다른 하드웨어 구성...
  }
  
  @doc """
  하드웨어 구성 정보 가져오기
  """
  def get_config(device) do
    Map.get(@hardware_config, device)
  end
  
  @doc """
  하드웨어 초기화
  """
  def initialize do
    # 모든 GPIO 장치 초기화
    for {device, config} <- @hardware_config, config.type == :output do
      {:ok, gpio} = Circuits.GPIO.open(config.pin, :output)
      Process.put({:gpio, device}, gpio)
    end
    
    for {device, config} <- @hardware_config, config.type == :input do
      {:ok, gpio} = Circuits.GPIO.open(config.pin, :input, pull_mode: config.pull_mode)
      Process.put({:gpio, device}, gpio)
    end
    
    # I2C 초기화
    {:ok, i2c} = Circuits.I2C.open("i2c-1")
    Process.put(:i2c, i2c)
    
    # SPI 초기화
    {:ok, spi} = Circuits.SPI.open("spidev0.0")
    Process.put(:spi, spi)
    
    :ok
  end
  
  @doc """
  GPIO 출력 설정
  """
  def set_output(device, value) do
    gpio = Process.get({:gpio, device})
    Circuits.GPIO.write(gpio, value)
  end
  
  @doc """
  GPIO 입력 읽기
  """
  def read_input(device) do
    gpio = Process.get({:gpio, device})
    Circuits.GPIO.read(gpio)
  end
  
  @doc """
  I2C 장치에 데이터 쓰기
  """
  def i2c_write(address, data) do
    i2c = Process.get(:i2c)
    Circuits.I2C.write(i2c, address, data)
  end
  
  @doc """
  I2C 장치에서 데이터 읽기
  """
  def i2c_read(address, bytes) do
    i2c = Process.get(:i2c)
    Circuits.I2C.read(i2c, address, bytes)
  end
  
  # 다른 하드웨어 제어 함수들...
end
      

defmodule HelloNerves.Application do
  # ...
  
  def start(_type, _args) do
    # 하드웨어 초기화
    HelloNerves.Hardware.initialize()
    
    # LED 켜기
    HelloNerves.Hardware.set_output(:led, 1)
    
    # 버튼 상태 읽기
    button_state = HelloNerves.Hardware.read_input(:button)
    Logger.info("Button state: #{button_state}")
    
    # ...
  end
end
      

# mix.exs에 의존성 추가
def deps do
  [
    # 기존 의존성들...
    {:nerves_firmware_ssh, "~> 0.4"}
  ]
end
      

config :nerves_firmware_ssh,
  authorized_keys: [
    File.read!(Path.join(System.user_home!(), ".ssh/id_rsa.pub"))
  ]
      

# 펌웨어 빌드
mix firmware

# SSH를 통해 업데이트 (nerves.local은 기기의 호스트명)
mix firmware.push nerves.local
      

# mix.exs에 의존성 추가
def deps do
  [
    # 기존 의존성들...
    {:nerves_firmware_http, "~> 0.1"},
    {:httpoison, "~> 1.8"}
  ]
end
      

defmodule HelloNerves.FirmwareUpdater do
  require Logger
  
  @firmware_url "https://firmware.example.com/latest.fw"
  @local_path "/tmp/firmware.fw"
  
  def check_for_updates do
    Logger.info("Checking for firmware updates...")
    
    case download_firmware() do
      :ok ->
        Logger.info("Firmware downloaded successfully")
        apply_update()
        
      {:error, reason} ->
        Logger.error("Failed to download firmware: #{inspect(reason)}")
        {:error, reason}
    end
  end
  
  defp download_firmware do
    Logger.info("Downloading firmware from #{@firmware_url}")
    
    case HTTPoison.get(@firmware_url, [], follow_redirect: true, stream_to: self()) do
      {:ok, %HTTPoison.AsyncResponse{id: ref}} ->
        receive_firmware_chunks(ref, File.open!(@local_path, [:write, :binary]))
        
      {:error, reason} ->
        {:error, reason}
    end
  end
  
  defp receive_firmware_chunks(ref, file, acc \\ 0) do
    receive do
      %HTTPoison.AsyncStatus{id: ^ref, code: 200} ->
        receive_firmware_chunks(ref, file, acc)
        
      %HTTPoison.AsyncStatus{id: ^ref, code: code} ->
        File.close(file)
        {:error, "HTTP error: #{code}"}
        
      %HTTPoison.AsyncHeaders{id: ^ref} ->
        receive_firmware_chunks(ref, file, acc)
        
      %HTTPoison.AsyncChunk{id: ^ref, chunk: chunk} ->
        IO.binwrite(file, chunk)
        receive_firmware_chunks(ref, file, acc + byte_size(chunk))
        
      %HTTPoison.AsyncEnd{id: ^ref} ->
        File.close(file)
        Logger.info("Downloaded #{acc} bytes")
        :ok
    after
      30_000 ->
        File.close(file)
        {:error, :timeout}
    end
  end
  
  defp apply_update do
    Logger.info("Applying firmware update...")
    
    case System.cmd("fwup", ["-a", "-i", @local_path, "-d", "/dev/mmcblk0", "-t", "upgrade"]) do
      {_output, 0} ->
        Logger.info("Firmware update applied successfully. Rebooting...")
        Nerves.Runtime.reboot()
        :ok
        
      {output, code} ->
        Logger.error("Firmware update failed with code #{code}: #{output}")
        {:error, output}
    end
  end
  
  # 주기적으로 업데이트 확인 (예: 1시간마다)
  def schedule_update_check do
    Process.send_after(self(), :check_updates, 60 * 60 * 1000)
  end
  
  def handle_info(:check_updates, state) do
    check_for_updates()
    schedule_update_check()
    {:noreply, state}
  end
end
      

defmodule HelloNerves.Application do
  use Application
  require Logger
  
  def start(_type, _args) do
    # 부팅 후 펌웨어 검증 시작
    spawn(fn -> validate_firmware() end)
    
    # 나머지 애플리케이션 시작 코드...
  end
  
  defp validate_firmware do
    # 부팅 후 일정 시간 대기 (시스템이 안정화될 시간)
    Process.sleep(60_000)  # 1분
    
    # 기본적인 시스템 검증 수행
    case perform_system_checks() do
      :ok ->
        Logger.info("Firmware validation passed. Marking as valid.")
        Nerves.Runtime.validate_firmware()
        
      {:error, reason} ->
        Logger.error("Firmware validation failed: #{inspect(reason)}. Rolling back.")
        Nerves.Runtime.revert_firmware()
    end
  end
  
  defp perform_system_checks do
    # 여기에 시스템 검증 로직 구현
    # 예: 네트워크 연결 확인, 센서 작동 확인, 기본 기능 테스트 등
    
    # 예시: 네트워크 연결 확인
    case test_network_connection() do
      :ok -> :ok
      error -> error
    end
  end
  
  defp test_network_connection do
    # 인터넷 연결 테스트 (예: Google DNS 핑)
    case System.cmd("ping", ["-c", "1", "8.8.8.8"]) do
      {_output, 0} -> :ok
      {output, _code} -> {:error, "Network test failed: #{output}"}
    end
  end
end
      

# 서버 측에서 델타 패치 생성 (개발 머신에서 실행)
fwup -m -b base_firmware.fw -d delta_patch.fw -t delta

# 기기에서 델타 패치 적용
fwup -a -i delta_patch.fw -t delta -d /dev/mmcblk0
      

defmodule SmartFarm.Application do
  use Application
  
  def start(_type, _args) do
    children = [
      # 센서 데이터 수집 모듈
      SmartFarm.SensorSupervisor,
      
      # 데이터 저장 및 분석
      SmartFarm.DataStore,
      
      # 관개 시스템 제어
      SmartFarm.IrrigationController,
      
      # LoRaWAN 네트워크 관리
      SmartFarm.LoRaWAN,
      
      # 웹 대시보드 (Phoenix)
      {SmartFarm.Web.Endpoint, []}
    ]
    
    opts = [strategy: :one_for_one, name: SmartFarm.Supervisor]
    Supervisor.start_link(children, opts)
  end
end

defmodule SmartFarm.SensorSupervisor do
  use Supervisor
  
  def start_link(arg) do
    Supervisor.start_link(__MODULE__, arg, name: __MODULE__)
  end
  
  def init(_arg) do
    # 센서 노드 설정 파일에서 로드
    sensor_configs = SmartFarm.Config.load_sensors()
    
    # 각 센서 노드에 대한 프로세스 시작
    children = Enum.map(sensor_configs, fn config ->
      {SmartFarm.SensorNode, config}
    end)
    
    Supervisor.init(children, strategy: :one_for_one)
  end
end

defmodule SmartFarm.SensorNode do
  use GenServer
  require Logger
  
  # 센서 노드 상태 관리 및 데이터 수집 로직
  # ...
end
      

defmodule IndustrialGateway.Protocol do
  @moduledoc """
  산업 프로토콜 추상화를 위한 프로토콜 정의
  """
  
  @doc """
  장치에 연결
  """
  @callback connect(config :: map()) :: {:ok, state :: term()} | {:error, reason :: term()}
  
  @doc """
  장치에서 데이터 읽기
  """
  @callback read(state :: term(), address :: term()) :: {:ok, value :: term(), state :: term()} | {:error, reason :: term(), state :: term()}
  
  @doc """
  장치에 데이터 쓰기
  """
  @callback write(state :: term(), address :: term(), value :: term()) :: {:ok, state :: term()} | {:error, reason :: term(), state :: term()}
  
  @doc """
  연결 종료
  """
  @callback disconnect(state :: term()) :: :ok | {:error, reason :: term()}
end

defmodule IndustrialGateway.ModbusProtocol do
  @moduledoc """
  Modbus 프로토콜 구현
  """
  @behaviour IndustrialGateway.Protocol
  
  @impl true
  def connect(config) do
    # Modbus 장치 연결 로직
    # ...
  end
  
  @impl true
  def read(state, address) do
    # Modbus 레지스터 읽기
    # ...
  end
  
  @impl true
  def write(state, address, value) do
    # Modbus 레지스터 쓰기
    # ...
  end
  
  @impl true
  def disconnect(state) do
    # 연결 종료
    # ...
  end
end

defmodule IndustrialGateway.OpcUaProtocol do
  @moduledoc """
  OPC-UA 프로토콜 구현
  """
  @behaviour IndustrialGateway.Protocol
  
  # OPC-UA 구현...
end

defmodule IndustrialGateway.DeviceManager do
  @moduledoc """
  다양한 프로토콜의 장치를 관리하는 모듈
  """
  use GenServer
  
  # 장치 관리 로직...
end
      

defmodule SmartHub.PluginManager do
  use GenServer
  require Logger
  
  def start_link(opts) do
    GenServer.start_link(__MODULE__, opts, name: __MODULE__)
  end
  
  def init(opts) do
    # 플러그인 디렉토리에서 모든 플러그인 로드
    plugins_dir = opts[:plugins_dir] || "/data/plugins"
    plugins = load_plugins(plugins_dir)
    
    {:ok, %{plugins: plugins, plugins_dir: plugins_dir}}
  end
  
  def get_plugin(type) do
    GenServer.call(__MODULE__, {:get_plugin, type})
  end
  
  def handle_call({:get_plugin, type}, _from, state) do
    plugin = Map.get(state.plugins, type)
    {:reply, plugin, state}
  end
  
  # 플러그인 디렉토리에서 모든 .beam 파일 로드
  defp load_plugins(dir) do
    Logger.info("Loading plugins from #{dir}")
    
    # 디렉토리의 모든 .beam 파일 찾기
    beam_files = Path.wildcard(Path.join(dir, "*.beam"))
    
    # 각 파일에서 모듈 로드
    plugins = 
      for beam_file <- beam_files,
          module = extract_module_from_beam(beam_file),
          implements_plugin_behaviour?(module) do
        type = module.plugin_type()
        Logger.info("Loaded plugin: #{module} for type: #{type}")
        {type, module}
      end
    
    Map.new(plugins)
  end
  
  # .beam 파일에서 모듈 이름 추출
  defp extract_module_from_beam(beam_file) do
    # 파일 이름에서 모듈 이름 추출
    module_name = 
      beam_file
      |> Path.basename(".beam")
      |> String.to_atom()
    
    # 모듈 코드 로드
    Code.load_file(beam_file)
    
    module_name
  end
  
  # 모듈이 플러그인 행동을 구현하는지 확인
  defp implements_plugin_behaviour?(module) do
    # 모듈이 존재하고 plugin_type/0 함수를 구현하는지 확인
    function_exported?(module, :plugin_type, 0)
  end
end

defmodule SmartHub.DeviceController do
  @moduledoc """
  스마트 홈 기기 제어 모듈
  """
  
  def control_device(device_id, command, args) do
    # 기기 정보 조회
    device = SmartHub.DeviceRegistry.get_device(device_id)
    
    # 기기 유형에 맞는 플러그인 가져오기
    plugin = SmartHub.PluginManager.get_plugin(device.type)
    
    if plugin do
      # 플러그인을 통해 기기 제어
      plugin.execute_command(device, command, args)
    else
      {:error, :unsupported_device_type}
    end
  end
end
      

defmodule SensorManager do
  use GenServer
  
  # 모든 센서를 하나의 프로세스에서 관리
  def init(_) do
    # 센서 목록 로드
    sensors = load_sensors()
    
    # 모든 센서의 초기 상태
    sensor_states = Map.new(sensors, fn sensor -> {sensor.id, %{last_reading: nil}} end)
    
    # 주기적 폴링 시작
    schedule_polling()
    
    {:ok, %{sensors: sensors, states: sensor_states}}
  end
  
  # 주기적으로 모든 센서 폴링
  def handle_info(:poll_sensors, state) do
    new_states = 
      Enum.reduce(state.sensors, state.states, fn sensor, acc ->
        # 센서 읽기
        reading = read_sensor(sensor)
        # 상태 업데이트
        Map.put(acc, sensor.id, %{last_reading: reading})
      end)
    
    schedule_polling()
    
    {:noreply, %{state | states: new_states}}
  end
  
  # 다음 폴링 예약
  defp schedule_polling do
    Process.send_after(self(), :poll_sensors, 5000)  # 5초마다
  end
  
  # 센서 읽기 로직
  defp read_sensor(sensor) do
    # 실제 센서 읽기 로직
    # ...
  end
end
      

# rel/vm.args 파일에 다음 설정 추가

# 가비지 컬렉션 설정
# 힙 크기를 작게 유지하여 메모리 사용량 최소화
-env ERL_FULLSWEEP_AFTER 10
      

defmodule LowPowerSensor do
  use GenServer
  require Logger
  
  def init(_) do
    # 초기 상태
    state = %{
      active_mode: false,
      last_reading: nil
    }
    
    # 모션 감지 인터럽트 설정
    {:ok, motion_pin} = Circuits.GPIO.open(17, :input)
    Circuits.GPIO.set_interrupts(motion_pin, :rising)
    
    {:ok, Map.put(state, :motion_pin, motion_pin)}
  end
  
  # 모션 감지 시 활성 모드로 전환
  def handle_info({:circuits_gpio, 17, _timestamp, 1}, state) do
    Logger.info("Motion detected, entering active mode")
    
    # 활성 모드로 전환
    new_state = %{state | active_mode: true}
    
    # 센서 읽기 시작
    schedule_reading()
    
    # 일정 시간 후 절전 모드로 돌아가기 위한 타이머 설정
    timer = Process.send_after(self(), :enter_sleep_mode, 60_000)  # 1분 후
    
    {:noreply, Map.put(new_state, :sleep_timer, timer)}
  end
  
  # 센서 읽기 (활성 모드에서만)
  def handle_info(:read_sensor, %{active_mode: true} = state) do
    reading = read_sensor()
    Logger.info("Sensor reading: #{inspect(reading)}")
    
    # 다음 읽기 예약
    schedule_reading()
    
    {:noreply, %{state | last_reading: reading}}
  end
  
  # 절전 모드에서는 센서 읽기 무시
  def handle_info(:read_sensor, state) do
    {:noreply, state}
  end
  
  # 절전 모드로 전환
  def handle_info(:enter_sleep_mode, state) do
    Logger.info("Entering sleep mode")
    
    # 활성 모드 해제
    {:noreply, %{state | active_mode: false}}
  end
  
  # 센서 읽기 예약 (활성 모드에서 5초마다)
  defp schedule_reading do
    Process.send_after(self(), :read_sensor, 5000)
  end
  
  # 센서 읽기 로직
  defp read_sensor do
    # 실제 센서 읽기 로직
    # ...
  end
end
      

defmodule PowerManager do
  use GenServer
  require Logger
  alias Circuits.I2C
  
  # BME280 센서 주소 및 레지스터
  @sensor_address 0x76
  @power_control_reg 0xF4
  
  def init(_) do
    {:ok, i2c} = I2C.open("i2c-1")
    {:ok, %{i2c: i2c}}
  end
  
  # 센서를 절전 모드로 전환
  def sleep_sensor(pid) do
    GenServer.call(pid, :sleep_sensor)
  end
  
  # 센서를 활성 모드로 전환
  def wake_sensor(pid) do
    GenServer.call(pid, :wake_sensor)
  end
  
  # 절전 모드 처리
  def handle_call(:sleep_sensor, _from, %{i2c: i2c} = state) do
    Logger.info("Putting sensor to sleep")
    
    # 센서를 절전 모드로 설정 (센서별 명령어 다름)
    I2C.write(i2c, @sensor_address, <<@power_control_reg, 0x00>>)
    
    {:reply, :ok, state}
  end
  
  # 활성 모드 처리
  def handle_call(:wake_sensor, _from, %{i2c: i2c} = state) do
    Logger.info("Waking up sensor")
    
    # 센서를 정상 모드로 설정
    I2C.write(i2c, @sensor_address, <<@power_control_reg, 0x27>>)
    
    # 센서 안정화 대기
    Process.sleep(10)
    
    {:reply, :ok, state}
  end
end
      

# config/target.exs 파일에 로깅 설정 추가

config :logger,
  # 로그 레벨 설정 (개발 시: :debug, 프로덕션: :info 또는 :warning)
  level: :info,
  
  # 로그 포맷 설정
  format: "$time $metadata[$level] $message\n",
  
  # 메타데이터 설정
  metadata: [:module, :function, :line],
  
  # 로그 파일로 출력 설정
  backends: [
    :console,
    {LoggerFileBackend, :error_log}
  ]

# 파일 백엔드 설정
config :logger, :error_log,
  path: "/data/logs/error.log",
  level: :error,
  format: "$date $time $metadata[$level] $message\n",
  metadata: [:module, :function, :line]
      

# 개발 머신에서 실행
$ ssh nerves.local

# 또는 더 편리하게
$ mix nerves.ssh

# IEx 세션 내에서 실시간 디버깅
iex(1)> Process.list() |> length()
127

iex(2)> :observer_cli.start()  # 텍스트 기반 시스템 모니터링

iex(3)> pid = Process.whereis(MyApp.SensorSupervisor)
#PID<0.1234.0>

iex(4)> Process.info(pid)
[
  current_function: {GenServer, :loop, 7},
  initial_call: {Supervisor, :init, 1},
  status: :waiting,
  message_queue_len: 0,
  # ...
]

iex(5)> :sys.get_state(MyApp.SensorManager)
%{
  sensors: [...],
  states: %{...}
}
      

defmodule MyApp.Metrics do
  use GenServer
  require Logger
  
  # 메트릭 수집 간격 (밀리초)
  @collection_interval 60_000  # 1분
  
  def start_link(opts) do
    GenServer.start_link(__MODULE__, opts, name: __MODULE__)
  end
  
  def init(_opts) do
    # 메트릭 수집 시작
    schedule_collection()
    
    {:ok, %{metrics: []}}
  end
  
  def handle_info(:collect_metrics, state) do
    # 시스템 메트릭 수집
    metrics = %{
      timestamp: :os.system_time(:second),
      memory: :erlang.memory(),
      process_count: Process.list() |> length(),
      cpu_load: cpu_load(),
      network: network_stats(),
      disk: disk_stats()
    }
    
    # 메트릭 저장
    store_metrics(metrics)
    
    # 경고 조건 확인
    check_warning_conditions(metrics)
    
    # 다음 수집 예약
    schedule_collection()
    
    # 최근 10개 메트릭만 상태에 유지
    updated_metrics = [metrics | state.metrics] |> Enum.take(10)
    
    {:noreply, %{state | metrics: updated_metrics}}
  end
  
  # CPU 로드 측정
  defp cpu_load do
    {output, 0} = System.cmd("cat", ["/proc/loadavg"])
    [load1, load5, load15 | _] = String.split(output)
    %{
      load1: String.to_float(load1),
      load5: String.to_float(load5),
      load15: String.to_float(load15)
    }
  end
  
  # 네트워크 통계 수집
  defp network_stats do
    # 실제 구현은 시스템에 따라 다름
    # ...
  end
  
  # 디스크 통계 수집
  defp disk_stats do
    # 실제 구현은 시스템에 따라 다름
    # ...
  end
  
  # 메트릭 저장 (파일, 데이터베이스 등)
  defp store_metrics(metrics) do
    # 실제 구현은 저장 방식에 따라 다름
    # ...
  end
  
  # 경고 조건 확인
  defp check_warning_conditions(metrics) do
    # 메모리 사용량 확인
    total_memory = metrics.memory[:total]
    used_memory = total_memory - metrics.memory[:free]
    memory_usage_percent = used_memory / total_memory * 100
    
    if memory_usage_percent > 80 do
      Logger.warning("High memory usage: #{Float.round(memory_usage_percent, 1)}%")
    end
    
    # CPU 로드 확인
    if metrics.cpu_load.load1 > 0.8 do
      Logger.warning("High CPU load: #{metrics.cpu_load.load1}")
    end
    
    # 다른 조건들...
  end
  
  # 다음 메트릭 수집 예약
  defp schedule_collection do
    Process.send_after(self(), :collect_metrics, @collection_interval)
  end
end
      

# IEx 세션에서 프로파일링 실행
iex(1)> :fprof.apply(fn -> MyApp.heavy_function() end, [])
:ok

iex(2)> :fprof.profile()
:ok

iex(3)> :fprof.analyse()
# 상세한 프로파일링 결과 출력
      

defmodule SmartCamera.ObjectDetection do
  alias Nx.Serving
  require Logger
  
  # 객체 감지 모델 로드 및 서빙 설정
  def start_link(_opts) do
    {:ok, model_info} = Bumblebee.load_model({:hf, "facebook/detr-resnet-50"})
    {:ok, featurizer} = Bumblebee.load_featurizer({:hf, "facebook/detr-resnet-50"})
    
    serving = 
      Bumblebee.Vision.object_detection(model_info, featurizer,
        compile: [batch_size: 1],
        defn_options: [compiler: EXLA]
      )
    
    # 서빙 시작
    {:ok, pid} = Serving.start_link(serving: serving)
    
    Logger.info("Object detection model loaded and ready")
    
    {:ok, pid}
  end
  
  # 이미지에서 객체 감지
  def detect_objects(pid, image_path) do
    image = StbImage.read_file!(image_path)
    
    result = Serving.run(pid, image)
    
    # 결과 처리
    objects = 
      for %{label: label, score: score, box: %{top: top, left: left, width: width, height: height}} <- result.objects,
          score > 0.5 do
        %{
          label: label,
          confidence: score,
          box: %{top: top, left: left, width: width, height: height}
        }
      end
    
    Logger.info("Detected #{length(objects)} objects")
    
    objects
  end
end
      

defmodule MeshNetwork.Application do
  use Application
  
  def start(_type, _args) do
    children = [
      # 클러스터 설정
      {Cluster.Supervisor, [cluster_config(), [name: MeshNetwork.ClusterSupervisor]]},
      
      # 분산 레지스트리
      {Horde.Registry, [name: MeshNetwork.Registry, keys: :unique]},
      
      # 분산 슈퍼바이저
      {Horde.DynamicSupervisor, [name: MeshNetwork.DynamicSupervisor, strategy: :one_for_one]},
      
      # 기타 애플리케이션 컴포넌트
      # ...
    ]
    
    opts = [strategy: :one_for_one, name: MeshNetwork.Supervisor]
    Supervisor.start_link(children, opts)
  end
  
  defp cluster_config do
    [
      # mDNS를 통한 자동 노드 발견
      gossip: [
        strategy: Cluster.Strategy.Gossip,
        config: [
          port: 45892,
          multicast_addr: {230, 1, 1, 251},
          multicast_ttl: 1
        ]
      ],
      
      # 또는 정적 노드 목록
      epmd: [
        strategy: Cluster.Strategy.Epmd,
        config: [
          hosts: [
            :"node1@192.168.1.101",
            :"node2@192.168.1.102",
            :"node3@192.168.1.103"
          ]
        ]
      ]
    ]
  end
end