基于ESP-IDF4.1

1 #include
2 #include "freertos/FreeRTOS.h"
3 #include "freertos/task.h"
4 #include "esp_system.h"
5 #include "esp_event.h"
6 #include "esp_log.h"
7 #include "esp_ota_ops.h"
8 #include "esp_http_client.h"
9 #include "esp_flash_partitions.h"
10 #include "esp_partition.h"
11 #include "nvs.h"
12 #include "nvs_flash.h"
13 #include "driver/gpio.h"
14 #include "protocol_examples_common.h"
15 #include "errno.h"
16
17 #if CONFIG_EXAMPLE_CONNECT_WIFI
18 #include "esp_wifi.h"
19 #endif
20
21 #define BUFFSIZE 1024
22 #define HASH_LEN 32 //sha256摘要长度
23
24 static const char *TAG = "native_ota_example";
25 //准备写入闪存的OTA数据写入缓冲区
26 static char ota_write_data[BUFFSIZE + 1] = { 0 };
27 extern const uint8_t server_cert_pem_start[] asm("_binary_ca_cert_pem_start");
28 extern const uint8_t server_cert_pem_end[] asm("_binary_ca_cert_pem_end");
29
30 #define OTA_URL_SIZE 256
31
32 static void http_cleanup(esp_http_client_handle_t client)
33 {
34 esp_http_client_close(client);
35 esp_http_client_cleanup(client);
36 }
37
38 //__attribute__((noreturn)) 这个属性告诉编译器函数不会返回，这可以用来抑制关于未达到代码路径的错误。
39 static void __attribute__((noreturn)) task_fatal_error(void)
40 {
41 ESP_LOGE(TAG, "Exiting task due to fatal error…");
42 (void)vTaskDelete(NULL);
43
44 while (1) {
45 ;
46 }
47 }
48
49 static void print_sha256 (const uint8_t *image_hash, const char *label)
50 {
51 char hash_print[HASH_LEN * 2 + 1];
52 hash_print[HASH_LEN * 2] = 0;
53 for (int i = 0; i < HASH_LEN; ++i) { 54 sprintf(&hash_print[i * 2], "%02x", image_hash[i]); 55 } 56 ESP_LOGI(TAG, "%s: %s", label, hash_print); 57 } 58 59 static void infinite_loop(void) 60 { 61 int i = 0; 62 ESP_LOGI(TAG, "When a new firmware is available on the server, press the reset button to download it"); 63 while(1) { 64 ESP_LOGI(TAG, "Waiting for a new firmware … %d", ++i); 65 vTaskDelay(2000 / portTICK_PERIOD_MS); 66 } 67 } 68 69 //OTA升级任务 70 static void ota_example_task(void *pvParameter) 71 { 72 esp_err_t err; 73 //更新处理程序，通过esp_ota_begin()设置，必须通过esp_ota_end()释放 74 esp_ota_handle_t update_handle = 0 ; 75 const esp_partition_t *update_partition = NULL; 76 77 ESP_LOGI(TAG, "Starting OTA example"); 78 79 const esp_partition_t *configured = esp_ota_get_boot_partition(); 80 const esp_partition_t *running = esp_ota_get_running_partition(); 81 82 if (configured != running) { 83 ESP_LOGW(TAG, "Configured OTA boot partition at offset 0x%08x, but running from offset 0x%08x", 84 configured->address, running->address);
85 ESP_LOGW(TAG, "(This can happen if either the OTA boot data or preferred boot image become corrupted somehow.)");
86 }
87 ESP_LOGI(TAG, "Running partition type %d subtype %d (offset 0x%08x)",
88 running->type, running->subtype, running->address);
89
90 esp_http_client_config_t config = {
91 .url = CONFIG_EXAMPLE_FIRMWARE_UPG_URL,
92 .cert_pem = (char *)server_cert_pem_start,
93 .timeout_ms = CONFIG_EXAMPLE_OTA_RECV_TIMEOUT,
94 };
95
96 #ifdef CONFIG_EXAMPLE_FIRMWARE_UPGRADE_URL_FROM_STDIN
97 char url_buf[OTA_URL_SIZE];
98 if (strcmp(config.url, "FROM_STDIN") == 0) {
99 example_configure_stdin_stdout();
100 fgets(url_buf, OTA_URL_SIZE, stdin);
101 int len = strlen(url_buf);
102 url_buf[len - 1] = '\0';
103 config.url = url_buf;
104 } else {
105 ESP_LOGE(TAG, "Configuration mismatch: wrong firmware upgrade image url");
106 abort();
107 }
108 #endif
109
110 #ifdef CONFIG_EXAMPLE_SKIP_COMMON_NAME_CHECK
111 config.skip_cert_common_name_check = true;
112 #endif
113
114 esp_http_client_handle_t client = esp_http_client_init(&config);
115 if (client == NULL) {
116 ESP_LOGE(TAG, "Failed to initialise HTTP connection");
117 task_fatal_error();
118 }
119 err = esp_http_client_open(client, 0);
120 if (err != ESP_OK) {
121 ESP_LOGE(TAG, "Failed to open HTTP connection: %s", esp_err_to_name(err));
122 esp_http_client_cleanup(client);
123 task_fatal_error();
124 }
125 esp_http_client_fetch_headers(client);
126
127 update_partition = esp_ota_get_next_update_partition(NULL);
128 ESP_LOGI(TAG, "Writing to partition subtype %d at offset 0x%x",
129 update_partition->subtype, update_partition->address);
130 assert(update_partition != NULL);
131
132 int binary_file_length = 0;
133 //处理所有接收数据包
134 bool image_header_was_checked = false;
135 while (1) {
136 int data_read = esp_http_client_read(client, ota_write_data, BUFFSIZE);
137 if (data_read < 0) { 138 ESP_LOGE(TAG, "Error: SSL data read error"); 139 http_cleanup(client); 140 task_fatal_error(); 141 } else if (data_read > 0) {
142 if (image_header_was_checked == false) {
143 esp_app_desc_t new_app_info;
144 if (data_read > sizeof(esp_image_header_t) + sizeof(esp_image_segment_header_t) + sizeof(esp_app_desc_t)) {
145 //通过下载检查当前版本
146 memcpy(&new_app_info, &ota_write_data[sizeof(esp_image_header_t) + sizeof(esp_image_segment_header_t)], sizeof(esp_app_desc_t));
147 ESP_LOGI(TAG, "New firmware version: %s", new_app_info.version);
148
149 esp_app_desc_t running_app_info;
150 if (esp_ota_get_partition_description(running, &running_app_info) == ESP_OK) {
151 ESP_LOGI(TAG, "Running firmware version: %s", running_app_info.version);
152 }
153
154 const esp_partition_t* last_invalid_app = esp_ota_get_last_invalid_partition();
155 esp_app_desc_t invalid_app_info;
156 if (esp_ota_get_partition_description(last_invalid_app, &invalid_app_info) == ESP_OK) {
157 ESP_LOGI(TAG, "Last invalid firmware version: %s", invalid_app_info.version);
158 }
159
160 //通过最新无效分区检查当前版本
161 if (last_invalid_app != NULL) {
162 if (memcmp(invalid_app_info.version, new_app_info.version, sizeof(new_app_info.version)) == 0) {
163 ESP_LOGW(TAG, "New version is the same as invalid version.");
164 ESP_LOGW(TAG, "Previously, there was an attempt to launch the firmware with %s version, but it failed.", invalid_app_info.version);
165 ESP_LOGW(TAG, "The firmware has been rolled back to the previous version.");
166 http_cleanup(client);
167 infinite_loop();
168 }
169 }
170 #ifndef CONFIG_EXAMPLE_SKIP_VERSION_CHECK
171 if (memcmp(new_app_info.version, running_app_info.version, sizeof(new_app_info.version)) == 0) {
172 ESP_LOGW(TAG, "Current running version is the same as a new. We will not continue the update.");
173 http_cleanup(client);
174 infinite_loop();
175 }
176 #endif
177
178 image_header_was_checked = true;
179
180 err = esp_ota_begin(update_partition, OTA_SIZE_UNKNOWN, &update_handle);
181 if (err != ESP_OK) {
182 ESP_LOGE(TAG, "esp_ota_begin failed (%s)", esp_err_to_name(err));
183 http_cleanup(client);
184 task_fatal_error();
185 }
186 ESP_LOGI(TAG, "esp_ota_begin succeeded");
187 } else {
188 ESP_LOGE(TAG, "received package is not fit len");
189 http_cleanup(client);
190 task_fatal_error();
191 }
192 }
193 err = esp_ota_write( update_handle, (const void *)ota_write_data, data_read);
194 if (err != ESP_OK) {
195 http_cleanup(client);
196 task_fatal_error();
197 }
198 binary_file_length += data_read;
199 ESP_LOGD(TAG, "Written image length %d", binary_file_length);
200 } else if (data_read == 0) {
201 //由于esp_http_client_read从不返回负错误代码，因此我们依赖“errno”来检查底层传输连接关闭（如果有）
202 if (errno == ECONNRESET || errno == ENOTCONN) {
203 ESP_LOGE(TAG, "Connection closed, errno = %d", errno);
204 break;
205 }
206 if (esp_http_client_is_complete_data_received(client) == true) {
207 ESP_LOGI(TAG, "Connection closed");
208 break;
209 }
210 }
211 }
212 ESP_LOGI(TAG, "Total Write binary data length: %d", binary_file_length);
213 if (esp_http_client_is_complete_data_received(client) != true) {
214 ESP_LOGE(TAG, "Error in receiving complete file");
215 http_cleanup(client);
216 task_fatal_error();
217 }
218
219 err = esp_ota_end(update_handle);
220 if (err != ESP_OK) {
221 if (err == ESP_ERR_OTA_VALIDATE_FAILED) {
222 ESP_LOGE(TAG, "Image validation failed, image is corrupted");
223 }
224 ESP_LOGE(TAG, "esp_ota_end failed (%s)!", esp_err_to_name(err));
225 http_cleanup(client);
226 task_fatal_error();
227 }
228
229 err = esp_ota_set_boot_partition(update_partition);
230 if (err != ESP_OK) {
231 ESP_LOGE(TAG, "esp_ota_set_boot_partition failed (%s)!", esp_err_to_name(err));
232 http_cleanup(client);
233 task_fatal_error();
234 }
235 ESP_LOGI(TAG, "Prepare to restart system!");
236 esp_restart();
237 return ;
238 }
239
240 //诊断
241 static bool diagnostic(void)
242 {
243 gpio_config_t io_conf;
244 io_conf.intr_type = GPIO_PIN_INTR_DISABLE;
245 io_conf.mode = GPIO_MODE_INPUT;
246 io_conf.pin_bit_mask = (1ULL << CONFIG_EXAMPLE_GPIO_DIAGNOSTIC);
247 io_conf.pull_down_en = GPIO_PULLDOWN_DISABLE;
248 io_conf.pull_up_en = GPIO_PULLUP_ENABLE;
249 gpio_config(&io_conf);
250
251 ESP_LOGI(TAG, "Diagnostics (5 sec)…");
252 vTaskDelay(5000 / portTICK_PERIOD_MS);
253
254 bool diagnostic_is_ok = gpio_get_level(CONFIG_EXAMPLE_GPIO_DIAGNOSTIC);
255
256 gpio_reset_pin(CONFIG_EXAMPLE_GPIO_DIAGNOSTIC);
257 return diagnostic_is_ok;
258 }
259
260 void app_main(void)
261 {
262 uint8_t sha_256[HASH_LEN] = { 0 };
263 esp_partition_t partition;
264
265 //获取分区表的sha256摘要
266 partition.address = ESP_PARTITION_TABLE_OFFSET;
267 partition.size = ESP_PARTITION_TABLE_MAX_LEN;
268 partition.type = ESP_PARTITION_TYPE_DATA;
269 esp_partition_get_sha256(&partition, sha_256);
270 print_sha256(sha_256, "SHA-256 for the partition table: ");
271
272 //获取引导加载程序的sha256摘要
273 partition.address = ESP_BOOTLOADER_OFFSET;
274 partition.size = ESP_PARTITION_TABLE_OFFSET;
275 partition.type = ESP_PARTITION_TYPE_APP;
276 esp_partition_get_sha256(&partition, sha_256);
277 print_sha256(sha_256, "SHA-256 for bootloader: ");
278
279 //获取运行分区的sha256摘要
280 esp_partition_get_sha256(esp_ota_get_running_partition(), sha_256);
281 print_sha256(sha_256, "SHA-256 for current firmware: ");
282
283 const esp_partition_t *running = esp_ota_get_running_partition();
284 esp_ota_img_states_t ota_state;
285 if (esp_ota_get_state_partition(running, &ota_state) == ESP_OK) {
286 if (ota_state == ESP_OTA_IMG_PENDING_VERIFY) {
287 // 运行诊断功能 …
288 bool diagnostic_is_ok = diagnostic();
289 if (diagnostic_is_ok) {
290 ESP_LOGI(TAG, "Diagnostics completed successfully! Continuing execution …");
291 esp_ota_mark_app_valid_cancel_rollback();
292 } else {
293 ESP_LOGE(TAG, "Diagnostics failed! Start rollback to the previous version …");
294 esp_ota_mark_app_invalid_rollback_and_reboot();
295 }
296 }
297 }
298
299 // 初始化NVS
300 esp_err_t err = nvs_flash_init();
301 if (err == ESP_ERR_NVS_NO_FREE_PAGES || err == ESP_ERR_NVS_NEW_VERSION_FOUND) {
302 //OTA应用程序分区表有一个比非OTA分区表更小的NVS分区。大小不匹配可能导致NVS初始化失败，如果发生这种情况，我们擦除NVS分区并在此初始化NVS
303 ESP_ERROR_CHECK(nvs_flash_erase());
304 err = nvs_flash_init();
305 }
306 ESP_ERROR_CHECK( err );
307
308 ESP_ERROR_CHECK(esp_netif_init());
309 ESP_ERROR_CHECK(esp_event_loop_create_default());
310
311 //连接网络
312 ESP_ERROR_CHECK(example_connect());
313
314 #if CONFIG_EXAMPLE_CONNECT_WIFI
315 //确保禁用低功耗模式，这样可以提供最佳的吞吐量从而节省OTA操作的时间
316 esp_wifi_set_ps(WIFI_PS_NONE);
317 #endif
318 xTaskCreate(&ota_example_task, "ota_example_task", 8192, NULL, 5, NULL);
319 }

原文：https://gitee.com/EspressifSystems/esp-idf/tree/master/examples/system/ota