【ESP32】OTAアップデート：MQTTとAWS IoTデバイスシャドウを利用したファームウェア更新

// user.go
type User struct {
	// 他のフィールド...
	FirmwareVersion   string	  `db:"firmware_version" json:"firmware_version"`
}

func (u *User) ToDeviceConfig() pb.DeviceConfig {
	return pb.DeviceConfig{
		FirmwareVersion:         &u.FirmwareVersion,
	}
}

// user_handler.go
type UserHandler struct {
	db *sqlx.DB
	sm ShadowManager
}

func (h *UserHandler) HandleUpdateUser(c echo.Context) error {
	uid := c.Get("uid").(string)
	user := &User{}
	if err := c.Bind(user); err != nil {
		return err
	}
	user.UID = uid

	// DB更新
	updatedUser, err := UpdateUser(h.db, user)
	if err != nil {
		c.Logger().Errorf("failed to update user: %v", err)
		return echo.NewHTTPError(http.StatusInternalServerError, "failed to update user")
	}

	// デバイスIDが存在するとき
	if updatedUser.DeviceID.Valid {
		dc := updatedUser.ToDeviceConfig()
		desired := &pb.PublishShadowDesired{
			State: &pb.ShadowDesiredState{
				Desired: &pb.ShadowDesired{
					Config: &dc,
				},
			},
		}
		// DeviceShadowを反映
		if err = h.sm.UpdateShadow(updatedUser.DeviceID.String, desired); err != nil {
			c.Logger().Errorf("failed to update device shadow: %v", err)
			return echo.NewHTTPError(http.StatusInternalServerError, "failed to update device shadow")
		}
	}
	return c.JSON(http.StatusOK, updatedUser)
}

// src/mqtt_client.cpp
void MqttClient::onMessage(const std::function<void(const String &topic, const String &payload)> &callback) {
  client->onMessage([callback](const String &topic, const String &payload) {
    Serial.println("MQTTPubSubClient::onMessage: " + topic + " " + payload);
    callback(topic, payload);
  });
}

// MQTTメッセージのペイロード例
{
  "version": 1859,
  "timestamp": 1713327942,
  "state": {
    "config": {
      "phrase_type": "hakata"
    }
  },
  "metadata": {
    "config": {
      "phrase_type": {
        "timestamp": 1713250306
      }
    }
  }
}

// src/sync_shadow.cpp

tl::expected<void, String> SyncShadow::start() {
  // MQTTクライアント初期化
  client->init();

  // TopicごとにHandlerを呼び出す
  this->client->onMessage([this](const String &topic, const String &payload) {
    Logger &logger = Logger::getInstance();

    if (topic == topicGetAccepted) {
      if (auto result = handleShadowGetAccepted(payload); !result) {
        logger.error(ErrorCode::SHADOW_FAILED, result.error());
      }
    } else if (topic == topicUpdateDelta) {
      if (auto result = handleShadowUpdateDelta(payload); !result) {
        logger.error(ErrorCode::SHADOW_FAILED, result.error());
      }
    }
  });
}

// デバイスシャドウの更新があった場合に呼ばれる
tl::expected<void, String> SyncShadow::handleShadowUpdateDelta(const String &payload) {
  auto resultDelta = deserializeSubscribeShadowUpdateDelta(payload);
  if (!resultDelta) {
    return tl::make_unexpected("can not deserialize delta shadow: " + resultDelta.error());
  }
  // 現在の設定
  const auto currentConfig = this->reported.config;
  // 更新された設定
  const auto deltaConfig = resultDelta->state->config;

  // configに変更がない場合は終了
  if (!isDeviceConfigChanged(deltaConfig, currentConfig)) {
    Serial.println("no change: skip");
    return {};
  }
  // 更新された設定を反映
  updateDeviceConfig(*this->desired.config, *resultDelta->state->config);
  return {};
}

Phrase Type: hakata

// src/json/device_config.cpp
// 現在の設定とdesiredの設定の差分を取得する
std::optional<DeviceConfig> getDeviceConfigDiff(const std::optional<DeviceConfig> &desiredConfig, const std::optional<DeviceConfig> ¤tConfig) {
  DeviceConfig diff;
  bool hasDiff = false;

  // desiredの値がcurrentと異なる場合にdiffに設定する
  auto checkAndAssign = [&hasDiff](const auto &desired, const auto ¤t, auto &diffField) {
    if (desired.has_value()) {
      if (!current.has_value() || *desired != *current) {
        diffField = desired;
        hasDiff = true;
      }
    }
  };
  
  checkAndAssign(desiredConfig->firmware_version, currentConfig->firmware_version, diff.firmware_version);

  if (hasDiff) {
    return diff;
  } else {
    return std::nullopt;
  }
}

bool isDeviceConfigChanged(const std::optional<DeviceConfig> &desiredConfig, const std::optional<DeviceConfig> ¤tConfig) {
  if (desiredConfig->firmware_version.has_value() && desiredConfig->firmware_version != currentConfig->firmware_version) {
    return true;
  }
  // その他のフィールド
  // ...
  // すべてのフィールドが同じ場合
  return false;
}

// src/main.cpp

void setup() {
	// Wi-Fi接続の設定
	setupWiFi(ssid, password);
	
	// システムの起動ログ
	Serial.println("System initialization...");
	
	// SyncShadowインスタンスの取得
	SyncShadow &syncShadow = SyncShadow::getInstance();
	
	// SyncShadowの開始
	if (auto result = syncShadow.start(); !result) {
	    Serial.println("Failed to start SyncShadow: " + result.error());
	} else {
	    Serial.println("SyncShadow started successfully.");
	}
		
	// デバイス設定の変更を適用し、デバイスシャドウに通知する
	void applyAndReportConfigUpdates() {
	  Logger &logger = Logger::getInstance();
	  SyncShadow &syncShadow = SyncShadow::getInstance();
	
	  auto desiredConfig = syncShadow.getDesiredConfig();
	  auto reportedConfig = syncShadow.getReportedConfig();
	
	  auto optConfigDiff = getDeviceConfigDiff(desiredConfig, reportedConfig);
	  // 変更がない場合はスキップ
	  if (!optConfigDiff) {
	    return;
	  }
	  logger.debug("device config changed");
	
	  // 変更のあった設定
	  auto configDiff = optConfigDiff.value();
	  logger.debug("config diff: " + serializeDeviceConfig(configDiff));
	
	  // ファームウェアバージョンの変更があった場合
	  if (configDiff.firmware_version.has_value()) {
	    logger.debug("Firmware version changed: " + desiredConfig->firmware_version.value());
	    // ファームウェアアップグレード開始
	    if (auto result = upgradeFirmware(desiredConfig->firmware_version.value()); !result) {
	      logger.error(ErrorCode::OTA_UPDATE_FAILED, "failed to upgrade firmware: " + result.error());
	    delay(100);
　　     ESP.restart(); // ダウンロードに失敗した場合は再起動
	    return;
	    } else {
	      logger.info("Firmware upgrade successful");
	    }
	  }
  }
}

void loop() {
	// デバイスシャドウが更新されていた場合の処理
  applyAndReportConfigUpdates();
}

// src/ota_update.cpp
tl::expected<void, String> upgradeFirmware(const String &firmwareVersion) {
  Serial.println("OTA firmware upgrade start");

  // ルートCA証明書を読み込む
  String cert = readRootCA();
  if (cert.length() == 0) {
    return tl::make_unexpected("Failed to load root CA certificate");
  }

  // Firmware Update URLを組み立てる
  String firmwareUpdateUrl = String(FIRMWARE_UPGRADE_URL) + firmwareVersion + ".bin";
  Serial.println("Firmware update URL: " + firmwareUpdateUrl);

  esp_http_client_config_t config = {
      .url = firmwareUpdateUrl.c_str(),
      .cert_pem = cert.c_str(),
      .timeout_ms = 600000, // 念の為に通信タイムアウトを10分に設定。
      .keep_alive_enable = true,
  };
  esp_https_ota_config_t ota_config = {
      .http_config = &config,
  };

  // OTAのエラーを格納する
  String otaError;
  int last_progress = -1;

  // OTA開始
  esp_https_ota_handle_t https_ota_handle = nullptr;
  esp_err_t err = esp_https_ota_begin(&ota_config, &https_ota_handle);
  if (err != ESP_OK) {
    otaError = "OTA begin failed: " + String(esp_err_to_name(err));
    goto ota_end;
  }

  // イメージの存在チェック（descriptionを取得）
  esp_app_desc_t app_desc;
  err = esp_https_ota_get_img_desc(https_ota_handle, &app_desc);
  if (err != ESP_OK) {
    otaError = "failed to get image description: " + String(esp_err_to_name(err));
    goto ota_end;
  }

  // OTAのダウンロードを実行
  while (true) {
    err = esp_https_ota_perform(https_ota_handle);
    if (err != ESP_ERR_HTTPS_OTA_IN_PROGRESS) {
      break;
    }
    int32_t dl = esp_https_ota_get_image_len_read(https_ota_handle);
    int32_t size = esp_https_ota_get_image_size(https_ota_handle);
    int progress = 100 * ((float)dl / (float)size);
    if (progress != last_progress) {
      Serial.printf("Firmware update progress: %d%%\n", progress);
      last_progress = progress;
    }
  }

  // OTAが正常に完了したか確認
  if (err != ESP_OK) {
    otaError = "OTA finish failed: " + String(esp_err_to_name(err));
    goto ota_end;
  }

  // OTAで完全なデータが受信されたか確認
  if (esp_https_ota_is_complete_data_received(https_ota_handle) != true) {
    otaError = "OTA image was not completely received";
    goto ota_end;
  }

  // OTAの終了処理を実行
  err = esp_https_ota_finish(https_ota_handle);
  if (err == ESP_ERR_OTA_VALIDATE_FAILED) {
    otaError = "OTA image validation failed";
    goto ota_end;
  }

  Serial.println("Firmware upgrade succeeded");

  return {};

ota_end:
  esp_https_ota_abort(https_ota_handle);
  return tl::make_unexpected("OTA process ended unexpectedly: " + otaError);
}

tl::expected<void, String> performFirmwareUpdate(const String &firmwareVersion) {
  Logger &logger = Logger::getInstance();
  SyncShadow &syncShadow = SyncShadow::getInstance();

  // ダウンロードステータスを開始状態に更新
  if (auto result = startDownloadStatus(syncShadow, "firmware"); !result) {
    return tl::make_unexpected("failed to start download status: " + result.error());
  }

  delay(100);

  // ファームウェアアップデートの前にデバイスシャドウの同期を停止する
  if (auto result = syncShadow.stop(); !result) {
    return tl::make_unexpected("failed to stop mqtt: " + result.error());
  }

  // ファームウェアアップデートを実行
  if (auto result = upgradeFirmware(firmwareVersion); !result) {
    return tl::make_unexpected("failed to upgrade firmware: " + result.error());
  }

  // ファームウェアアップデート後にデバイスシャドウの同期を再開する
  if (auto result = syncShadow.start(); !result) {
    return tl::make_unexpected("failed to start mqtt: " + result.error());
  }

  // ダウンロードステータスを終了状態に更新
  if (auto result = updateDownloadStatus(syncShadow, 100, "firmware"); !result) {
    return tl::make_unexpected("failed to update download status: " + result.error());
  }

  delay(100);

  // 初期値に戻す
  if (auto result = finishDownloadStatus(syncShadow, "firmware"); !result) {
    return tl::make_unexpected("failed to init download status" + result.error());
  }

  return {};
}

// src/main.cpp
// デバイス設定の変更を適用し、デバイスシャドウに通知する
void setup() {
	// 既存のコード
	// ...
	
	// デバイス設定をデバイスシャドウに通知
  if (auto result = syncShadow.reportConfig(configDiff); !result) {
    logger.error(ErrorCode::CONFIG_REPORT_FAILED, "failed to report config: " + result.error());
    return;
  }
  const auto reported = syncShadow.getReported();
  if (auto result = PersistentShadow::getInstance().save(reported); !result) {
    logger.error(ErrorCode::IO_FAILED, "failed to save app state: " + result.error());
    return;
  }
}

// src/sync_shadow.cpp
// デバイスシャドウの状態を報告
tl::expected<void, String> SyncShadow::report() const {
  if (!isWiFiConnected()) {
    return {};
  }
  const auto publishShadowUpdate = PublishShadowUpdate{.state = reported};
  const String payload = serializePublishShadowUpdate(publishShadowUpdate);
  if (client->publish(topicUpdate, payload)) {
    return {};
  } else {
    return tl::make_unexpected("Failed to publish shadow update");
  }
}

tl::expected<void, String> SyncShadow::reportConfig(const DeviceConfig &config) {
  updateDeviceConfig(*this->reported.config, config);
  if (auto result = this->report(); !result) {
    return tl::make_unexpected("failed to report config: " + result.error());
  }
  return {};
}

flutter: Request updateUser: {"firmware_version":"1.0.5"}

clocky_api_local  | 2024/04/17 11:50:00 received listen request from user: [USER_ID]
clocky_api_local  | 2024/04/17 11:50:00 received listen firmware update request from user: [USER_ID]
clocky_api_local  | 2024/04/17 11:50:00 received listen request from deviceId: [DEVICE_ID]
clocky_api_local  | 2024/04/17 11:50:00 sent message to user: 1
clocky_api_local  | subscribing to topic: $aws/things/[DEVICE_ID]/shadow/update/accepted
clocky_api_local  | {"time":"2024-04-17T11:50:00.754083024Z","id":"","remote_ip":"[IP_ADDRESS]","host":"[HOST_IP]:8080","method":"GET","uri":"/app/weather","user_agent":"Dart/3.3 (dart:io)","status":200,"error":"","latency":166399359,"latency_human":"166.399359ms","bytes_in":0,"bytes_out":233}

// device shadow
{
  "state": {
    "desired": {
      "config": {
        "firmware_version": "1.0.5"
      }
    },
    "reported": {
      "config": {
        "firmware_version": "1.0.4"
      }
    },
  }
}

MQTTPubSubClient::onMessage: $aws/things/[DEVICE_ID]/shadow/update/delta {"version":1242,"timestamp":[TIMESTAMP],"state":{"config":{"firmware_version":"1.0.5"}},"metadata":{"config":{"firmware_version":{"timestamp":[TIMESTAMP]}}}}
{"timestamp":[TIMESTAMP],"message":"device config changed","level":"DEBUG","thingName":"[DEVICE_ID]","freeHeap":[FREE_HEAP],"usedBytes":[USED_BYTES]}
MQTTPubSubClient::publish: mia/things/[DEVICE_ID]/logs {"timestamp":[TIMESTAMP],"message":"device config changed","level":"DEBUG","thingName":"[DEVICE_ID]","freeHeap":[FREE_HEAP],"usedBytes":[USED_BYTES]}
{"timestamp":[TIMESTAMP],"message":"config diff: {"config":{"firmware_version":"1.0.5"}}","level":"DEBUG","thingName":"[DEVICE_ID]","freeHeap":[FREE_HEAP],"usedBytes":[USED_BYTES]}
MQTTPubSubClient::publish: mia/things/[DEVICE_ID]/logs {"timestamp":[TIMESTAMP],"message":"config diff: {"config":{"firmware_version":"1.0.5"}}","level":"DEBUG","thingName":"[DEVICE_ID]","freeHeap":[FREE_HEAP],"usedBytes":[USED_BYTES]}
{"timestamp":[TIMESTAMP],"message":"Firmware version changed: 1.0.5","level":"DEBUG","thingName":"[DEVICE_ID]","freeHeap":[FREE_HEAP],"usedBytes":[USED_BYTES]}
MQTTPubSubClient::publish: mia/things/[DEVICE_ID]/logs {"timestamp":[TIMESTAMP],"message":"Firmware version changed: 1.0.5","level":"DEBUG","thingName":"[DEVICE_ID]","freeHeap":[FREE_HEAP],"usedBytes":[USED_BYTES]}

OTA firmware upgrade start
Starting OTA task
HTTP_EVENT_ON_CONNECTED
HTTP_EVENT_HEADER_SENT
HTTP_EVENT_ON_HEADER, key=x-amz-id-2, value=[AMAZON_ID]
HTTP_EVENT_ON_HEADER, key=x-amz-request-id, value=[REQUEST_ID]
HTTP_EVENT_ON_HEADER, key=Date, value=[DATE]
HTTP_EVENT_ON_HEADER, key=Last-Modified, value=[MODIFIED_DATE]
HTTP_EVENT_ON_HEADER, key=ETag, value="[ETAG_VALUE]"
HTTP_EVENT_ON_HEADER, key=x-amz-server-side-encryption, value=AES256
HTTP_EVENT_ON_HEADER, key=Accept-Ranges, value=bytes
HTTP_EVENT_ON_HEADER, key=Content-Type, value=application/octet-stream
HTTP_EVENT_ON_HEADER, key=Server, value=AmazonS3
HTTP_EVENT_ON_HEADER, key=Content-Length, value=[CONTENT_LENGTH]
HTTP_EVENT_ON_DATA, len=[DATA_LENGTH]
HTTP_EVENT_ON_DATA, len=[DATA_LENGTH]
HTTP_EVENT_ON_DATA, len=[DATA_LENGTH]
....
HTTP_EVENT_ON_DATA, len=[DATA_LENGTH]
HTTP_EVENT_DISCONNECTED
Total data received before disconnect: [TOTAL_BYTES] bytes
HTTP_EVENT_DISCONNECTED
Total data received before disconnect: [TOTAL_BYTES] bytes
Firmware upgrade succeeded

{
  "state": {
    "desired": {
      "config": {
        "firmware_version": "1.0.5"
      }
    },
    "reported": {
      "config": {
        "firmware_version": "1.0.4"
      }
    },
    "delta": {
      "config": {
        "firmware_version": "1.0.5"
      }
    }
  }
}

{
    "timestamp": [TIMESTAMP],
    "message": "Firmware version changed: 1.0.5",
    "level": "DEBUG",
    "thingName": "[DEVICE_ID]",
    "freeHeap": [FREE_HEAP],
    "usedBytes": [USED_BYTES]
}