深海游弋的鱼 – 第 2 页

【玩转ESP32】ESP32串口使用

1、ESP32串口

ESP32芯片有三个UART控制器(UART0, UART1和UART2)，其中UART0（GPIO3用于U0RXD，GPIO1用于U0TXD）用作下载、调试串口，引脚不可改变；

UART1和UART2的引脚是可以设置的。 UART1默认引脚是GPIO9用作U1RXD，GPIO10用作U1TXD，但是这两个引脚也是用于外接flash的，因此在使用UART1的时候需要设置其他引脚；

UART2默认引脚是GPIO16用作U2RXD，GPIO17用作U2TXD。

2、API

在components/driver/include/driver/uart.h中可以查看api；

在examples/peripherals/uart中也可以参考官方的各种串口例程。

2.1、安装uart驱动

esp_err_t uart_driver_install(uart_port_t uart_num, int rx_buffer_size, int tx_buffer_size, int queue_size, QueueHandle_t* uart_queue, int intr_alloc_flags);

1	esp_err_t uart_driver_install(uart_port_t uart_num, int rx_buffer_size, int tx_buffer_size, int queue_size, QueueHandle_t* uart_queue, int intr_alloc_flags);

这里要注意参数：uart_queue属于freertos里面的队列句柄，在这里表示用于指示来自串口底层中断的队列消息。

2.2、uart参数配置

esp_err_t uart_param_config(uart_port_t uart_num, const uart_config_t *uart_config);

1	esp_err_t uart_param_config(uart_port_t uart_num, const uart_config_t *uart_config);

2.3、接收阈值设置

esp_err_t uart_set_rx_full_threshold(uart_port_t uart_num, int threshold);

1	esp_err_t uart_set_rx_full_threshold(uart_port_t uart_num, int threshold);

2.4、串口引脚设置

esp_err_t uart_set_pin(uart_port_t uart_num, int tx_io_num, int rx_io_num, int rts_io_num, int cts_io_num);

1	esp_err_t uart_set_pin(uart_port_t uart_num, int tx_io_num, int rx_io_num, int rts_io_num, int cts_io_num);

2.5、从接收缓冲区读取数据

int uart_read_bytes(uart_port_t uart_num, uint8_t* buf, uint32_t length, TickType_t ticks_to_wait);

1	int uart_read_bytes(uart_port_t uart_num, uint8_t* buf, uint32_t length, TickType_t ticks_to_wait);

2.6、数据写入发送缓冲区

int uart_write_bytes(uart_port_t uart_num, const char* src, size_t size);

1	int uart_write_bytes(uart_port_t uart_num, const char* src, size_t size);

3、代码实现

3.1、参数定义

#define EX_UART_NUM UART_NUM_1  //串口1

#define TXD_PIN    (GPIO_NUM_17) //txd使用gpio17
#define RXD_PIN    (GPIO_NUM_16) //rxd使用gpio16

#define BUF_SIZE (128)   //缓冲区定义
static QueueHandle_t uart_queue; //队列句柄
static uint8_t  uartbuf[BUF_SIZE];

#define EX_UART_NUM UART_NUM_1 //串口1

#define TXD_PIN (GPIO_NUM_17) //txd使用gpio17

#define RXD_PIN (GPIO_NUM_16) //rxd使用gpio16

#define BUF_SIZE (128) //缓冲区定义

static QueueHandle_t uart_queue; //队列句柄

static uint8_t uartbuf[BUF_SIZE];

3.2、串口初始化

void uart_comm_init(void)
{
    /* Configure parameters of an UART driver,
     * communication pins and install the driver */
    uart_config_t uart_config = {
        .baud_rate = 115200,
        .data_bits = UART_DATA_8_BITS,
        .parity = UART_PARITY_DISABLE,
        .stop_bits = UART_STOP_BITS_1,
        .flow_ctrl = UART_HW_FLOWCTRL_DISABLE,
        .source_clk = UART_SCLK_APB,
    };
    //Install UART driver, and get the queue.
    uart_driver_install(EX_UART_NUM, BUF_SIZE * 2, BUF_SIZE * 2, 20, &uart_queue, 0);
    uart_param_config(EX_UART_NUM, &uart_config);
    uart_set_rx_full_threshold(EX_UART_NUM,126);

    //Set UART pins (using UART0 default pins ie no changes.)
    uart_set_pin(EX_UART_NUM, TXD_PIN, RXD_PIN, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);

    //Create a task to handler UART event from ISR
    xTaskCreate(uart_event_task, "uart_event_task", 2048, NULL, 12, NULL); //创建串口任务
}

void uart_comm_init(void)

{

/* Configure parameters of an UART driver,

* communication pins and install the driver */

uart_config_t uart_config = {

.baud_rate = 115200,

.data_bits = UART_DATA_8_BITS,

.parity = UART_PARITY_DISABLE,

.stop_bits = UART_STOP_BITS_1,

.flow_ctrl = UART_HW_FLOWCTRL_DISABLE,

.source_clk = UART_SCLK_APB,

};

//Install UART driver, and get the queue.

uart_driver_install(EX_UART_NUM, BUF_SIZE * 2, BUF_SIZE * 2, 20, &uart_queue, 0);

uart_param_config(EX_UART_NUM, &uart_config);

uart_set_rx_full_threshold(EX_UART_NUM,126);

//Set UART pins (using UART0 default pins ie no changes.)

uart_set_pin(EX_UART_NUM, TXD_PIN, RXD_PIN, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);

//Create a task to handler UART event from ISR

xTaskCreate(uart_event_task, "uart_event_task", 2048, NULL, 12, NULL); //创建串口任务

}

3.3、串口任务函数

static void uart_event_task(void *pvParameters)
{
    uart_event_t event;
    for(;;) {
        //阻塞接收串口队列，
        //这个队列在底层发送，用户只需在应用层接收即可
        if(xQueueReceive(uart_queue, (void * )&event, (portTickType)portMAX_DELAY)) {
            switch(event.type) {//各种串口事件
                case UART_DATA:
                    ESP_LOGI(TAG, "[UART DATA]: %d", event.size);
                    uart_read_bytes(EX_UART_NUM, uartbuf, event.size, portMAX_DELAY); //阻塞接收
                    ESP_LOGI(TAG, "[DATA EVT]:");
                    uart_write_bytes(EX_UART_NUM, uartbuf, event.size);//原样发送
                    break;
                //Event of HW FIFO overflow detected
                case UART_FIFO_OVF: //硬件fifo溢出
                    ESP_LOGI(TAG, "hw fifo overflow");
                    // If fifo overflow happened, you should consider adding flow control for your application.
                    // The ISR has already reset the rx FIFO,
                    // As an example, we directly flush the rx buffer here in order to read more data.
                    uart_flush_input(EX_UART_NUM);
                    xQueueReset(uart_queue);
                    break;
                //Event of UART ring buffer full
                case UART_BUFFER_FULL: //环形缓冲区满
                    ESP_LOGI(TAG, "ring buffer full");
                    // If buffer full happened, you should consider encreasing your buffer size
                    // As an example, we directly flush the rx buffer here in order to read more data.
                    uart_flush_input(EX_UART_NUM);
                    xQueueReset(uart_queue);
                    break;
                //Event of UART RX break detected
                case UART_BREAK:
                    ESP_LOGI(TAG, "uart rx break");
                    break;
                //Event of UART parity check error
                case UART_PARITY_ERR:
                    ESP_LOGI(TAG, "uart parity error");
                    break;
                //Event of UART frame error
                case UART_FRAME_ERR:
                    ESP_LOGI(TAG, "uart frame error");
                    break;
                //UART_PATTERN_DET
                case UART_PATTERN_DET:
                    break;
                //Others
                default:
                    ESP_LOGI(TAG, "uart event type: %d", event.type);
                    break;
            }
        }
    }
    vTaskDelete(NULL);
}

static void uart_event_task(void *pvParameters)

{

uart_event_t event;

for(;;) {

//阻塞接收串口队列，

//这个队列在底层发送，用户只需在应用层接收即可

if(xQueueReceive(uart_queue, (void * )&event, (portTickType)portMAX_DELAY)) {

switch(event.type) {//各种串口事件

case UART_DATA:

ESP_LOGI(TAG, "[UART DATA]: %d", event.size);

uart_read_bytes(EX_UART_NUM, uartbuf, event.size, portMAX_DELAY); //阻塞接收

ESP_LOGI(TAG, "[DATA EVT]:");

uart_write_bytes(EX_UART_NUM, uartbuf, event.size);//原样发送

break;

//Event of HW FIFO overflow detected

case UART_FIFO_OVF: //硬件fifo溢出

ESP_LOGI(TAG, "hw fifo overflow");

// If fifo overflow happened, you should consider adding flow control for your application.

// The ISR has already reset the rx FIFO,

// As an example, we directly flush the rx buffer here in order to read more data.

uart_flush_input(EX_UART_NUM);

xQueueReset(uart_queue);

break;

//Event of UART ring buffer full

case UART_BUFFER_FULL: //环形缓冲区满

ESP_LOGI(TAG, "ring buffer full");

// If buffer full happened, you should consider encreasing your buffer size

// As an example, we directly flush the rx buffer here in order to read more data.

uart_flush_input(EX_UART_NUM);

xQueueReset(uart_queue);

break;

//Event of UART RX break detected

case UART_BREAK:

ESP_LOGI(TAG, "uart rx break");

break;

//Event of UART parity check error

case UART_PARITY_ERR:

ESP_LOGI(TAG, "uart parity error");

break;

//Event of UART frame error

case UART_FRAME_ERR:

ESP_LOGI(TAG, "uart frame error");

break;

//UART_PATTERN_DET

case UART_PATTERN_DET:

break;

//Others

default:

ESP_LOGI(TAG, "uart event type: %d", event.type);

break;

}

vTaskDelete(NULL);

}

4、使用总结

初始化串口参数，（队列指针、缓冲区、引脚等）；
任务中阻塞等待串口队列。

如何实现 ESP32 固件的 OTA 在线升级更新

1、背景

在实际产品开发过程中，在线升级可以远程解决产品软件开发引入的问题，更好地满足用户需求。

2、OTA 简介

OTA（空中）更新是使用 Wi-Fi 连接而不是串行端口将固件加载到 ESP 模块的过程。

2.1、ESP32 的 OTA 升级有三种方式：

Arduino IDE：主要用于软件开发阶段，实现不接线固件烧写
Web Browser：通过 Web 浏览器手动提供应用程序更新模块
HTTP Server：自动使用http服务器 - 针对产品应用

在三种升级情况下，必须通过串行端口完成第一个固件上传。

OTA 进程没有强加的安全性，需要确保开发人员只能从合法/受信任的来源获得更新。更新完成后，模块将重新启动，并执行新的代码。开发人员应确保在模块上运行的应用程序以安全的方式关闭并重新启动。

2.2、保密性 Security

模块必须以无线方式显示，以便通过新的草图进行更新。这使得模块被强行入侵并加载了其他代码。为了减少被黑客入侵的可能性，请考虑使用密码保护您的上传，选择某些OTA端口等。

可以提高安全性的 ArduinoOTA 库接口：

void setPort(uint16_t port);
void setHostname(const char* hostname);
void setPassword(const char* password);

void setPort(uint16_t port);

void setHostname(const char* hostname);

void setPassword(const char* password);

void onStart(OTA_CALLBACK(fn));
void onEnd(OTA_CALLBACK(fn));
void onProgress(OTA_CALLBACK_PROGRESS(fn));
void onError(OTA_CALLBACK_ERROR (fn));

void onStart(OTA_CALLBACK(fn));

void onEnd(OTA_CALLBACK(fn));

void onProgress(OTA_CALLBACK_PROGRESS(fn));

void onError(OTA_CALLBACK_ERROR (fn));

已经内置了某些保护功能，不需要开发人员进行任何其他编码。ArduinoOTA和espota.py使用Digest-MD5来验证上传。使用MD5校验和，在ESP端验证传输数据的完整性。

2.3、OTA 升级策略 - 针对 HTTP

ESP32 连接 HTTP 服务器，发送请求 Get 升级固件；每次读取1KB固件数据，写入Flash。

ESP32 SPI Flash 内有与升级相关的（至少）四个分区：OTA data、Factory App、OTA_0、OTA_1。其中 FactoryApp 内存有出厂时的默认固件。

首次进行 OTA 升级时，OTA Demo 向 OTA_0 分区烧录目标固件，并在烧录完成后，更新 OTA data 分区数据并重启。

系统重启时获取 OTA data 分区数据进行计算，决定此后加载 OTA_0 分区的固件执行（而不是默认的 Factory App 分区内的固件），从而实现升级。

同理，若某次升级后 ESP32 已经在执行 OTA_0 内的固件，此时再升级时 OTA Demo 就会向 OTA_1 分区写入目标固件。再次启动后，执行 OTA_1 分区实现升级。以此类推，升级的目标固件始终在 OTA_0、OTA_1 两个分区之间交互烧录，不会影响到出厂时的 Factory App 固件。

3、OTA 实例解析

3.1、Arduino IDE方案固件更新

从 Arduino IDE 无线上传模块适用于以下典型场景：

在固件开发过程中，通过串行加载更快的替代方案 - 用于更新少量模块，只有模块在与 Arduino IDE 的计算机相同的网络上可用。

参考实例：

#include <WiFi.h>
#include <ESPmDNS.h>
#include <WiFiUdp.h>
#include <ArduinoOTA.h>
 
const char* ssid = "..........";
const char* password = "..........";
 
void setup() {
  Serial.begin(115200);
  Serial.println("Booting");
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  while (WiFi.waitForConnectResult() != WL_CONNECTED) {
    Serial.println("Connection Failed! Rebooting...");
    delay(5000);
    ESP.restart();
  }
 
  // Port defaults to 3232
  // ArduinoOTA.setPort(3232);
 
  // Hostname defaults to esp3232-[MAC]
  // ArduinoOTA.setHostname("myesp32");
 
  // No authentication by default
  // ArduinoOTA.setPassword("admin");
 
  // Password can be set with it's md5 value as well
  // MD5(admin) = 21232f297a57a5a743894a0e4a801fc3
  // ArduinoOTA.setPasswordHash("21232f297a57a5a743894a0e4a801fc3");
 
  ArduinoOTA
    .onStart([]() {
      String type;
      if (ArduinoOTA.getCommand() == U_FLASH)
        type = "sketch";
      else // U_SPIFFS
        type = "filesystem";
 
      // NOTE: if updating SPIFFS this would be the place to unmount SPIFFS using SPIFFS.end()
      Serial.println("Start updating " + type);
    })
    .onEnd([]() {
      Serial.println("\nEnd");
    })
    .onProgress([](unsigned int progress, unsigned int total) {
      Serial.printf("Progress: %u%%\r", (progress / (total / 100)));
    })
    .onError([](ota_error_t error) {
      Serial.printf("Error[%u]: ", error);
      if (error == OTA_AUTH_ERROR) Serial.println("Auth Failed");
      else if (error == OTA_BEGIN_ERROR) Serial.println("Begin Failed");
      else if (error == OTA_CONNECT_ERROR) Serial.println("Connect Failed");
      else if (error == OTA_RECEIVE_ERROR) Serial.println("Receive Failed");
      else if (error == OTA_END_ERROR) Serial.println("End Failed");
    });
 
  ArduinoOTA.begin();
 
  Serial.println("Ready");
  Serial.print("IP address: ");
  Serial.println(WiFi.localIP());
}
 
void loop() {
  ArduinoOTA.handle();
}

#include <WiFi.h>

#include <ESPmDNS.h>

#include <WiFiUdp.h>

#include <ArduinoOTA.h>

const char* ssid = "..........";

const char* password = "..........";

void setup() {

Serial.begin(115200);

Serial.println("Booting");

WiFi.mode(WIFI_STA);

WiFi.begin(ssid, password);

while (WiFi.waitForConnectResult() != WL_CONNECTED) {

Serial.println("Connection Failed! Rebooting...");

delay(5000);

ESP.restart();

}

// Port defaults to 3232

// ArduinoOTA.setPort(3232);

// Hostname defaults to esp3232-[MAC]

// ArduinoOTA.setHostname("myesp32");

// No authentication by default

// ArduinoOTA.setPassword("admin");

// Password can be set with it's md5 value as well

// MD5(admin) = 21232f297a57a5a743894a0e4a801fc3

// ArduinoOTA.setPasswordHash("21232f297a57a5a743894a0e4a801fc3");

ArduinoOTA

.onStart([]() {

String type;

if (ArduinoOTA.getCommand() == U_FLASH)

type = "sketch";

else // U_SPIFFS

type = "filesystem";

// NOTE: if updating SPIFFS this would be the place to unmount SPIFFS using SPIFFS.end()

Serial.println("Start updating " + type);

})

.onEnd([]() {

Serial.println("\nEnd");

})

.onProgress([](unsigned int progress, unsigned int total) {

Serial.printf("Progress: %u%%\r", (progress / (total / 100)));

})

.onError([](ota_error_t error) {

Serial.printf("Error[%u]: ", error);

if (error == OTA_AUTH_ERROR) Serial.println("Auth Failed");

else if (error == OTA_BEGIN_ERROR) Serial.println("Begin Failed");

else if (error == OTA_CONNECT_ERROR) Serial.println("Connect Failed");

else if (error == OTA_RECEIVE_ERROR) Serial.println("Receive Failed");

else if (error == OTA_END_ERROR) Serial.println("End Failed");

});

ArduinoOTA.begin();

Serial.println("Ready");

Serial.print("IP address: ");

Serial.println(WiFi.localIP());

}

void loop() {

ArduinoOTA.handle();

}

3.2、Web Browser 方案固件更新

该方案使用场景：

直接从 Arduino IDE 加载是不方便或不可能的

用户无法从外部更新服务器公开 OTA 的模块

在设置更新服务器不可行时，将部署后的更新提供给少量模块

参考实例：

#include <WiFi.h>
#include <WiFiClient.h>
#include <WebServer.h>
#include <ESPmDNS.h>
#include <Update.h>
 
const char* host = "esp32";
const char* ssid = "xxx";
const char* password = "xxxx";
 
WebServer server(80);
 
/*
 * Login page
 */
 
const char* loginIndex = 
 "<form name='loginForm'>"
    "<table width='20%' bgcolor='A09F9F' align='center'>"
        "<tr>"
            "<td colspan=2>"
                "<center><font size=4><b>ESP32 Login Page</b></font></center>"
                "<br>"
            "</td>"
            "<br>"
            "<br>"
        "</tr>"
        "<td>Username:</td>"
        "<td><input type='text' size=25 name='userid'><br></td>"
        "</tr>"
        "<br>"
        "<br>"
        "<tr>"
            "<td>Password:</td>"
            "<td><input type='Password' size=25 name='pwd'><br></td>"
            "<br>"
            "<br>"
        "</tr>"
        "<tr>"
            "<td><input type='submit' onclick='check(this.form)' value='Login'></td>"
        "</tr>"
    "</table>"
"</form>"
"<script>"
    "function check(form)"
    "{"
    "if(form.userid.value=='admin' && form.pwd.value=='admin')"
    "{"
    "window.open('/serverIndex')"
    "}"
    "else"
    "{"
    " alert('Error Password or Username')/*displays error message*/"
    "}"
    "}"
"</script>";
 
/*
 * Server Index Page
 */
 
const char* serverIndex = 
"<script src='https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js'></script>"
"<form method='POST' action='#' enctype='multipart/form-data' id='upload_form'>"
   "<input type='file' name='update'>"
        "<input type='submit' value='Update'>"
    "</form>"
 "<div id='prg'>progress: 0%</div>"
 "<script>"
  "$('form').submit(function(e){"
  "e.preventDefault();"
  "var form = $('#upload_form')[0];"
  "var data = new FormData(form);"
  " $.ajax({"
  "url: '/update',"
  "type: 'POST',"
  "data: data,"
  "contentType: false,"
  "processData:false,"
  "xhr: function() {"
  "var xhr = new window.XMLHttpRequest();"
  "xhr.upload.addEventListener('progress', function(evt) {"
  "if (evt.lengthComputable) {"
  "var per = evt.loaded / evt.total;"
  "$('#prg').html('progress: ' + Math.round(per*100) + '%');"
  "}"
  "}, false);"
  "return xhr;"
  "},"
  "success:function(d, s) {"
  "console.log('success!')" 
 "},"
 "error: function (a, b, c) {"
 "}"
 "});"
 "});"
 "</script>";
 
/*
 * setup function
 */
void setup(void) {
  Serial.begin(115200);
 
  // Connect to WiFi network
  WiFi.begin(ssid, password);
  Serial.println("");
 
  // Wait for connection
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.print("Connected to ");
  Serial.println(ssid);
  Serial.print("IP address: ");
  Serial.println(WiFi.localIP());
 
  /*use mdns for host name resolution*/
  if (!MDNS.begin(host)) { //http://esp32.local
    Serial.println("Error setting up MDNS responder!");
    while (1) {
      delay(1000);
    }
  }
  Serial.println("mDNS responder started");
  /*return index page which is stored in serverIndex */
  server.on("/", HTTP_GET, []() {
    server.sendHeader("Connection", "close");
    server.send(200, "text/html", loginIndex);
  });
  server.on("/serverIndex", HTTP_GET, []() {
    server.sendHeader("Connection", "close");
    server.send(200, "text/html", serverIndex);
  });
  /*handling uploading firmware file */
  server.on("/update", HTTP_POST, []() {
    server.sendHeader("Connection", "close");
    server.send(200, "text/plain", (Update.hasError()) ? "FAIL" : "OK");
    ESP.restart();
  }, []() {
    HTTPUpload& upload = server.upload();
    if (upload.status == UPLOAD_FILE_START) {
      Serial.printf("Update: %s\n", upload.filename.c_str());
      if (!Update.begin(UPDATE_SIZE_UNKNOWN)) { //start with max available size
        Update.printError(Serial);
      }
    } else if (upload.status == UPLOAD_FILE_WRITE) {
      /* flashing firmware to ESP*/
      if (Update.write(upload.buf, upload.currentSize) != upload.currentSize) {
        Update.printError(Serial);
      }
    } else if (upload.status == UPLOAD_FILE_END) {
      if (Update.end(true)) { //true to set the size to the current progress
        Serial.printf("Update Success: %u\nRebooting...\n", upload.totalSize);
      } else {
        Update.printError(Serial);
      }
    }
  });
  server.begin();
}
 
void loop(void) {
  server.handleClient();
  delay(1);
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

#include <WiFi.h>

#include <WiFiClient.h>

#include <WebServer.h>

#include <ESPmDNS.h>

#include <Update.h>

const char* host = "esp32";

const char* ssid = "xxx";

const char* password = "xxxx";

WebServer server(80);

* Login page

const char* loginIndex =

"<form name='loginForm'>"

"<table width='20%' bgcolor='A09F9F' align='center'>"

"<tr>"

"<td colspan=2>"

"<center><font size=4><b>ESP32 Login Page</b></font></center>"

"<br>"

"</td>"

"<br>"

"</tr>"

"<td>Username:</td>"

"<td><input type='text' size=25 name='userid'><br></td>"

"</tr>"

"<br>"

"<tr>"

"<td>Password:</td>"

"<td><input type='Password' size=25 name='pwd'><br></td>"

"<br>"

"</tr>"

"<tr>"

"<td><input type='submit' onclick='check(this.form)' value='Login'></td>"

"</tr>"

"</table>"

"</form>"

"<script>"

"function check(form)"

"{"

"if(form.userid.value=='admin' && form.pwd.value=='admin')"

"{"

"window.open('/serverIndex')"

"}"

"else"

"{"

" alert('Error Password or Username')/*displays error message*/"

"}"

"</script>";

* Server Index Page

const char* serverIndex =

"<script src='https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js'></script>"

"<form method='POST' action='#' enctype='multipart/form-data' id='upload_form'>"

"<input type='file' name='update'>"

"<input type='submit' value='Update'>"

"</form>"

"<div id='prg'>progress: 0%</div>"

"<script>"

"$('form').submit(function(e){"

"e.preventDefault();"

"var form = $('#upload_form')[0];"

"var data = new FormData(form);"

" $.ajax({"

"url: '/update',"

"type: 'POST',"

"data: data,"

"contentType: false,"

"processData:false,"

"xhr: function() {"

"var xhr = new window.XMLHttpRequest();"

"xhr.upload.addEventListener('progress', function(evt) {"

"if (evt.lengthComputable) {"

"var per = evt.loaded / evt.total;"

"$('#prg').html('progress: ' + Math.round(per*100) + '%');"

"}"

"}, false);"

"return xhr;"

"},"

"success:function(d, s) {"

"console.log('success!')"

"},"

"error: function (a, b, c) {"

"}"

"});"

"</script>";

* setup function

void setup(void) {

Serial.begin(115200);

// Connect to WiFi network

WiFi.begin(ssid, password);

Serial.println("");

// Wait for connection

while (WiFi.status() != WL_CONNECTED) {

delay(500);

Serial.print(".");

}

Serial.println("");

Serial.print("Connected to ");

Serial.println(ssid);

Serial.print("IP address: ");

Serial.println(WiFi.localIP());

/*use mdns for host name resolution*/

if (!MDNS.begin(host)) { //http://esp32.local

Serial.println("Error setting up MDNS responder!");

while (1) {

delay(1000);

}

Serial.println("mDNS responder started");

/*return index page which is stored in serverIndex */

server.on("/", HTTP_GET, []() {

server.sendHeader("Connection", "close");

server.send(200, "text/html", loginIndex);

});

server.on("/serverIndex", HTTP_GET, []() {

server.sendHeader("Connection", "close");

server.send(200, "text/html", serverIndex);

});

/*handling uploading firmware file */

server.on("/update", HTTP_POST, []() {

server.sendHeader("Connection", "close");

server.send(200, "text/plain", (Update.hasError()) ? "FAIL" : "OK");

ESP.restart();

}, []() {

HTTPUpload& upload = server.upload();

if (upload.status == UPLOAD_FILE_START) {

Serial.printf("Update: %s\n", upload.filename.c_str());

if (!Update.begin(UPDATE_SIZE_UNKNOWN)) { //start with max available size

Update.printError(Serial);

}

} else if (upload.status == UPLOAD_FILE_WRITE) {

/* flashing firmware to ESP*/

if (Update.write(upload.buf, upload.currentSize) != upload.currentSize) {

Update.printError(Serial);

}

} else if (upload.status == UPLOAD_FILE_END) {

if (Update.end(true)) { //true to set the size to the current progress

Serial.printf("Update Success: %u\nRebooting...\n", upload.totalSize);

} else {

Update.printError(Serial);

}

});

server.begin();

}

void loop(void) {

server.handleClient();

delay(1);

}

3.3、HTTP 服务器实现更新

ESPhttpUpdate 类可以检查更新并从 HTTP Web 服务器下载二进制文件。可以从网络或 Internet 上的每个 IP 或域名地址下载更新，主要应用于远程服务器更新升级。

参考实例：

/**
   AWS S3 OTA Update
   Date: 14th June 2017
   Author: Arvind Ravulavaru <https://github.com/arvindr21>
   Purpose: Perform an OTA update from a bin located in Amazon S3 (HTTP Only)
 
   Upload:
   Step 1 : Download the sample bin file from the examples folder
   Step 2 : Upload it to your Amazon S3 account, in a bucket of your choice
   Step 3 : Once uploaded, inside S3, select the bin file >> More (button on top of the file list) >> Make Public
   Step 4 : You S3 URL => http://bucket-name.s3.ap-south-1.amazonaws.com/sketch-name.ino.bin
   Step 5 : Build the above URL and fire it either in your browser or curl it `curl -I -v http://bucket-name.ap-south-1.amazonaws.com/sketch-name.ino.bin` to validate the same
   Step 6:  Plug in your SSID, Password, S3 Host and Bin file below
 
   Build & upload
   Step 1 : Menu > Sketch > Export Compiled Library. The bin file will be saved in the sketch folder (Menu > Sketch > Show Sketch folder)
   Step 2 : Upload bin to S3 and continue the above process
 
   // Check the bottom of this sketch for sample serial monitor log, during and after successful OTA Update
*/
 
#include <WiFi.h>
#include <Update.h>
 
WiFiClient client;
 
// Variables to validate
// response from S3
int contentLength = 0;
bool isValidContentType = false;
 
// Your SSID and PSWD that the chip needs
// to connect to
const char* SSID = "YOUR-SSID";
const char* PSWD = "YOUR-SSID-PSWD";
 
// S3 Bucket Config
String host = "bucket-name.s3.ap-south-1.amazonaws.com"; // Host => bucket-name.s3.region.amazonaws.com
int port = 80; // Non https. For HTTPS 443. As of today, HTTPS doesn't work.
String bin = "/sketch-name.ino.bin"; // bin file name with a slash in front.
 
// Utility to extract header value from headers
String getHeaderValue(String header, String headerName) {
  return header.substring(strlen(headerName.c_str()));
}
 
// OTA Logic 
void execOTA() {
  Serial.println("Connecting to: " + String(host));
  // Connect to S3
  if (client.connect(host.c_str(), port)) {
    // Connection Succeed.
    // Fecthing the bin
    Serial.println("Fetching Bin: " + String(bin));
 
    // Get the contents of the bin file
    client.print(String("GET ") + bin + " HTTP/1.1\r\n" +
                 "Host: " + host + "\r\n" +
                 "Cache-Control: no-cache\r\n" +
                 "Connection: close\r\n\r\n");
 
    // Check what is being sent
    //    Serial.print(String("GET ") + bin + " HTTP/1.1\r\n" +
    //                 "Host: " + host + "\r\n" +
    //                 "Cache-Control: no-cache\r\n" +
    //                 "Connection: close\r\n\r\n");
 
    unsigned long timeout = millis();
    while (client.available() == 0) {
      if (millis() - timeout > 5000) {
        Serial.println("Client Timeout !");
        client.stop();
        return;
      }
    }
    // Once the response is available,
    // check stuff
 
    /*
       Response Structure
        HTTP/1.1 200 OK
        x-amz-id-2: NVKxnU1aIQMmpGKhSwpCBh8y2JPbak18QLIfE+OiUDOos+7UftZKjtCFqrwsGOZRN5Zee0jpTd0=
        x-amz-request-id: 2D56B47560B764EC
        Date: Wed, 14 Jun 2017 03:33:59 GMT
        Last-Modified: Fri, 02 Jun 2017 14:50:11 GMT
        ETag: "d2afebbaaebc38cd669ce36727152af9"
        Accept-Ranges: bytes
        Content-Type: application/octet-stream
        Content-Length: 357280
        Server: AmazonS3
                                   
        {{BIN FILE CONTENTS}}
 
    */
    while (client.available()) {
      // read line till /n
      String line = client.readStringUntil('\n');
      // remove space, to check if the line is end of headers
      line.trim();
 
      // if the the line is empty,
      // this is end of headers
      // break the while and feed the
      // remaining `client` to the
      // Update.writeStream();
      if (!line.length()) {
        //headers ended
        break; // and get the OTA started
      }
 
      // Check if the HTTP Response is 200
      // else break and Exit Update
      if (line.startsWith("HTTP/1.1")) {
        if (line.indexOf("200") < 0) {
          Serial.println("Got a non 200 status code from server. Exiting OTA Update.");
          break;
        }
      }
 
      // extract headers here
      // Start with content length
      if (line.startsWith("Content-Length: ")) {
        contentLength = atoi((getHeaderValue(line, "Content-Length: ")).c_str());
        Serial.println("Got " + String(contentLength) + " bytes from server");
      }
 
      // Next, the content type
      if (line.startsWith("Content-Type: ")) {
        String contentType = getHeaderValue(line, "Content-Type: ");
        Serial.println("Got " + contentType + " payload.");
        if (contentType == "application/octet-stream") {
          isValidContentType = true;
        }
      }
    }
  } else {
    // Connect to S3 failed
    // May be try?
    // Probably a choppy network?
    Serial.println("Connection to " + String(host) + " failed. Please check your setup");
    // retry??
    // execOTA();
  }
 
  // Check what is the contentLength and if content type is `application/octet-stream`
  Serial.println("contentLength : " + String(contentLength) + ", isValidContentType : " + String(isValidContentType));
 
  // check contentLength and content type
  if (contentLength && isValidContentType) {
    // Check if there is enough to OTA Update
    bool canBegin = Update.begin(contentLength);
 
    // If yes, begin
    if (canBegin) {
      Serial.println("Begin OTA. This may take 2 - 5 mins to complete. Things might be quite for a while.. Patience!");
      // No activity would appear on the Serial monitor
      // So be patient. This may take 2 - 5mins to complete
      size_t written = Update.writeStream(client);
 
      if (written == contentLength) {
        Serial.println("Written : " + String(written) + " successfully");
      } else {
        Serial.println("Written only : " + String(written) + "/" + String(contentLength) + ". Retry?" );
        // retry??
        // execOTA();
      }
 
      if (Update.end()) {
        Serial.println("OTA done!");
        if (Update.isFinished()) {
          Serial.println("Update successfully completed. Rebooting.");
          ESP.restart();
        } else {
          Serial.println("Update not finished? Something went wrong!");
        }
      } else {
        Serial.println("Error Occurred. Error #: " + String(Update.getError()));
      }
    } else {
      // not enough space to begin OTA
      // Understand the partitions and
      // space availability
      Serial.println("Not enough space to begin OTA");
      client.flush();
    }
  } else {
    Serial.println("There was no content in the response");
    client.flush();
  }
}
 
void setup() {
  //Begin Serial
  Serial.begin(115200);
  delay(10);
 
  Serial.println("Connecting to " + String(SSID));
 
  // Connect to provided SSID and PSWD
  WiFi.begin(SSID, PSWD);
 
  // Wait for connection to establish
  while (WiFi.status() != WL_CONNECTED) {
    Serial.print("."); // Keep the serial monitor lit!
    delay(500);
  }
 
  // Connection Succeed
  Serial.println("");
  Serial.println("Connected to " + String(SSID));
 
  // Execute OTA Update
  execOTA();
}
 
void loop() {
  // chill
}
 
/*
 * Serial Monitor log for this sketch
 * 
 * If the OTA succeeded, it would load the preference sketch, with a small modification. i.e.
 * Print `OTA Update succeeded!! This is an example sketch : Preferences > StartCounter`
 * And then keeps on restarting every 10 seconds, updating the preferences
 * 
 * 
      rst:0x10 (RTCWDT_RTC_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT)
      configsip: 0, SPIWP:0x00
      clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00
      mode:DIO, clock div:1
      load:0x3fff0008,len:8
      load:0x3fff0010,len:160
      load:0x40078000,len:10632
      load:0x40080000,len:252
      entry 0x40080034
      Connecting to SSID
      ......
      Connected to SSID
      Connecting to: bucket-name.s3.ap-south-1.amazonaws.com
      Fetching Bin: /StartCounter.ino.bin
      Got application/octet-stream payload.
      Got 357280 bytes from server
      contentLength : 357280, isValidContentType : 1
      Begin OTA. This may take 2 - 5 mins to complete. Things might be quite for a while.. Patience!
      Written : 357280 successfully
      OTA done!
      Update successfully completed. Rebooting.
      ets Jun  8 2016 00:22:57
      
      rst:0x10 (RTCWDT_RTC_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT)
      configsip: 0, SPIWP:0x00
      clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00
      mode:DIO, clock div:1
      load:0x3fff0008,len:8
      load:0x3fff0010,len:160
      load:0x40078000,len:10632
      load:0x40080000,len:252
      entry 0x40080034
      
      OTA Update succeeded!! This is an example sketch : Preferences > StartCounter
      Current counter value: 1
      Restarting in 10 seconds...
      E (102534) wifi: esp_wifi_stop 802 wifi is not init
      ets Jun  8 2016 00:22:57
      
      rst:0x10 (RTCWDT_RTC_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT)
      configsip: 0, SPIWP:0x00
      clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00
      mode:DIO, clock div:1
      load:0x3fff0008,len:8
      load:0x3fff0010,len:160
      load:0x40078000,len:10632
      load:0x40080000,len:252
      entry 0x40080034
      
      OTA Update succeeded!! This is an example sketch : Preferences > StartCounter
      Current counter value: 2
      Restarting in 10 seconds...
 
      ....
 * 
 */

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

/**

AWS S3 OTA Update

Date: 14th June 2017

Author: Arvind Ravulavaru <https://github.com/arvindr21>

Purpose: Perform an OTA update from a bin located in Amazon S3 (HTTP Only)

Upload:

Step 1 : Download the sample bin file from the examples folder

Step 2 : Upload it to your Amazon S3 account, in a bucket of your choice

Step 3 : Once uploaded, inside S3, select the bin file >> More (button on top of the file list) >> Make Public

Step 4 : You S3 URL => http://bucket-name.s3.ap-south-1.amazonaws.com/sketch-name.ino.bin

Step 5 : Build the above URL and fire it either in your browser or curl it `curl -I -v http://bucket-name.ap-south-1.amazonaws.com/sketch-name.ino.bin` to validate the same

Step 6: Plug in your SSID, Password, S3 Host and Bin file below

Build & upload

Step 1 : Menu > Sketch > Export Compiled Library. The bin file will be saved in the sketch folder (Menu > Sketch > Show Sketch folder)

Step 2 : Upload bin to S3 and continue the above process

// Check the bottom of this sketch for sample serial monitor log, during and after successful OTA Update

#include <WiFi.h>

#include <Update.h>

WiFiClient client;

// Variables to validate

// response from S3

int contentLength = 0;

bool isValidContentType = false;

// Your SSID and PSWD that the chip needs

// to connect to

const char* SSID = "YOUR-SSID";

const char* PSWD = "YOUR-SSID-PSWD";

// S3 Bucket Config

String host = "bucket-name.s3.ap-south-1.amazonaws.com"; // Host => bucket-name.s3.region.amazonaws.com

int port = 80; // Non https. For HTTPS 443. As of today, HTTPS doesn't work.

String bin = "/sketch-name.ino.bin"; // bin file name with a slash in front.

// Utility to extract header value from headers

String getHeaderValue(String header, String headerName) {

return header.substring(strlen(headerName.c_str()));

}

// OTA Logic

void execOTA() {

Serial.println("Connecting to: " + String(host));

// Connect to S3

if (client.connect(host.c_str(), port)) {

// Connection Succeed.

// Fecthing the bin

Serial.println("Fetching Bin: " + String(bin));

// Get the contents of the bin file

client.print(String("GET ") + bin + " HTTP/1.1\r\n" +

"Host: " + host + "\r\n" +

"Cache-Control: no-cache\r\n" +

"Connection: close\r\n\r\n");

// Check what is being sent

// Serial.print(String("GET ") + bin + " HTTP/1.1\r\n" +

// "Host: " + host + "\r\n" +

// "Cache-Control: no-cache\r\n" +

// "Connection: close\r\n\r\n");

unsigned long timeout = millis();

while (client.available() == 0) {

if (millis() - timeout > 5000) {

Serial.println("Client Timeout !");

client.stop();

return;

}

// Once the response is available,

// check stuff

Response Structure

HTTP/1.1 200 OK

x-amz-id-2: NVKxnU1aIQMmpGKhSwpCBh8y2JPbak18QLIfE+OiUDOos+7UftZKjtCFqrwsGOZRN5Zee0jpTd0=

x-amz-request-id: 2D56B47560B764EC

Date: Wed, 14 Jun 2017 03:33:59 GMT

Last-Modified: Fri, 02 Jun 2017 14:50:11 GMT

ETag: "d2afebbaaebc38cd669ce36727152af9"

Accept-Ranges: bytes

Content-Type: application/octet-stream

Content-Length: 357280

Server: AmazonS3

while (client.available()) {

// read line till /n

String line = client.readStringUntil('\n');

// remove space, to check if the line is end of headers

line.trim();

// if the the line is empty,

// this is end of headers

// break the while and feed the

// remaining `client` to the

// Update.writeStream();

if (!line.length()) {

//headers ended

break; // and get the OTA started

}

// Check if the HTTP Response is 200

// else break and Exit Update

if (line.startsWith("HTTP/1.1")) {

if (line.indexOf("200") < 0) {

Serial.println("Got a non 200 status code from server. Exiting OTA Update.");

break;

}

// extract headers here

// Start with content length

if (line.startsWith("Content-Length: ")) {

contentLength = atoi((getHeaderValue(line, "Content-Length: ")).c_str());

Serial.println("Got " + String(contentLength) + " bytes from server");

}

// Next, the content type

if (line.startsWith("Content-Type: ")) {

String contentType = getHeaderValue(line, "Content-Type: ");

Serial.println("Got " + contentType + " payload.");

if (contentType == "application/octet-stream") {

isValidContentType = true;

}

} else {

// Connect to S3 failed

// May be try?

// Probably a choppy network?

Serial.println("Connection to " + String(host) + " failed. Please check your setup");

// retry??

// execOTA();

}

// Check what is the contentLength and if content type is `application/octet-stream`

Serial.println("contentLength : " + String(contentLength) + ", isValidContentType : " + String(isValidContentType));

// check contentLength and content type

if (contentLength && isValidContentType) {

// Check if there is enough to OTA Update

bool canBegin = Update.begin(contentLength);

// If yes, begin

if (canBegin) {

Serial.println("Begin OTA. This may take 2 - 5 mins to complete. Things might be quite for a while.. Patience!");

// No activity would appear on the Serial monitor

// So be patient. This may take 2 - 5mins to complete

size_t written = Update.writeStream(client);

if (written == contentLength) {

Serial.println("Written : " + String(written) + " successfully");

} else {

Serial.println("Written only : " + String(written) + "/" + String(contentLength) + ". Retry?" );

// retry??

// execOTA();

}

if (Update.end()) {

Serial.println("OTA done!");

if (Update.isFinished()) {

Serial.println("Update successfully completed. Rebooting.");

ESP.restart();

} else {

Serial.println("Update not finished? Something went wrong!");

}

} else {

Serial.println("Error Occurred. Error #: " + String(Update.getError()));

}

} else {

// not enough space to begin OTA

// Understand the partitions and

// space availability

Serial.println("Not enough space to begin OTA");

client.flush();

}

} else {

Serial.println("There was no content in the response");

client.flush();

}

void setup() {

//Begin Serial

Serial.begin(115200);

delay(10);

Serial.println("Connecting to " + String(SSID));

// Connect to provided SSID and PSWD

WiFi.begin(SSID, PSWD);

// Wait for connection to establish

while (WiFi.status() != WL_CONNECTED) {

Serial.print("."); // Keep the serial monitor lit!

delay(500);

}

// Connection Succeed

Serial.println("");

Serial.println("Connected to " + String(SSID));

// Execute OTA Update

execOTA();

}

void loop() {

// chill

}

* Serial Monitor log for this sketch

* If the OTA succeeded, it would load the preference sketch, with a small modification. i.e.

* Print `OTA Update succeeded!! This is an example sketch : Preferences > StartCounter`

* And then keeps on restarting every 10 seconds, updating the preferences

rst:0x10 (RTCWDT_RTC_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT)

configsip: 0, SPIWP:0x00

clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00

mode:DIO, clock div:1

load:0x3fff0008,len:8

load:0x3fff0010,len:160

load:0x40078000,len:10632

load:0x40080000,len:252

entry 0x40080034

Connecting to SSID

......

Connected to SSID

Connecting to: bucket-name.s3.ap-south-1.amazonaws.com

Fetching Bin: /StartCounter.ino.bin

Got application/octet-stream payload.

Got 357280 bytes from server

contentLength : 357280, isValidContentType : 1

Begin OTA. This may take 2 - 5 mins to complete. Things might be quite for a while.. Patience!

Written : 357280 successfully

OTA done!

Update successfully completed. Rebooting.

ets Jun 8 2016 00:22:57

rst:0x10 (RTCWDT_RTC_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT)

configsip: 0, SPIWP:0x00

clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00

mode:DIO, clock div:1

load:0x3fff0008,len:8

load:0x3fff0010,len:160

load:0x40078000,len:10632

load:0x40080000,len:252

entry 0x40080034

OTA Update succeeded!! This is an example sketch : Preferences > StartCounter

Current counter value: 1

Restarting in 10 seconds...

E (102534) wifi: esp_wifi_stop 802 wifi is not init

ets Jun 8 2016 00:22:57

rst:0x10 (RTCWDT_RTC_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT)

configsip: 0, SPIWP:0x00

clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00

mode:DIO, clock div:1

load:0x3fff0008,len:8

load:0x3fff0010,len:160

load:0x40078000,len:10632

load:0x40080000,len:252

entry 0x40080034

OTA Update succeeded!! This is an example sketch : Preferences > StartCounter

Current counter value: 2

Restarting in 10 seconds...

....

refer：

参考链接

终于知道为什么esp的IO21和IO22引脚是SDA和SCL的默认接口。
恐惧：恐惧是给C++的，我这几天正好在网上看到别人说，C++语法可以特别特别恶心，常量特别特别难定位。我就在想有多难，有多恶心，CTRL+f很快就定位到了。然后这几天头头在捣鼓传感器，我就在旁边看着，学习学习。记下了当时他接的引脚号，回去自己捣鼓捣鼓，一般来说，接传感器都是要在程序里指定引脚的，我看了看样例代码里也没有指定就很纳闷（我也在头文件里面找，也没找到）。就问头头，为什么=这个不指定引脚啊？头头很随意的说“因为这个是使用I2C的接口，只需要指定传感器的编号（相当于人的手机号，每类传感器都有一个，也可以人为设定），esp32会自动扫描在总线上的设备，不用管接哪个引脚。”那我听了这话，就很感慨，原来现在传感器也这么智能了，就试了试其他的引脚，不行，我大概尝试了几十种组合方式，除了头头的那一种其他的都不行。这个时候也不好意思去问头头，感觉很简单的一个东西。于是就上网看看I2C协议，再看看一些实例，哦，原来随便接是说在同一个I2C接口上可以随便接很多个传感器，在这个I2C接口上会自动的扫描不同的传感器设备。好，那我们来看看esp32上的I2C接口是哪个引脚。如果不出所料应该是头头用的IO21，22

继续阅读esp32在Arduino 1.8下的I2C引脚

根据温度、气压计算海拔高度

有趣的是，这个简单的内容居然在国内的网站上很难搜索。不过无妨，毕竟是学过多年英语的人，链接在此。闲话不说，请看公式

1. hypsometric 公式

$ \Large h = \frac{[(\frac{P_0}{P})^{\frac{1}{5.257}}-1] \times (T + 273.15)}{0.0065} \tag{1}$

(1)

其中，$P_0$为标准大气压强，取值 $101.325 {\rm kPa}$; $P$为实际测量的大气压强，单位 ${\rm kPa}$; $T$为实际测量温度，单位 ℃。

上式中( T + 273.15 )是将摄氏度转化为华氏度。该公式同时考虑为温度和压强计算海拔高度，计算结果的单位是米。

2. barometric 公式

$\Large h = 44330 \times \left [ 1 - (\frac{P}{P_0})^{\frac{1}{5.255}} \right ] \tag{2}$

(2)

其实该公式只是只是(1)式在一定条件下取值，不考虑温度的影响，计算结果的单位是米。

继续阅读根据温度、气压计算海拔高度

MicroPython入坑记（四）关于MicroPython的代码保护

脚本开发东西，可能面临的第一个问题就是：拷给别人，代码怎么写的他不就都知道了？不行，我要保住我的小秘密！

先说下结果：没有攻不破的堡垒，即使你写成C语言，只要能拿到二进制结果，都可以反汇编逆向出你是怎么实现的，关键是值不值得

另外，这跟逆向者对系统的了解程度有关，比如对方连代码都不会上传，那你即使把源文件放进去也他也无可奈何。

好了，言归正传，我们知道普通python有个编译成字节码的功能，也就是源代码会在解释时先编译成一个类似java中间代码的结果，这是不可读的（但是这也不排除反编译的可能，毕竟JAVA的class文件是有反编译软件的）。

micropython也有这个功能，不过这个文件的扩展名是mpy，也不能在运行时自动生成，需要一款软件：mpy-cross.exe，这是micropython官方提供的，可以用python pip直接安装，安装完成后，可以运行mpy-cross.exe pythonfile,py，就可以生成一个pythonfile.mpy的字节码文件，这文件使用跟py文件是等效的。把所有文件生成mpy，可以在一定程度上保护你的代码。

更进一步的方式：把mpy文件藏到固件中去，这不光能保护代码，还能降低程序的内存占用，官方的描述如下：

Cross-installing packages with freezing

For the low-memory MicroPython ports, the process described in the previous section does not provide the most efficient resource usage,because the packages are installed in the source form, so need to be compiled to the bytecome on each import. This compilation requires RAM, and the resulting bytecode is also stored in RAM, reducing its amount available for storing application data. Moreover, the process above requires presence of the filesystem on a device, and the most resource-constrained devices may not even have it.

The bytecode freezing is a process which resolves all the issues mentioned above:

The source code is pre-compiled into bytecode and store as such.
The bytecode is stored in ROM, not RAM.
Filesystem is not required for frozen packages.

Using frozen bytecode requires building the executable (firmware) for a given MicroPython port from the C source code. Consequently, the process is:

Follow the instructions for a particular port on setting up a toolchain and building the port. For example, for ESP8266 port, study instructions in ports/esp8266/README.md and follow them. Make sure you can build the port and deploy the resulting executable/firmware successfully before proceeding to the next steps.
Build MicroPython Unix port and make sure it is in your PATH and you can execute micropython.
Change to port’s directory (e.g. ports/esp8266/ for ESP8266).
Run make clean-frozen. This step cleans up any previous modules which were installed for freezing (consequently, you need to skip this step to add additional modules, instead of starting from scratch).
Run micropython -m upip install -p modules <packages>... to install packages you want to freeze.
Run make clean.
Run make.

After this, you should have the executable/firmware with modules as the bytecode inside, which you can deploy the usual way.

大体的意思是这样的：运行py文件不能有效的使用内存资源，因为代码执行时需要被编译成bytecode代码，该编译需要RAM，生成的字节码也存在RAM中，这就降低了可用内存。并且存储py文件需要文件系统，而一些嵌入设备本身不存在文件系统。

嗯，神一样的保护功能，不但降低了内存占用，还把字节码藏到了固件中，代价就是需要自己编译micropython固件。

参考链接

MicroPython入坑记（四）关于MicroPython的代码保护

ESP32-WROOM-32E写入MicroPython固件

最近入手了 ESP32 WROOM 32E 模组，记录一下刷入 MicroPython 固件的过程。

继续阅读ESP32-WROOM-32E写入MicroPython固件

Whistle 是基于 Node 实现的跨平台抓包调试工具

Whistle 是基于 Node 实现的跨平台抓包调试工具，其主要特点：

完全跨平台：支持 Mac、Windows 等桌面系统，且支持服务端等命令行系统
功能强大（理论上可以对请求做任意修改）：
- 支持作为 HTTP、HTTPS、SOCKS 代理及反向代理
- 支持抓包及修改 HTTP、HTTPS、HTTP2、WebSocket、TCP 请求
- 支持重放及构造 HTTP、HTTPS、HTTP2、WebSocket、TCP 请求
- 支持设置上游代理、PAC 脚本、Hosts、延迟（限速）请求响应等
- 支持查看远程页面的 console 日志及 DOM 节点
- 支持用 Node 开发插件扩展功能，也可以作为独立 npm 包引用
操作简单：
- 直接通过浏览器查看抓包、修改请求
- 所有修改操作都可以通过配置方式实现（类似系统 Hosts），并支持分组管理
- 项目可以自带代理规则配置并一键设置到本地 Whistle 代理，也可以通过定制插件简化操作

继续阅读Whistle 是基于 Node 实现的跨平台抓包调试工具

苹果ARM SOC M1显微图像

由于PPT需要，特意搜集了一下苹果ARM SOC M1显微图像

继续阅读苹果ARM SOC M1显微图像

nvidia-smi GPU性能状态(Performance State)含义

我正在使用Nvidia GTX Titan X进行深度学习实验。
我正在使用nvidia-smi来监视GPU的运行状态，但是提供的工具的性能(性能)状态没有意义。

我已经查看了nvidia-smi手册，它表示以下内容：

Performance State
The current performance state for the GPU. States range from P0 (maximum performance) to P12 (minimum performance).

如果不在GPU上运行任何进程(空闲状态)，则GPU性能状态为p0。
但是，当运行一些计算繁重的过程时，状态变为p2。

我的问题是，为什么我的GPU闲置时处于P0状态，但是在执行繁重的计算任务时切换到P2？不应该相反吗？

另外，有没有办法使我的GPU始终在P0状态下运行(最高性能)？

令人困惑。

但是，nvidia-smi手册是正确的。

当一个或一组GPU处于空闲状态时，在计算机上运行nvidia-smi的过程通常会使其中一个GPU退出空闲状态。这是由于该工具正在收集的信息-需要唤醒其中一个GPU。

此唤醒过程最初会将GPU置于P0状态(最高性能状态)，但如果GPU空闲或不是特别忙碌，GPU驱动程序将监控该GPU，并最终开始降低性能状态以节省功耗。

另一方面，当GPU在工作负载下处于活动状态时，GPU驱动程序将根据其自身的启发式方法不断调整性能状态以提供最佳性能，同时使性能状态与实际工作负载相匹配。如果没有达到热或功率限制，则对于最活跃和最重的连续工作负载，性能状态应达到最高水平(P0)。

周期性很重但不连续的工作负载可能会导致GPU功耗状态在P0-P2级别附近波动。由于热(温度)或电源问题而"受限制"的GPU也可能会看到P状态降低。这种限制是显而易见的，并在nvidia-smi中单独报告，但是可能并非所有GPU类型都启用这种报告。

如果要在GPU上查看P0状态，我可以提供的最佳建议是运行短暂，繁重且连续的工作负载(例如，执行大型sgemm操作的工作)，然后在该工作负载期间监视GPU。在这种情况下应该可以看到P0状态。

如果您使用的是正在使用cuDNN库的机器学习应用程序(例如Caffe)，并且正在训练大型网络，则应该可以不时看到P0，因为cuDNN会执行类似于sgemm的操作通常情况下。

但是对于零星的工作负载，最常见的状态很有可能是P2。

要始终"强制" P0电源状态，可以尝试通过nvidia-smi工具尝试持久性模式和应用程序时钟。使用nvidia-smi --help或nvidia-smi的手册页了解选项。

尽管我认为这通常不适用于Tesla GPU，但除非特别设置更高的应用时钟，否则某些NVIDIA GPU可能会在计算负载下将自身限制为P2功耗状态。使用nvidia-smi -a命令查看可用于GPU的当前应用程序时钟，默认应用程序时钟和最大时钟。 (某些GPU(包括较旧的GPU)可能会在其中某些字段中显示N / A。这通常表明应用程序时钟无法通过nvidia-smi进行修改。)如果在计算负载期间卡似乎以P2状态运行，则可能通过将应用程序时钟增加到最大可用时钟(即最大时钟)，可以将其增加到P0状态。使用nvidia-smi --help了解如何格式化命令以更改GPU上的应用程序时钟。修改应用程序时钟或启用可修改的应用程序时钟可能需要root / admin特权。设置GPU持久模式也可能是理想的或必要的。这将防止驱动程序在GPU活动期间"卸载"，这可能导致驱动程序重新加载时重置应用程序时钟。

对于这种情况下受影响的卡，此默认行为是在计算负载下限制为P2，这是由GPU驱动程序设计的。

参考链接

[华硕主板] 支持ECC内存的AMD Ryzen™处理器列表

下表列出了支持带ECC功能内存模组的Ryzen™处理器的列表；它们的官方名称；以及是否支持B550和X570系列。

请注意，当涉及到APUs（Ryzen 3000/4000 G系列），只有PRO处理器（例如Ryzen 3 PRO 3200G）支持ECC内存。

官方名称	支持B550系列	支持X570系列	ECC功能	UDIMM ECC	REG ECC
AMD Ryzen™ 5000 Series Processors	V	V	支持	V
AMD Ryzen™ 4000 G-Series Processors	V	V	只有PRO支持	V
AMD Ryzen™ 3000 Series Processors	V	V	支持	V
AMD Ryzen™ 2000 Series Processors		V	支持	V
AMD Ryzen™ 3000 G-Series Processors		V	只有PRO支持	V

注意，Ryzen™处理器只支持二手UDIMM ECC，不支持更便宜的二手REG ECC。

这个问题简单解释一下，新的REG ECC从性能到价格都是远远高于UDIMM ECC的，但是REG ECC不能用在家用主板上，导致大量淘汰的二手内存需求量不高，因而价格偏便宜。

继续阅读[华硕主板] 支持ECC内存的AMD Ryzen™处理器列表

2024 年 12 月
一	二	三	四	五	六	日
						1
2	3	4	5	6	7	8
9	10	11	12	13	14	15
16	17	18	19	20	21	22
23	24	25	26	27	28	29
30	31