## 簡介

最近讀到一本好書，書名是[《透過 Elixir 和 Nerves 搭建氣象站》](https://pragprog.com/titles/passweather/build-a-weather-station-with-elixir-and-nerves/)， 書中介紹瞭如何引入 Elixir 作為構建嵌入式應用程式的工具。

透過使用 [Nerves](https://www.nerves-project.org/)，我們可以在支援網路的裝置上執行 Elixir 程式碼，並且與一些控制軟體互動。

上面提到的書主要關注點在 Nerves，使用 HTTP 協議進行網路互動。 儘管在許多情況下這是一個合理的選擇，但我想介紹另一個廣泛用於生產物聯網 (IoT) 設定的選擇：MQTT。

## MQTT 協議

MQTT 是一種專為物聯網 (IoT) 裝置通訊而設計的訊息傳輸協議。 它廣泛應用於許多領域，例如銀行、石油和天然氣、製造業等。

MQTT 協議有很多優點，部分如下所示：

- 它是一種輕量級的二進位制協議，通常在 TCP/IP 協議之上執行。
- 它專為網路不可靠的場景設計，是戶外安裝的理想選擇。
- 它遵循釋出/訂閱模式，簡化客戶端邏輯。

我們將在設定中演示 MQTT 的一些優勢。

## MQTT Broker

MQTT 的一個重要特徵是它簡化了客戶端邏輯，這對於嵌入式裝置至關重要。 這是透過釋出/訂閱模式實現的：在 MQTT 中，沒有“伺服器”的概念。 相反，所有參與實體都是連線到所謂 *broker* 的客戶端。 客戶端*訂閱主題*，*向它們釋出訊息*，broker 進行路由（以及許多其他事情）。

一個好的用於生產的 broker，如 EMQ X，通常不僅提供 MQTT 路由功能，還提供許多其他有趣的功能，例如

- 其他型別的連線方法，如 WebSockets；
- 不同的認證和授權模式；
- 將資料流傳輸到資料庫；
- 基於訊息特徵的自定義路由規則。

## 感測器設定

為簡單起見，我們的裝置將由一個普通的 Mix 應用程式表示：它可以輕鬆轉換為 Nerves 應用程式。

首先，我們建立一個 Mix 專案：

```
mix new --sup weather_sensor
cd weather_sensor
```

為了與 MQTT broker 互動，我們需要一個 MQTT 客戶端。 我們採用 [emqtt](https://github.com/emqx/emqtt)。 將其新增到 mix.exs 作為依賴項：

```
defp deps do
  [
    {:emqtt, github: "emqx/emqtt", tag: "1.4.4", system_env: [{"BUILD_WITHOUT_QUIC", "1"}]}
  ]
end
```

我們將把所有的“感測器”程式碼放到主模組 WeatherSensor 中，所以我們需要將它新增到應用程式管理器 lib/weather_sensor/application.ex 中：

```
defmodule WeatherSensor.Application do
  @moduledoc false

use Application

@impl true
  def start(_type, _args) do
    children = [
      WeatherSensor
    ]

opts = [strategy: :one_for_one, name: WeatherSensor.Supervisor]
    Supervisor.start_link(children, opts)
  end
end
```

現在，讓我們在 lib/weather_sensor.ex 中實現主模組：

```
defmodule WeatherSensor do
  @moduledoc false

use GenServer

def start_link([]) do
    GenServer.start_link(__MODULE__, [])
  end

def init([]) do
    interval = Application.get_env(:weather_sensor, :interval)
    emqtt_opts = Application.get_env(:weather_sensor, :emqtt)
    report_topic = "reports/#{emqtt_opts[:clientid]}/temperature"
    {:ok, pid} = :emqtt.start_link(emqtt_opts)
    st = %{
      interval: interval,
      timer: nil,
      report_topic: report_topic,
      pid: pid
    }

{:ok, set_timer(st), {:continue, :start_emqtt}}
  end

def handle_continue(:start_emqtt, %{pid: pid} = st) do
    {:ok, _} = :emqtt.connect(pid)

emqtt_opts = Application.get_env(:weather_sensor, :emqtt)
    clientid = emqtt_opts[:clientid]
    {:ok, _, _} = :emqtt.subscribe(pid, {"commands/#{clientid}/set_interval", 1})
    {:noreply, st}
  end

def handle_info(:tick, %{report_topic: topic, pid: pid} = st) do
    report_temperature(pid, topic)
    {:noreply, set_timer(st)}
  end

def handle_info({:publish, publish}, st) do
    handle_publish(parse_topic(publish), publish, st)
  end

defp handle_publish(["commands", _, "set_interval"], %{payload: payload}, st) do
    new_st = %{st | interval: String.to_integer(payload)}
    {:noreply, set_timer(new_st)}
  end

defp handle_publish(_, _, st) do
    {:noreply, st}
  end

defp parse_topic(%{topic: topic}) do
    String.split(topic, "/", trim: true)
  end

defp set_timer(st) do
    if st.timer do
      Process.cancel_timer(st.timer)
    end
    timer = Process.send_after(self(), :tick, st.interval)
    %{st | timer: timer}
  end

defp report_temperature(pid, topic) do
    temperature = 10.0 + 2.0 * :rand.normal()
    message = {System.system_time(:millisecond), temperature}
    payload = :erlang.term_to_binary(message)
    :emqtt.publish(pid, topic, payload)
  end
end
```

並在 config/config.exs 中新增一些選項：

```
import Config

config :weather_sensor, :emqtt,
  host: '127.0.0.1',
  port: 1883,
  clientid: "weather_sensor",
  clean_start: false,
  name: :emqtt

config :weather_sensor, :interval, 1000
```

讓我們總結一下 WeatherSensor 中發生的事情：

- 它實現了GenServer 行為。
- 啟動時，它有如下動作：
  - 開啟一個 MQTT 連線；
  - 訂閱 commands/weather_sensor/set_interval 主題以接收命令，將接收到的資料將透過 :emqtt 傳送到程式，作為 {:publish, publish }訊息。
  - 以預定義的時間間隔設定計時器。
- 在定時器超時時，它釋出 {Timestamp, Temperature} 元組到 reports/weather_sensor/temperature 主題。
- 在收到來自 commands/weather_sensor/set_interval 主題的訊息時，它會更新計時器間隔。

由於我們的應用程式不是真正的 Nerves 應用程式，它連線了 BMP280 之類的感測器，因此我們生成溫度資料。

在這裡我們已經可以看到相對於 HTTP 互動的一個優勢：我們不僅可以傳送資料，還可以實時接收一些命令。

我們需要一個 broker 來執行節點； 我們稍後會開始。

## 控制檯設定

由於 MQTT 中沒有“伺服器”，因此我們的控制檯也將是一個 MQTT 客戶端。 但它會*訂閱*reports/weather_sensor/temperature主題和*釋出*命令到 commands/weather_sensor/set_interval。

對於控制檯，我們將設定 Phoenix LiveView 應用程式。

建立過程如下：

```
mix phx.new --version
Phoenix installer v1.6.2
mix phx.new weather_dashboard --no-ecto --no-gettext --no-dashboard --live
cd weather_dashboard
```

向 mix.exs 新增依賴項

```
  defp deps do
    [
      ...
      {:jason, "~> 1.2"},
      {:plug_cowboy, "~> 2.5"},

{:emqtt, github: "emqx/emqtt", tag: "1.4.4", system_env: [{"BUILD_WITHOUT_QUIC", "1"}]},
      {:contex, github: "mindok/contex"} # We will need this for SVG charts
    ]
  end
```

向 config/dev.exs 新增一些設定：

```
config :weather_dashboard, :emqtt,
  host: '127.0.0.1',
  port: 1883

config :weather_dashboard, :sensor_id, "weather_sensor"

# Period for chart
config :weather_dashboard, :timespan, 60
```

現在我們生成一個 LiveView 控制器：

```
mix phx.gen.live Measurements Temperature temperatures  --no-schema --no-context
```

這會生成很多檔案，但並非都是必需的，我們需要的是一個帶有圖表的單頁應用程式。

```
rm lib/weather_dashboard_web/live/temperature_live/form_component.*
rm lib/weather_dashboard_web/live/temperature_live/show.*
rm lib/weather_dashboard_web/live/live_helpers.ex
```

同時從lib/weather_dashboard_web.ex 中刪除import WeatherDashboardWeb.LiveHelpers。

更新我們頁面的模板（lib/weather_dashboard_web/live/temperature_live/index.html.heex）：

```
<div>
  
    
  
</div>

<div>
  <form phx-submit="set-interval">
    <label for="interval">Interval</label>
    <input type="text" name="interval" value="{@interval}/">
    <input type="submit" value="Set interval">
  </form>
</div>
```

我們有一個圖表和輸入控制元件，用於向此頁面上的“裝置”傳送命令。

現在更新主要部分 LiveView 控制器（lib/weather_dashboard_web/live/temperature_live/index.ex）：

```
defmodule WeatherDashboardWeb.TemperatureLive.Index do
  use WeatherDashboardWeb, :live_view

require Logger

@impl true
  def mount(_params, _session, socket) do
    reports = []
    emqtt_opts = Application.get_env(:weather_dashboard, :emqtt)
    {:ok, pid} = :emqtt.start_link(emqtt_opts)
    {:ok, _} = :emqtt.connect(pid)
    # Listen reports
    {:ok, _, _} = :emqtt.subscribe(pid, "reports/#")
    {:ok, assign(socket,
      reports: reports,
      pid: pid,
      plot: nil,
      interval: nil
    )}
  end

@impl true
  def handle_params(_params, _url, socket) do
    {:noreply, socket}
  end

@impl true
  def handle_event("set-interval", %{"interval" => interval_s}, socket) do
    case Integer.parse(interval_s) do
      {interval, ""} ->
        id = Application.get_env(:weather_dashboard, :sensor_id)
        # Send command to device
        topic = "commands/#{id}/set_interval"
        :ok = :emqtt.publish(
          socket.assigns[:pid],
          topic,
          interval_s,
          retain: true
        )
        {:noreply, assign(socket, interval: interval)}
      _ ->
        {:noreply, socket}
    end
  end

def handle_event(name, data, socket) do
    Logger.info("handle_event: #{inspect([name, data])}")
    {:noreply, socket}
  end

@impl true
  def handle_info({:publish, packet}, socket) do
    handle_publish(parse_topic(packet), packet, socket)
  end

defp handle_publish(["reports", id, "temperature"], %{payload: payload}, socket) do
    if id == Application.get_env(:weather_dashboard, :sensor_id) do
      report = :erlang.binary_to_term(payload)
      {reports, plot} = update_reports(report, socket)
      {:noreply, assign(socket, reports: reports, plot: plot)}
    else
      {:noreply, socket}
    end
  end

defp update_reports({ts, val}, socket) do
    new_report = {DateTime.from_unix!(ts, :millisecond), val}
    now = DateTime.utc_now()
    deadline = DateTime.add(DateTime.utc_now(), - 2 * Application.get_env(:weather_dashboard, :timespan), :second)
    reports =
      [new_report | socket.assigns[:reports]]
      |> Enum.filter(fn {dt, _} -> DateTime.compare(dt, deadline) == :gt end)
      |> Enum.sort()

{reports, plot(reports, deadline, now)}
  end

defp parse_topic(%{topic: topic}) do
    String.split(topic, "/", trim: true)
  end

defp plot(reports, deadline, now) do
    x_scale =
      Contex.TimeScale.new()
      |> Contex.TimeScale.domain(deadline, now)
      |> Contex.TimeScale.interval_count(10)

y_scale =
      Contex.ContinuousLinearScale.new()
      |> Contex.ContinuousLinearScale.domain(0, 30)

options = [
      smoothed: false,
      custom_x_scale: x_scale,
      custom_y_scale: y_scale,
      custom_x_formatter: &x_formatter/1,
      axis_label_rotation: 45
    ]

reports
    |> Enum.map(fn {dt, val} -> [dt, val] end)
    |> Contex.Dataset.new()
    |> Contex.Plot.new(Contex.LinePlot, 600, 250, options)
    |> Contex.Plot.to_svg()
  end

defp x_formatter(datetime) do
    datetime
    |> Calendar.strftime("%H:%M:%S")
  end

end
```

特別說明如下：

- 我們建立了一個 LiveView 處理程式來為我們的應用程式的主頁提供服務。
- 通常，Phoenix.PubSub 用於更新 LiveView 程式狀態。 但是，我們做了一個特殊設定：由於 MQTT broker 已經提供了一個釋出訂閱模式，我們直接從 LiveView 程式連線到它。
- 收到新的溫度資料後，伺服器更新溫度圖表。
- 收到使用者的表單更新後，我們會向命令主題傳送更新的時間間隔。

最後，在lib/weather_dashboard_web/router.ex 中設定路由，以便我們的控制器能夠處理根頁面：

```
  scope "/", WeatherDashboardWeb do
    pipe_through :browser

live "/", TemperatureLive.Index
  end
```

## 模組整合

現在，我們已準備設定並執行所有內容。

我們執行一個 MQTT broker。 由於我們不需要任何特定的設定，最簡單的方法是使用 docker 執行代 broker。

```
docker run -d --name emqx -p 1883:1883 emqx/emqx:4.3.10
```

現在執行我們的“裝置”：

```
cd weather_sensor
export BUILD_WITHOUT_QUIC=1
iex -S mix
Erlang/OTP 24 [erts-12.1.2] [source] [64-bit] [smp:16:16] [ds:16:16:10] [async-threads:1] [jit] [dtrace]

....

13:17:24.461 [debug] emqtt(weather_sensor): SEND Data: {:mqtt_packet, {:mqtt_packet_header, 8, false, 1, false}, {:mqtt_packet_subscribe, 2, %{}, [{"/commands/weather_sensor/set_interval", %{nl: 0, qos: 1, rap: 0, rh: 0}}]}, :undefined}

13:17:24.463 [debug] emqtt(weather_sensor): RECV Data: <<144, 3, 0, 2, 1>>

13:17:25.427 [debug] emqtt(weather_sensor): SEND Data: {:mqtt_packet, {:mqtt_packet_header, 3, false, 0, false}, {:mqtt_packet_publish, "/reports/weather_sensor/temperature", :undefined, :undefined}, <<131, 104, 2, 110, 6, 0, 179, 156, 178, 158, 125, 1, 70, 64, 38, 106, 91, 64, 234, 212, 185>>}

13:17:26.428 [debug] emqtt(weather_sensor): SEND Data: {:mqtt_packet, {:mqtt_packet_header, 3, false, 0, false}, {:mqtt_packet_publish, "/reports/weather_sensor/temperature", :undefined, :undefined}, <<131, 104, 2, 110, 6, 0, 156, 160, 178, 158, 125, 1, 70, 64, 39, 115, 221, 187, 144, 192, 31>>}
...
```

我們看到我們的感測器立即開始傳送報告。

現在執行我們的控制檯：

```
cd weather_dashboard
export BUILD_WITHOUT_QUIC=1
iex -S mix phx.server
Erlang/OTP 24 [erts-12.1.2] [source] [64-bit] [smp:16:16] [ds:16:16:10] [async-threads:1] [jit] [dtrace]

[info] Running WeatherDashboardWeb.Endpoint with cowboy 2.9.0 at 127.0.0.1:4000 (http)
[info] Access WeatherDashboardWeb.Endpoint at http://localhost:4000
Interactive Elixir (1.12.3) - press Ctrl+C to exit (type h() ENTER for help)
iex(1)> [watch] build finished, watching for changes...
```

讓我們導航到 [http://localhost:4000](http://localhost:4000/)。

我們看到相應的 LiveView 程式掛載，連線到代理，並開始接收溫度資料：

```
[info] GET /
[info] Sent 200 in 145ms
[info] CONNECTED TO Phoenix.LiveView.Socket in 129µs
  Transport: :websocket
  Serializer: Phoenix.Socket.V2.JSONSerializer
  Parameters: %{"_csrf_token" => "cwoROxAwKFo7NEcSdgMwFlgaZ1AlBxUa6FIRhAbjHA6XORIF-EUiIRqU", "_mounts" => "0", "_track_static" => %{"0" => "http://localhost:4000/assets/app.css", "1" => "http://localhost:4000/assets/app.js"}, "vsn" => "2.0.0"}
[debug] emqtt(emqtt-MacBook-Pro-iaveryanov-86405372ddbf17052130): SEND Data: {:mqtt_packet, {:mqtt_packet_header, 1, false, 0, false}, {:mqtt_packet_connect, "MQTT", 4, false, true, false, 0, false, 60, %{}, "emqtt-MacBook-Pro-iaveryanov-86405372ddbf17052130", :undefined, :undefined, :undefined, :undefined, :undefined}, :undefined}
[debug] emqtt(emqtt-MacBook-Pro-iaveryanov-86405372ddbf17052130): RECV Data: <<32, 2, 0, 0>>
[debug] emqtt(emqtt-MacBook-Pro-iaveryanov-86405372ddbf17052130): SEND Data: {:mqtt_packet, {:mqtt_packet_header, 8, false, 1, false}, {:mqtt_packet_subscribe, 2, %{}, [{"/reports/#", %{nl: 0, qos: 0, rap: 0, rh: 0}}]}, :undefined}
[debug] emqtt(emqtt-MacBook-Pro-iaveryanov-86405372ddbf17052130): RECV Data: <<144, 3, 0, 2, 0>>
[debug] emqtt(emqtt-MacBook-Pro-iaveryanov-86405372ddbf17052130): RECV Data: <<48, 58, 0, 35, 47, 114, 101, 112, 111, 114, 116, 115, 47, 119, 101, 97, 116,
  104, 101, 114, 95, 115, 101, 110, 115, 111, 114, 47, 116, 101, 109, 112, 101,
  114, 97, 116, 117, 114, 101, 131, 104, 2, 110, 6, 0, 180, 251, 188, 158, 125,
...
```

此外，該頁面立即開始更新：

![Phoenix](http://img.blog.itpub.net/blog/2022/01/30/11528bc192159040.png?x-oss-process=style/bb "Phoenix")

如果我們更新間隔，我們看到裝置節點立即收到命令並開始更頻繁地更新：

![Phoenix](http://img.blog.itpub.net/blog/2022/01/30/92a1d1f15fb1c7c8.png?x-oss-process=style/bb "Phoenix")

現在我們演示一件重要的事情：讓我們停止我們的“裝置”節點，稍等片刻，然後重新啟動它。 我們看到節點繼續以更新的頻率傳送資料。

![Phoenix](http://img.blog.itpub.net/blog/2022/01/30/90e75b5879a56f09.png?x-oss-process=style/bb "Phoenix")

怎麼會這樣？ 其實很簡單，秘訣就在於我們傳送到命令主題的命令訊息的 retain 標誌。

```
:ok = :emqtt.publish(
  socket.assigns[:pid],
  topic,
  interval_s,
  retain: true
)
```

當我們向主題傳送帶有 retain 標誌的訊息時，該訊息也成為“預設”訊息，並保留在 broker 上。該主題的每個訂閱者都會在訂閱時收到此訊息。

對於可能經常離線且沒有任何易於使用的本地儲存來保持其狀態的嵌入式裝置，此功能非常重要。 這是在連線時正確配置它們的方法。

## 結論

這篇文章介紹瞭如下內容：

- 展示了一種與嵌入式裝置互動的流行方式——MQTT 協議；
- 我們介紹了它在 Elixir 中的用法；
- 我們還展示了 MQTT 的一些優勢，例如釋出訂閱模式和訊息保留。

即使在簡單的設定中，我們也可能想要使用的強大功能是：

- 將主題資料流傳輸到資料庫中，這樣我們可以顯示連線歷史，無需“手動”儲存；
- 使用 [MQTT.js](https://www.emqx.com/zh/blog/mqtt-js-tutorial) 透過 WebSockets 從前端直接連線到 broker。

所有程式碼都可以在 [https://github.com/savonarola/mqtt-article](https://github.com/savonarola/mqtt-article) 上查閱。

>版權宣告： 本文為 EMQ 原創，轉載請註明出處。
>
>原文連結：[https://www.emqx.com/zh/blog/mqtt-for-elixir](https://www.emqx.com/zh/blog/mqtt-for-elixir)

MQTT 在 Elixir 中的應用

相關文章