回头再解释，先 mark 2020年4月28日。

2020年5月1日 今日有空，稍微更新一下，主要在这里备份一下相关的 code 和详细的问题分析和具体解释。

继着上次的 https://www.cnblogs.com/juwan/p/12389600.html 的内容，上次只定位了问题和简单解决了问题，调整了 Python 的 Code ，现在主要是旧 Code 不稳定，下载的文件容易出问题，容易因为二进制文件产生错误。

那么如何解决呢？

我回顾一下我的这 4 天的开发历程，第一天，基于旧接收框架重新整理 Code ，第二天准备到位开始测试，测试崩盘没有任何改造，镇定思痛，第三天重新上状态机架构，第四天大量测试，缝缝补补后符合预期执行，趋于完美。

先上逻辑分析仪捕获数据观察数据流，注意我压缩了很多写的过程，只交待重点，有理有据的代码让人信服，如果有漏洞也是细节的马虎，思路对了大体是不会有太大问题的。

在 HTTP 下载文件的时候，可以看到它接收数据是以 \r\n+IPD 开头的数据，如 '+IPD,3,1452:' or '+IPD,1452:' 两类，经过测试，确实是符合预期的返回指定长度的数据，但会在最后的结束的时候附带 CLOSED\r\n 数据表示传输结束。

这里我们注意到两个问题，以及旧代码为什么不能抵抗高速传输的异常数据所产生的错误，这在上次的分析就已经提到这个数据流的问题，我们先理清问题。

我们知道了传输的规则和传输的形式，例如 AT 指令 和 传输的数据 是混在同一条通道中的，这意味着二进制数据中一旦出现类似 AT 指令的数据必然导致后续的数据错乱，又或者是传输的缓冲区异常导致程序跑飞等等。

这些错误都在旧代码中体现了，这里不再细讲，直接开始编写新代码适用新的接口。

我们知道这个函数是可重入的，所以一开始在剥离基础框架的时候就要最大化的保留重入的接口，例如，接收数据完成后，将数据保留到一个缓冲区中，在下一次的重入的时候，取走足够数量的数据，如果不够，则继续接收数据，如下代码的设计。

// required data already in buf, just return data

size = Buffer_Size(&nic->buffer);

if (size >= out_buff_len) { // 请求的代码长度小于缓冲区的长度，直接返回数据

Buffer_Gets(&nic->buffer, (uint8_t *)out_buff, out_buff_len);

if (data_len) {

*data_len = out_buff_len;

}

size = size > out_buff_len ? out_buff_len : size;

frame_sum -= size; // 总体的缓冲区数据要对应减少，同时判断是否没有更多的数据了，如果为负数则报错。

// printk("Buffer_Size frame_sum %d size %d *data_len %d\n", frame_sum, size, *data_len);

if (frame_sum <= 0) {

Buffer_Clear(&nic->buffer);

if (*peer_closed) { //buffer empty, return EOF

return -2;

}

}

return out_buff_len;

}

围绕这个思路去，这个函数就形成一种非常适合 FSM 状态机的接口，同时必须要有 buffer 去保留上一次的状态与数据。

为此可以将其构建一种基础状态机模型，二话不说先上架构，保持 IDLE, IPD, DATA, EXIT 四种状态，本来有 CLOSED 状态的，后来想了一下还不到时候就移除了。

enum fsm_state { IDLE, IPD, DATA, EXIT } State = IDLE;

static uint8_t tmp_buf[1560 * 2] = {0}; // tmp_buf as queue 1560

uint32_t tmp_bak = 0, tmp_state = 0, tmp_len = 0, tmp_pos = 0;

mp_uint_t interrupt = 0, uart_recv_len = 0, res = 0;

while (State != EXIT) {

// wait any uart data

uart_recv_len = uart_rx_any(nic->uart_obj);

if (uart_recv_len > 0) {

if (tmp_len >= sizeof(tmp_buf)) { // lock across

// printk("lock across frame_len %d tmp_len %d\n", frame_len, tmp_len);

tmp_len = 0;

}

res = uart_stream->read(nic->uart_obj, tmp_buf + tmp_len, 1, &err);

// printk("%s | tmp_buf %s res %d err %d\n", __func__, tmp_buf, res, err);

if (res == 1 && err == 0) {

interrupt = mp_hal_ticks_ms();

// backup tmp_len to tmp_pos (tmp_pos - 1)

tmp_pos = tmp_len, tmp_len += 1; // buffer push

// printk("[%02X]", tmp_buf[tmp_pos]);

if (State == IDLE) {

continue;

}

if (State == IPD) {

continue;

}

if (State == DATA) {

// printk("%s | frame_len %d tmp_len %d tmp_buf[tmp_pos] %02X\n", __func__, frame_len, tmp_len, tmp_buf[tmp_pos]);

continue;

}

} else {

State = EXIT;

}

}

if (mp_hal_ticks_ms() - interrupt > timeout) {

break; // uart no return data to timeout break

}

if (*peer_closed) {

break; // disconnection

}

}

我们看到这个 FSM 的基础保证是，确保访问边界被控制住，防止程序指针异常访问导致跑飞(在我前一篇有所提及)。

if (tmp_len >= sizeof(tmp_buf)) { // lock across

// printk("lock across frame_len %d tmp_len %d\n", frame_len, tmp_len);

tmp_len = 0;

}

其次是超时机制，确保任何情况下都可以离开状态机。

if (mp_hal_ticks_ms() - interrupt > timeout) {

break; // uart no return data to timeout break

}

这样可以保障程序在任何场合下都不会陷入底层无法离开。

接下来就是当缓冲区有数据、数据接收正常、以及每次读取一字节成功的基础上，进行字符串的匹配和状态转移的分类处理。

// wait any uart data

uart_recv_len = uart_rx_any(nic->uart_obj);

if (uart_recv_len > 0) {

if (tmp_len >= sizeof(tmp_buf)) { // lock across

// printk("lock across frame_len %d tmp_len %d\n", frame_len, tmp_len);

tmp_len = 0;

}

res = uart_stream->read(nic->uart_obj, tmp_buf + tmp_len, 1, &err);

// printk("%s | tmp_buf %s res %d err %d\n", __func__, tmp_buf, res, err);

if (res == 1 && err == 0) {

interrupt = mp_hal_ticks_ms();

// backup tmp_len to tmp_pos (tmp_pos - 1)

tmp_pos = tmp_len, tmp_len += 1; // buffer push

// printk("[%02X]", tmp_buf[tmp_pos]);

if (State == IDLE) {

continue;

}

if (State == IPD) {

continue;

}

if (State == DATA) {

// printk("%s | frame_len %d tmp_len %d tmp_buf[tmp_pos] %02X\n", __func__, frame_len, tmp_len, tmp_buf[tmp_pos]);

continue;

}

} else {

State = EXIT;

}

}

这时候最后一个状态是用来离开的标记。

我们开始脑里模拟执行过程和假设，第一种状态就是空转(IDLE)，基本上每个状态机都是从这里开始的。

在 IDLE 期间要做的事情就是清理无关的数据，如下代码，直到符合预期的怀疑对象出现为止。

if (State == IDLE) {

if (tmp_buf[tmp_pos] == '+') {

tmp_state = 1, tmp_bak = tmp_pos, State = IPD;

continue;

} else {

// printk("(%02X)", tmp_buf[tmp_pos]);

tmp_len -= 1; // clear don't need data, such as (0D)(0A)

continue;

}

}

如上代码，在空转状态下，遇到 '+' 出现后，会进行假设性的状态转移，如果不符合预期的数据会跌回 ILDE 状态，然后我们看看 IPD 状态的实现。

if (tmp_pos - tmp_bak > 12) { // Over the length of the '+IPD,3,1452:' or '+IPD,1452:'

tmp_state = 0, State = IDLE;

continue;

}

if (0 < tmp_state && tmp_state < 5) {

// printk("(%d, %02X) [%d, %02X]\n", tmp_pos, tmp_buf[tmp_pos], tmp_pos - tmp_bak, ("+IPD,")[tmp_pos - tmp_bak]);

if (tmp_buf[tmp_pos] == ("+IPD,")[tmp_pos - tmp_bak]) {

tmp_state += 1; // tmp_state 1 + "IPD," to tmp_state 5

} else {

tmp_state = 0, State = IDLE;

}

continue;

}

if (tmp_state == 5 && tmp_buf[tmp_pos] == ':')

{

tmp_state = 6, State = IDLE;

tmp_buf[tmp_pos + 1] = '\0'; // lock tmp_buf

// printk("%s | is `IPD` tmp_bak %d tmp_len %d command %s\n", __func__, tmp_bak, tmp_len, tmp_buf + tmp_bak);

char *index = strstr((char *)tmp_buf + tmp_bak + 5 /* 5 > '+IPD,' and `+IPD,325:` in tmp_buf */, ",");

int ret = 0, len = 0;

if (index) { // '+IPD,3,1452:'

ret = sscanf((char *)tmp_buf + tmp_bak, "+IPD,%hhd,%d:", &mux_id, &len);

if (ret != 2 || mux_id < 0 || mux_id > 4 || len <= 0) {

; // Misjudge or fail, return, or clean up later

} else {

tmp_len = tmp_bak, tmp_bak = 0; // Clean up the commands in the buffer and roll back the data

frame_len = len, State = DATA;

}

} else { // '+IPD,1452:'

ret = sscanf((char *)tmp_buf + tmp_bak, "+IPD,%d:", &len);

if (ret != 1 || len <= 0) {

; // Misjudge or fail, return, or clean up later

} else {

tmp_len = tmp_bak, tmp_bak = 0; // Clean up the commands in the buffer and roll back the data

frame_len = len, State = DATA;

}

}

continue;

}

由于这是第三次重构的代码，所以里面加了很多保护措施，但实际上这些措施不一定会遇到，它会随着各种高频传输调试中触发，代码要能够抵抗这些异常数据。

我们看到 if (tmp_buf[tmp_pos] == ("+IPD,")[tmp_pos - tmp_bak]) { 的循环表示的就是 strstr 的匹配，但这里的匹配我稍微偷懒了一下简写了代码。

if (0 < tmp_state && tmp_state < 5) {

// printk("(%d, %02X) [%d, %02X]\n", tmp_pos, tmp_buf[tmp_pos], tmp_pos - tmp_bak, ("+IPD,")[tmp_pos - tmp_bak]);

if (tmp_buf[tmp_pos] == ("+IPD,")[tmp_pos - tmp_bak]) {

tmp_state += 1; // tmp_state 1 + "IPD," to tmp_state 5

} else {

tmp_state = 0, State = IDLE;

}

continue;

}

因为整个环境没有基础容器的支持，例如队列，所以我只能通过代码中的索引去模拟队列执行，保障整个执行的有序状态，当匹配完成后，会从 IPD 进入 DATA 态，此时意味着之后的数据都被视为数据，长度以 IPD 指示的为准。

tmp_len = tmp_bak, tmp_bak = 0; // Clean up the commands in the buffer and roll back the data

frame_len = len, State = DATA;

进入 DATA 态的时候就要思考终止条件的状态了，有两种可能，一种是标识的长度数据走完了，这表示应该要转移状态到 ILDE 了，但期望从这个状态中发现终止条件。

if (frame_len < 0) {

if (frame_len == -1 && tmp_buf[tmp_pos] == 'C') { // wait "CLOSED\r\n"

frame_bak = frame_len;

continue;

}

if (tmp_state == 6 && tmp_buf[tmp_pos] == '\r') {

tmp_state = 7;

continue;

}

if (tmp_state == 7 && tmp_buf[tmp_pos] == '\n') {

if (frame_len == -2) { // match +IPD EOF (\r\n)

tmp_state = 0, State = IDLE;

// After receive complete, confirm the data is enough

size = Buffer_Size(&nic->buffer);

// printk("%s | size %d out_buff_len %d\n", __func__, size, out_buff_len);

if (size >= out_buff_len) { // data enough

// printk("%s | recv out_buff_len overflow\n", __func__);

State = EXIT;

}

} else if (frame_len == -8 && frame_len == -1) {

// Get "CLOSED\r\n"

peer_just_closed = *peer_closed = true;

frame_bak = 0, tmp_state = 0, State = EXIT;

} else {

tmp_state = 6;

}

continue;

}

// 存在异常，没有得到 \r\n 的匹配，并排除 CLOSED\r\n 的指令触发的可能性，意味着传输可能越界出错了 \r\n ，则立即回到空闲状态。

if (frame_len <= -1 && frame_bak != -1) {

// printk("%s | tmp_state %d frame_len %d tmp %02X\n", __func__, tmp_state, frame_len, tmp_buf[tmp_pos]);

State = IDLE;

continue;

}

}

如我所假设的两种状态 \r\n 和 CLOSED\r\n 这两类，但还有最终保障措施，假设无法符合我的预期的结尾，要尽快回归 ILDE 重新进入匹配，否则数据将一片混乱，这个只能保障 1 、 2 字节的误差，对于缓冲区溢出复写的情况无法抵抗。

到这里我们还要注意到很多地方可能会出错和溢出，比如有如下考虑：

上层 Python 接收数据的变量溢出，无法继续 read 更多，积压数据未处理。

原始串口缓冲区溢出后，循环缓冲复写。

内部状态机解析的数据缓冲长度(已经被保护了，但出错了会导致其中的一帧丢失)

状态机解析后的数据缓冲变量写入可能会失败，夹在 C 与 Python 之间交互的一层缓冲区，主要用来供应 socket 层的数据。

因此这里面的任何一个环境出错，都可能导致 HTTP 的原始下载数据出错，但所辛都可以完整下好不会出现指令与二进制数据混淆的情况了。

基于这个接收框架，还可以进一步的拓展出 多 socket 的通信 和 其他 AT 指令的通信接口，匹配状态和解析后分类到各自对应的容器即可。

旧接口函数抵抗异常的设计不够多，所以之后测试完整了后，可以基于新的接口继续发展新功能。

我的测试结果如下：

在串口波特率 921600(1M)约 92 kb/s 的下载速度下载 384kb kmodel 模型文件的过程。

若是不写入 SD 卡的基础上，完美接收完毕，耗时 8s 。

若是写入我的 256M 的路边野卡，完整下载时 10s，无任何损坏，但受到网络波动则会出现下载的文件中会存在失败的帧，下载过程的好坏参半。

在串口波特率 576000(5M)约 57 kb/s 的下载速度下载 5M kmodel 模型文件的过程。

写入SD卡的过程，下载 5M 文件无错且完整，较为稳定，少有失败的情况。

从这个测试的结果来看，将 SD 卡写入数据是一个影响很大的变数，要么将其读写分离加缓冲在其中，减少 SD 卡带来的负面影响，优先把 HTTP 的数据带回内存之中。

这和串口缓冲区有关，如现在假定的 10k 字节，而 921600 (92kb/s)，意味着 read 数据要在 10k/x:100kb/s， x = 0.1s 内取走全部数据，否则 IO 不匹配，缓冲区会溢出，之后的数据都会被放弃从而形成接收数据的断层。

python 的 code 执行模型如下

while True:

tmp = wifi.read()

file.write(tmp)

所以再下一次的 wifi.read() 因符合下述读写分离模型，这只是伪代码。不用太计较。

# thread 0

while True:

tmp = wifi.read()

sleep(0.1)

# thread 1

while True:

file.write(tmp)

sleep(x)

这次我们必须在硬件的内存和 SD 卡的写入数据中做一个选择，至少保证 SD 写入速度应大于 100kb/s 从而保持 IO 的速率基本一致，减少下载文件的异常。

其他可能存在的问题，就比如有时候发送数据会请求失败，还不知道是哪个死角没考虑到，也许之后就会有人发现了吧？

之后的内容都是代码的备份，分为 新接口函数，旧接口函数，对应的 Python 测试代码，有兴趣的可以自己调试试试。

/*----------------------------------------------------------------------------*/

/* +IPD,,: */

/* +IPD,: */

/**

*

* @return -1: parameters error, -2: EOF, -3: timeout, -4:peer closed and no data in buffer

*/

uint32_t recvPkg(esp8285_obj *nic, char *out_buff, uint32_t out_buff_len, uint32_t *data_len, uint32_t timeout, char *coming_mux_id, bool *peer_closed, bool first_time_recv)

{

// printk("%s | head obl %d *dl %d tu %d ftr %d \n", __func__, out_buff_len, *data_len, timeout, first_time_recv);

int err = 0, size = 0;

bool peer_just_closed = false;

// only for single socket but need socket map & buffer TODO:

const mp_stream_p_t *uart_stream = mp_get_stream(nic->uart_obj);

static int8_t mux_id = -1;

static int32_t frame_sum = 0, frame_len = 0, frame_bak = 0;

// parameters check

if (out_buff == NULL) {

return -1;

}

if (first_time_recv) {

frame_sum = frame_len = 0;

}

// required data already in buf, just return data

size = Buffer_Size(&nic->buffer);

if (size >= out_buff_len) {

Buffer_Gets(&nic->buffer, (uint8_t *)out_buff, out_buff_len);

if (data_len) {

*data_len = out_buff_len;

}

size = size > out_buff_len ? out_buff_len : size;

frame_sum -= size;

// printk("Buffer_Size frame_sum %d size %d *data_len %d\n", frame_sum, size, *data_len);

if (frame_sum <= 0) {

Buffer_Clear(&nic->buffer);

if (*peer_closed) { //buffer empty, return EOF

return -2;

}

}

return out_buff_len;

}

enum fsm_state { IDLE, IPD, DATA, EXIT } State = IDLE;

static uint8_t tmp_buf[1560 * 2] = {0}; // tmp_buf as queue 1560

uint32_t tmp_bak = 0, tmp_state = 0, tmp_len = 0, tmp_pos = 0;

mp_uint_t interrupt = 0, uart_recv_len = 0, res = 0;

while (State != EXIT) {

// wait any uart data

uart_recv_len = uart_rx_any(nic->uart_obj);

if (uart_recv_len > 0) {

if (tmp_len >= sizeof(tmp_buf)) { // lock across

// printk("lock across frame_len %d tmp_len %d\n", frame_len, tmp_len);

tmp_len = 0;

}

res = uart_stream->read(nic->uart_obj, tmp_buf + tmp_len, 1, &err);

// printk("%s | tmp_buf %s res %d err %d\n", __func__, tmp_buf, res, err);

if (res == 1 && err == 0) {

interrupt = mp_hal_ticks_ms();

// backup tmp_len to tmp_pos (tmp_pos - 1)

tmp_pos = tmp_len, tmp_len += 1; // buffer push

// printk("[%02X]", tmp_buf[tmp_pos]);

if (State == IDLE) {

if (tmp_buf[tmp_pos] == '+') {

tmp_state = 1, tmp_bak = tmp_pos, State = IPD;

continue;

} else {

// printk("(%02X)", tmp_buf[tmp_pos]);

tmp_len -= 1; // clear don't need data, such as (0D)(0A)

continue;

}

}

if (State == IPD) {

if (tmp_pos - tmp_bak > 12) { // Over the length of the '+IPD,3,1452:' or '+IPD,1452:'

tmp_state = 0, State = IDLE;

continue;

}

if (0 < tmp_state && tmp_state < 5) {

// printk("(%d, %02X) [%d, %02X]\n", tmp_pos, tmp_buf[tmp_pos], tmp_pos - tmp_bak, ("+IPD,")[tmp_pos - tmp_bak]);

if (tmp_buf[tmp_pos] == ("+IPD,")[tmp_pos - tmp_bak]) {

tmp_state += 1; // tmp_state 1 + "IPD," to tmp_state 5

} else {

tmp_state = 0, State = IDLE;

}

continue;

}

if (tmp_state == 5 && tmp_buf[tmp_pos] == ':')

{

tmp_state = 6, State = IDLE;

tmp_buf[tmp_pos + 1] = '\0'; // lock tmp_buf

// printk("%s | is `IPD` tmp_bak %d tmp_len %d command %s\n", __func__, tmp_bak, tmp_len, tmp_buf + tmp_bak);

char *index = strstr((char *)tmp_buf + tmp_bak + 5 /* 5 > '+IPD,' and `+IPD,325:` in tmp_buf */, ",");

int ret = 0, len = 0;

if (index) { // '+IPD,3,1452:'

ret = sscanf((char *)tmp_buf + tmp_bak, "+IPD,%hhd,%d:", &mux_id, &len);

if (ret != 2 || mux_id < 0 || mux_id > 4 || len <= 0) {

; // Misjudge or fail, return, or clean up later

} else {

tmp_len = tmp_bak, tmp_bak = 0; // Clean up the commands in the buffer and roll back the data

frame_len = len, State = DATA;

}

} else { // '+IPD,1452:'

ret = sscanf((char *)tmp_buf + tmp_bak, "+IPD,%d:", &len);

if (ret != 1 || len <= 0) {

; // Misjudge or fail, return, or clean up later

} else {

tmp_len = tmp_bak, tmp_bak = 0; // Clean up the commands in the buffer and roll back the data

frame_len = len, State = DATA;

}

}

continue;

}

}

if (State == DATA) {

// printk("%s | frame_len %d tmp_len %d tmp_buf[tmp_pos] %02X\n", __func__, frame_len, tmp_len, tmp_buf[tmp_pos]);

frame_len -= tmp_len, tmp_len = 0; // get data

if (frame_len < 0) {

if (frame_len == -1 && tmp_buf[tmp_pos] == 'C') { // wait "CLOSED\r\n"

frame_bak = frame_len;

continue;

}

if (tmp_state == 6 && tmp_buf[tmp_pos] == '\r') {

tmp_state = 7;

continue;

}

if (tmp_state == 7 && tmp_buf[tmp_pos] == '\n') {

if (frame_len == -2) { // match +IPD EOF (\r\n)

tmp_state = 0, State = IDLE;

// After receive complete, confirm the data is enough

size = Buffer_Size(&nic->buffer);

// printk("%s | size %d out_buff_len %d\n", __func__, size, out_buff_len);

if (size >= out_buff_len) { // data enough

// printk("%s | recv out_buff_len overflow\n", __func__);

State = EXIT;

}

} else if (frame_len == -8 && frame_len == -1) {

// Get "CLOSED\r\n"

peer_just_closed = *peer_closed = true;

frame_bak = 0, tmp_state = 0, State = EXIT;

} else {

tmp_state = 6;

}

continue;

}

// 存在异常，没有得到 \r\n 的匹配，并排除 CLOSED\r\n 的指令触发的可能性，意味着传输可能越界出错了 \r\n ，则立即回到空闲状态。

if (frame_len <= -1 && frame_bak != -1) {

// printk("%s | tmp_state %d frame_len %d tmp %02X\n", __func__, tmp_state, frame_len, tmp_buf[tmp_pos]);

State = IDLE;

continue;

}

} else {

// for(int i = 0; i < tmp_len; i++) {

// int tmp = tmp_buf[i];

// printk("[%02X]", tmp);

// }

// printk("%s | frame_len %d tmp_len %d\n", __func__, frame_len, tmp_pos + 1);

// printk("%.*s", tmp_len, tmp_buf);

if (!Buffer_Puts(&nic->buffer, tmp_buf, (tmp_pos + 1))) {

printk("%s | network->buffer overflow Buffer Max %d Size %d\n", __func__, ESP8285_BUF_SIZE, Buffer_Size(&nic->buffer));

State = EXIT;

} else {

// reduce data len

// printk("[%02X]", tmp_buf[(tmp_pos + 1)]);

frame_sum += (tmp_pos + 1);

}

// printk("frame_sum %d frame_len %d tmp_len %d\n", frame_sum, frame_len, tmp_pos + 1);

}

continue;

}

} else {

State = EXIT;

}

}

if (mp_hal_ticks_ms() - interrupt > timeout) {

break; // uart no return data to timeout break

}

if (*peer_closed) {

break; // disconnection

}

}

size = Buffer_Size(&nic->buffer);

// peer closed and no data in buffer

if (size == 0 && !peer_just_closed && *peer_closed) {

frame_sum = 0;

return -4;

}

size = size > out_buff_len ? out_buff_len : size;

Buffer_Gets(&nic->buffer, (uint8_t *)out_buff, size);

if (data_len) {

*data_len = size;

}

frame_sum -= size;

if (frame_sum <= 0 || peer_just_closed) {

Buffer_Clear(&nic->buffer);

if (peer_just_closed)

{

frame_sum = 0;

return -2;

}

}

// printk(" %s | tail obl %d *dl %d se %d\n", __func__, out_buff_len, *data_len, size);

return size;

}

肝了三天了，彻底优化了 AT 8285 的通信过程，等测试得差不多了再提交，目前只测到了波特率 576000 下 HTTP 下载 K-Flash.zip (5M)二进制文件，数据完整，接收过程大体是没有太大问题了。

备份旧 CODE 。

uint32_t bak_recvPkg(esp8285_obj *nic, char *out_buff, uint32_t out_buff_len, uint32_t *data_len, uint32_t timeout, char *coming_mux_id, bool *peer_closed, bool first_time_recv)

{

const mp_stream_p_t *uart_stream = mp_get_stream(nic->uart_obj);

static uint8_t temp_buff1[2048] = {0};

static uint8_t temp_buff2[2048] = {0};

uint16_t temp_buff1_len = 0;

uint16_t temp_buff2_len = 0;

uint8_t find_frame_flag_index = 0;

static int8_t mux_id = -1;

static int16_t frame_len = 0;

static int32_t frame_len_sum = 0; //only for single socket TODO:

// bool overflow = false;

int ret = 0;

int size = 0;

int errcode;

mp_uint_t start1 = 0, start2 = 0;

bool no_frame_flag = false;

bool new_frame = false;

mp_uint_t data_len_in_uart_buff = 0;

bool peer_just_closed = false;

// parameters check

if (out_buff == NULL)

{

return -1;

}

// // printk("\r if (out_buff == NULL) { \n");

// init vars

memset(temp_buff1, 0, sizeof(temp_buff1));

memset(temp_buff2, 0, sizeof(temp_buff2));

if (first_time_recv)

{

frame_len = 0;

frame_len_sum = 0;

}

// required data already in buf, just return data

uint32_t buff_size = Buffer_Size(&nic->buffer);

// // printk("\r if(buff_size >= out_buff_len) \n");

// printk("\r buff_size %d out_buff_len %d\n", buff_size, out_buff_len);

if (buff_size >= out_buff_len)

{

Buffer_Gets(&nic->buffer, (uint8_t *)out_buff, out_buff_len);

if (data_len)

*data_len = out_buff_len;

frame_len_sum -= size;

if (frame_len_sum <= 0)

{

frame_len = 0;

frame_len_sum = 0;

Buffer_Clear(&nic->buffer);

if (*peer_closed) //buffer empty, return EOF

{

return -2;

}

}

return out_buff_len;

}

// read from uart buffer, if not frame start flag, put into nic buffer

// and need wait for full frame flag in 200ms(can be fewer), frame format: '+IPD,id,len:data' or '+IPD,len:data'

// wait data from uart buffer if not timeout

start2 = mp_hal_ticks_ms();

data_len_in_uart_buff = uart_rx_any(nic->uart_obj);

// // printk("\r uart_stream->read %p \n", uart_stream->read);

do

{

if (data_len_in_uart_buff > 0)

{

uart_stream->read(nic->uart_obj, temp_buff1 + temp_buff1_len, 1, &errcode);

if (find_frame_flag_index == 0 && temp_buff1[temp_buff1_len] == '+')

{

++find_frame_flag_index;

start1 = mp_hal_ticks_ms();

}

else if (find_frame_flag_index == 1 && temp_buff1[temp_buff1_len] == 'I')

{

++find_frame_flag_index;

}

else if (find_frame_flag_index == 2 && temp_buff1[temp_buff1_len] == 'P')

{

++find_frame_flag_index;

}

else if (find_frame_flag_index == 3 && temp_buff1[temp_buff1_len] == 'D')

{

++find_frame_flag_index;

}

else if (find_frame_flag_index == 4 && temp_buff1[temp_buff1_len] == ',')

{

++find_frame_flag_index;

}

else if (find_frame_flag_index == 5)

{

if (temp_buff1[temp_buff1_len] == ':')

{ // '+IPD,3,1452:' or '+IPD,1452:'

temp_buff1[temp_buff1_len + 1] = '\0';

char *index = strstr((char *)temp_buff1 + 5, ",");

if (index)

{ // '+IPD,3,1452:'

ret = sscanf((char *)temp_buff1, "+IPD,%hhd,%hd:", &mux_id, &frame_len);

if (ret != 2 || mux_id < 0 || mux_id > 4 || frame_len <= 0)

{ // format not satisfy, it's data

no_frame_flag = true;

}

else

{ // find frame start flag, although it may also data

new_frame = true;

}

}

else

{ // '+IPD,1452:'

ret = sscanf((char *)temp_buff1, "+IPD,%hd:", &frame_len);

if (ret != 1 || frame_len <= 0)

{ // format not satisfy, it's data

no_frame_flag = true;

}

else

{ // find frame start flag, although it may also data

new_frame = true;

// // printk("new frame:%d\r\n", frame_len);

}

}

}

}

else

{ // not match frame start flag, put into nic buffer

no_frame_flag = true;

}

// new frame or data

// or wait for frame start flag timeout(300ms, can be fewer), maybe they're data

if (new_frame || no_frame_flag || temp_buff1_len >= 12 ||

(find_frame_flag_index && (mp_hal_ticks_ms() - start1 > 300))) // '+IPD,3,1452:'

{

if (!new_frame)

{

if (frame_len_sum > 0)

{

// // printk("if(frame_len_sum > 0) { temp_buff2_len-%d temp_buff1_len-%d\r\n", temp_buff2_len, temp_buff1_len);

if (!Buffer_Puts(&nic->buffer, temp_buff1, temp_buff1_len + 1))

{

// printk("data_len_in_uart_buff %u temp_buff1_len %u temp_buff1 ", data_len_in_uart_buff, temp_buff1_len);

for (int i = 0; i < temp_buff1_len; i++) {

int tmp = temp_buff1[i];

// printk("(%c %02X)", temp_buff1[i], tmp);

}

// printk("\n");

// printk("data_len_in_uart_buff %u temp_buff1_len %u temp_buff1 ", data_len_in_uart_buff, temp_buff1_len);

for (int i = 0; i < temp_buff1_len; i++) {

int tmp = temp_buff1[i];

// printk("(%c %02X)", temp_buff1[i], tmp);

}

// printk("\n");

// overflow = true;

// break;//TODO:

}

}

else

{

if (temp_buff1[0] == 'C')

{

memset(temp_buff2, 0, sizeof(temp_buff2));

}

// // printk("-%d:%s\r\n", temp_buff2_len, temp_buff2);

// // printk("!(if(frame_len_sum > 0) {) temp_buff2_len-%d temp_buff1_len-%d\r\n", temp_buff2_len, temp_buff1_len);

temp_buff2[temp_buff2_len++] = temp_buff1[0];

// // printk("%c", temp_buff1[0]); //TODO: optimize uart overflow, if uart overflow, uncomment this will print some data

// // printk("-%d:%s\r\n", temp_buff2_len, temp_buff2);

if (strstr((const char *)temp_buff2, "CLOSED\r\n") != NULL)

{

// // printk("pear closed\r\n");

*peer_closed = true;

peer_just_closed = true;

break;

}

}

}

else

{

frame_len_sum += frame_len;

}

find_frame_flag_index = 0;

temp_buff1_len = 0;

new_frame = false;

no_frame_flag = false;

// enough data as required

size = Buffer_Size(&nic->buffer);

if (size >= out_buff_len) // data enough

break;

if (frame_len_sum != 0 && frame_len_sum <= size) // read at least one frame ok

{

break;

}

continue;

}

++temp_buff1_len;

}

if (timeout != 0 && (mp_hal_ticks_ms() - start2 > timeout) && !find_frame_flag_index)

{

// // printk("\n timeout %d start2 %d (mp_hal_ticks_ms() - start2 > timeout) %d find_frame_flag_index %d \n", timeout, start2, (mp_hal_ticks_ms() - start2 > timeout), find_frame_flag_index);

// // printk("\r-3 recvPkg nic %p out_buff %p out_buff_len %p data_len %p timeout %p coming_mux_id %p peer_closed %p first_time_recv %p\n", nic, out_buff, &out_buff_len, data_len, &timeout, coming_mux_id, peer_closed, &first_time_recv);

// printk("data_len_in_uart_buff %u temp_buff1_len %u temp_buff1 ", data_len_in_uart_buff, temp_buff1_len);

for (int i = 0; i < temp_buff1_len; i++) {

int tmp = temp_buff1[i];

// printk("(%c %02X)", temp_buff1[i], tmp);

}

// printk("\n");

return -3;

}

data_len_in_uart_buff = uart_rx_any(nic->uart_obj);

// // printk("\n2-%hd 1-%hd\n", temp_buff2_len, temp_buff1_len);

} while ((timeout || find_frame_flag_index) && (!*peer_closed || data_len_in_uart_buff > 0));

size = Buffer_Size(&nic->buffer);

if (size == 0 && !peer_just_closed && *peer_closed) //peer closed and no data in buffer

{

frame_len = 0;

frame_len_sum = 0;

// // printk("\r-4 recvPkg nic %p out_buff %p out_buff_len %p data_len %p timeout %p coming_mux_id %p peer_closed %p first_time_recv %p\n", nic, out_buff, &out_buff_len, data_len, &timeout, coming_mux_id, peer_closed, &first_time_recv);

return -4;

}

size = size > out_buff_len ? out_buff_len : size;

Buffer_Gets(&nic->buffer, (uint8_t *)out_buff, size);

if (data_len)

*data_len = size;

frame_len_sum -= size;

if (frame_len_sum <= 0 || peer_just_closed)

{

frame_len = 0;

frame_len_sum = 0;

Buffer_Clear(&nic->buffer);

if (peer_just_closed)

{

// // printk("\r-2 recvPkg nic %p out_buff %p out_buff_len %p data_len %p timeout %p coming_mux_id %p peer_closed %p first_time_recv %p\n", nic, out_buff, &out_buff_len, data_len, &timeout, coming_mux_id, peer_closed, &first_time_recv);

return -2;

}

}

// mp_printf(&mp_plat_print, "[MaixPy] %s | size %d out_buff_len %d *data_len %d \n", __func__, size, out_buff_len, *data_len);

return size;

}

旧 code 最大的问题在于处理过程单向思维，新 code 主要是上状态机分离 AT 指令和数据的处理过程。

对应的 HTTP Download 的 Python Code 也备份一下。

"""

The MIT License (MIT)

Copyright © 2018 Jean-Christophe Bos & HC² (www.hc2.fr)

"""

from struct import pack

import socket

import gc

class MicroWebCli:

# ============================================================================

# ===( Class AuthBasic )=====================================================

# ============================================================================

class AuthBasic:

# ------------------------------------------------------------------------

def __init__(self, user, password):

if password is None:

password = ''

if not 'b2a_base64' in globals():

from binascii import b2a_base64

cred = '%s:%s' % (user, password)

self._auth = 'Basic %s' % b2a_base64(

cred.encode()).decode().strip()

# ------------------------------------------------------------------------

def Apply(self, microWebCli):

microWebCli.Headers['Authorization'] = self._auth

# ============================================================================

# ===( Class AuthToken )=====================================================

# ============================================================================

class AuthToken:

# ------------------------------------------------------------------------

def __init__(self, token):

self._auth = 'Bearer %s' % token

# ------------------------------------------------------------------------

def Apply(self, microWebCli):

microWebCli.Headers['Authorization'] = self._auth

# ============================================================================

# ===( Utils )===============================================================

# ============================================================================

def _tryAllocByteArray(size):

for x in range(10):

try:

gc.collect()

return bytearray(size)

except:

pass

return None

# ----------------------------------------------------------------------------

@staticmethod

def _quote(s, safe='/'):

r = ''

for c in str(s):

if (c >= 'a' and c <= 'z') or \

(c >= '0' and c <= '9') or \

(c >= 'A' and c <= 'Z') or \

(c in '.-_') or (c in safe) :

r += c

else:

for b in c.encode('UTF-8'):

r += '%%%02X' % b

return r

# ----------------------------------------------------------------------------

@staticmethod

def _urlEncode(s):

return MicroWebCli._quote(s, ';/?:@&=+$,')

# ----------------------------------------------------------------------------

@staticmethod

def _unquote(s):

r = str(s).split('%')

try:

b = r[0].encode()

for i in range(1, len(r)):

try:

b += bytes([int(r[i][:2], 16)]) + r[i][2:].encode()

except:

b += b'%' + r[i].encode()

return b.decode('UTF-8')

except:

return str(s)

# ----------------------------------------------------------------------------

@staticmethod

def _unquote_plus(s):

return MicroWebCli._unquote(str(s).replace('+', ' '))

# ----------------------------------------------------------------------------

def GETRequest(url,

queryParams=None,

auth=None,

connTimeoutSec=10,

socks5Addr=None):

c = MicroWebCli(url,

auth=auth,

connTimeoutSec=connTimeoutSec,

socks5Addr=socks5Addr)

if queryParams:

c.QueryParams = queryParams

c.OpenRequest()

r = c.GetResponse()

if r.IsSuccess():

return r.ReadContent()

r.Close()

if r.IsLocationMoved():

return MicroWebCli.GETRequest(r.LocationMovedURL(), queryParams,

auth, connTimeoutSec, socks5Addr)

return None

# ----------------------------------------------------------------------------

def POSTRequest(url,

formData={},

auth=None,

connTimeoutSec=10,

socks5Addr=None):

c = MicroWebCli(url,

method='POST',

auth=auth,

connTimeoutSec=connTimeoutSec,

socks5Addr=socks5Addr)

c.OpenRequestFormData(formData)

r = c.GetResponse()

if r.IsSuccess():

return r.ReadContent()

r.Close()

if r.IsLocationMoved():

return MicroWebCli.POSTRequest(r.LocationMovedURL(), formData,

auth, connTimeoutSec, socks5Addr)

return None

# ----------------------------------------------------------------------------

def JSONRequest(url,

o=None,

auth=None,

connTimeoutSec=10,

socks5Addr=None):

c = MicroWebCli(url,

method=('POST' if o else 'GET'),

auth=auth,

connTimeoutSec=connTimeoutSec,

socks5Addr=socks5Addr)

if o:

c.OpenRequestJSONData(o)

else:

c.OpenRequest()

r = c.GetResponse()

if r.IsSuccess():

return r.ReadContentAsJSON()

r.Close()

if r.IsLocationMoved():

return MicroWebCli.JSONRequest(r.LocationMovedURL(), o, auth,

connTimeoutSec, socks5Addr)

return None

# ----------------------------------------------------------------------------

def FileRequest(url,

filepath,

progressCallback=None,

auth=None,

connTimeoutSec=5,

socks5Addr=None):

c = MicroWebCli(url,

auth=auth,

connTimeoutSec=connTimeoutSec,

socks5Addr=socks5Addr)

c.OpenRequest()

r = c.GetResponse()

if r.IsSuccess():

r.WriteContentToFile(filepath, progressCallback)

return r.GetContentType()

r.Close()

if r.IsLocationMoved():

return MicroWebCli.FileRequest(r.LocationMovedURL(), filepath,

progressCallback, auth,

connTimeoutSec, socks5Addr)

return None

# ============================================================================

# ===( Constructor )==========================================================

# ============================================================================

def __init__(self,

url='',

method='GET',

auth=None,

connTimeoutSec=10,

socks5Addr=None):

self.URL = url

self.Method = method

self.Auth = auth

self.ConnTimeoutSec = connTimeoutSec

self._socks5Addr = socks5Addr

self._headers = {}

self._socket = None

self._socketAddr = None

self._response = None

# ============================================================================

# ===( Functions )============================================================

# ============================================================================

def _write(self, data):

try:

data = memoryview(data)

while data:

n = self._socket.write(data)

data = data[n:]

return True

except:

self.Close()

raise Exception('Error to send data on connection')

# ------------------------------------------------------------------------

def _writeFirstLine(self):

path = MicroWebCli._quote(self.Path)

qs = self.QueryString

if qs != '':

path = path + '?' + qs

self._write('%s %s HTTP/1.0\r\n' % (self.Method, path))

# ------------------------------------------------------------------------

def _writeHeader(self, name, value):

self._write("%s: %s\r\n" % (name, value))

# ------------------------------------------------------------------------

def _writeEndHeader(self):

self._write("\r\n")

# ------------------------------------------------------------------------

def OpenRequest(self, data=None, contentType=None, contentLength=None):

if self._socket:

raise Exception('Request is already opened')

if not self.URL:

raise Exception('No URL defined')

if self.Socks5Addr:

if not isinstance(self.Socks5Addr,

tuple) or len(self.Socks5Addr) != 2:

raise Exception('"Socks5Addr" must be a tuple of (host, port)')

host, port = self.Socks5Addr

if not isinstance(host, str) or not isinstance(port, int):

raise Exception('"Socks5Addr" is incorrect ("%s", %s)' %

self.Socks5Addr)

else:

host = self.Host

port = self.Port

self._response = None

try:

err = 0

while 1:

try:

self._socketAddr = socket.getaddrinfo(host, port)[0][-1]

break

except Exception:

err += 1

if err > 5:

raise Exception("get ip failed!")

#cli = socket.socket()

cli = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

cli.settimeout(self.ConnTimeoutSec)

cli.connect(self._socketAddr)

except:

raise Exception('Error to connect to %s:%s' % (host, port))

if self.Socks5Addr:

err = None

try:

cli.send(b'\x05\x01\x00')

b = cli.read(2)

if b is None or len(b) < 2 or b[0] != 0x05 or b[1] != 0x00:

err = "%s:%s doesn't supports MicroWebCli SOCKS5 client protocol" % self.Socks5Addr

else:

h = self.Host.encode()

p = pack('>H', self.Port)

cli.send(b'\x05\x01\x00\x03' + bytes([len(h)]) + h + p)

b = cli.read(4)

if b is None or len(b) < 4 or b[1] != 0x00:

err = "Error to connect to %s:%s through SOCKS5 server" % (

self.Host, self.Port)

else:

if b[3] == 0x01:

l = 4

elif b[3] == 0x03:

l = cli.read(1)[0]

elif b[3] == 0x04:

l = 16

cli.read(l + 2)

except Exception as ex:

err = 'Error during negotiation with SOCKS5 server (%s)' % ex

if err:

cli.close()

raise Exception(err)

if self.Proto == 'https':

if not 'ssl' in globals():

import ssl

try:

try:

cli = ssl.wrap_socket(cli, timeout=self.ConnTimeoutSec)

except TypeError:

cli = ssl.wrap_socket(cli)

except Exception as ex:

cli.close()

raise Exception(

'Error to open a secure SSL/TLS connection (%s)' % ex)

self._socket = cli

self._writeFirstLine()

if data:

contentLength = len(data)

self._headers['Host'] = self.Host

if self._auth:

try:

self._auth.Apply(self)

except:

raise Exception('Error to apply authentication using %s' %

type(self._auth))

else:

self._headers.pop('Authorization', None)

if contentType:

self._headers['Content-Type'] = contentType

else:

self._headers.pop('Content-Type', None)

if contentLength:

self._headers['Content-Length'] = contentLength

else:

self._headers.pop('Content-Length', None)

self._headers['User-Agent'] = 'MicroWebCli by JC`zic'

for h in self._headers:

self._writeHeader(h, self._headers[h])

self._writeEndHeader()

if data:

self._write(data)

# ------------------------------------------------------------------------

def OpenRequestFormData(self, formData={}):

data = ''

if len(formData) > 0:

for param in formData:

if param != '':

if data != '':

data += '&'

data += MicroWebCli._quote(

param) + '=' + MicroWebCli._quote(formData[param])

self.OpenRequest(data=data,

contentType='application/x-www-form-urlencoded')

# ------------------------------------------------------------------------

def OpenRequestJSONData(self, o=None):

if not 'json' in globals():

import json

try:

data = json.dumps(o)

except:

raise Exception('Error to convert object to JSON format')

self.OpenRequest(data=data, contentType='application/json')

# ------------------------------------------------------------------------

def RequestWriteData(self, data):

self._write(data)

# ------------------------------------------------------------------------

def GetResponse(self):

if not self._response:

self._response = MicroWebCli._response(self, self._socket,

self._socketAddr)

return self._response

# ------------------------------------------------------------------------

def IsClosed(self):

return self._socket is None

# ------------------------------------------------------------------------

def Close(self):

if self._socket:

try:

self._socket.close()

except:

pass

self._socket = None

# ============================================================================

# ===( Properties )===========================================================

# ============================================================================

@property

def ConnTimeoutSec(self):

return self._connTimeoutSec

@ConnTimeoutSec.setter

def ConnTimeoutSec(self, value):

self._connTimeoutSec = int(value) if value and int(value) > 0 else None

# ------------------------------------------------------------------------

@property

def Method(self):

return self._method

@Method.setter

def Method(self, value):

self._method = str(value).upper()

# ------------------------------------------------------------------------

@property

def URL(self):

host = self.Host

if host != '':

proto = self.Proto

port = self.Port

if ( proto == 'http' and port == 80 ) or \

( proto == 'https' and port == 443 ) :

port = ''

else:

port = ':' + str(port)

url = proto + '://' + host + port + self.Path

url = MicroWebCli._urlEncode(url)

qs = self.QueryString

if qs != '':

return url + '?' + qs

return url

return None

@URL.setter

def URL(self, value):

try:

s = str(value)

if '://' in s:

proto, s = s.split('://', 1)

else:

proto = 'http'

except:

raise ValueError('URL error (%s)' % value)

self.Proto = proto

if '/' in s:

host, path = s.split('/', 1)

elif '?' in s:

host, path = s.split('?', 1)

path = '?' + path

else:

host = s

path = ''

if ':' in host:

try:

host, port = host.split(':')

self.Port = port

except:

raise ValueError('URL host:port error (%s)' % host)

self.Host = host

self._queryParams = {}

self.Path = path

# ------------------------------------------------------------------------

@property

def Proto(self):

return self._proto

@Proto.setter

def Proto(self, value):

value = str(value).lower()

if value == 'http':

self._port = 80

elif value == 'https':

self._port = 443

else:

raise ValueError('Unsupported URL protocol (%s)' % value)

self._proto = value

# ------------------------------------------------------------------------

@property

def Host(self):

return self._host

@Host.setter

def Host(self, value):

self._host = MicroWebCli._unquote_plus(str(value))

# ------------------------------------------------------------------------

@property

def Port(self):

return self._port

@Port.setter

def Port(self, value):

self._port = int(value)

# ------------------------------------------------------------------------

@property

def Path(self):

return self._path

@Path.setter

def Path(self, value):

x = value.split('?', 1)

if len(x[0]) > 0:

if x[0][0] != '/':

x[0] = '/' + x[0]

self._path = MicroWebCli._unquote_plus(x[0])

else:

self._path = '/'

if len(x) == 2:

self.QueryString = x[1]

# ------------------------------------------------------------------------

@property

def QueryString(self):

r = ''

for param in self._queryParams:

if param != '':

if r != '':

r += '&'

r += MicroWebCli._quote(param) + '=' + MicroWebCli._quote(

self._queryParams[param])

return r

@QueryString.setter

def QueryString(self, value):

self._queryParams = {}

for x in value.split('&'):

param = x.split('=', 1)

if param[0] != '':

value = MicroWebCli._unquote(

param[1]) if len(param) > 1 else ''

self._queryParams[MicroWebCli._unquote(param[0])] = value

# ------------------------------------------------------------------------

@property

def QueryParams(self):

return self._queryParams

@QueryParams.setter

def QueryParams(self, value):

if not isinstance(value, dict):

raise ValueError('QueryParams must be a dict')

self._queryParams = value

# ------------------------------------------------------------------------

@property

def Headers(self):

return self._headers

@Headers.setter

def Headers(self, value):

if not isinstance(value, dict):

raise ValueError('Headers must be a dict')

self._headers = value

# ------------------------------------------------------------------------

@property

def Auth(self):

return self._auth

@Auth.setter

def Auth(self, value):

self._auth = value

# ------------------------------------------------------------------------

@property

def Socks5Addr(self):

return self._socks5Addr

@Socks5Addr.setter

def Socks5Addr(self, value):

self._socks5Addr = value

# ============================================================================

# ===( Class Response )======================================================

# ============================================================================

class _response:

# ------------------------------------------------------------------------

def __init__(self, microWebCli, socket, addr):

self._microWebCli = microWebCli

self._socket = socket

self._addr = addr

self._httpVer = None

self._code = None

self._msg = None

self._headers = {}

self._contentType = None

self._contentLength = None

self._processResponse()

# ------------------------------------------------------------------------

def _processResponse(self):

try:

self._parseFirstLine()

self._parseHeader()

if self._contentLength == 0:

self.Close()

except:

self._microWebCli.Close()

raise Exception('Error to get response')

# ------------------------------------------------------------------------

def _parseFirstLine(self):

tmp = self._socket.readline();

print(tmp)

self._httpVer, code, self._msg = tmp \

.decode() \

.strip() \

.split(' ', 2)

self._code = int(code)

# ------------------------------------------------------------------------

def _parseHeader(self):

while True:

tmp = self._socket.readline();

print(tmp)

elements = tmp \

.decode() \

.strip() \

.split(':', 1)

if len(elements) == 2:

self._headers[elements[0].strip()] = elements[1].strip()

elif len(elements) == 1 and len(elements[0]) == 0:

self._contentType = self._headers.get("Content-Type", None)

ctLen = self._headers.get("Content-Length", None)

self._contentLength = int(

ctLen) if ctLen is not None else None

break

# ------------------------------------------------------------------------

def GetClient(self):

return self._microWebCli

# ------------------------------------------------------------------------

def GetAddr(self):

return self._addr

# ------------------------------------------------------------------------

def GetIPAddr(self):

return self._addr[0]

# ------------------------------------------------------------------------

def GetPort(self):

return self._addr[1]

# ------------------------------------------------------------------------

def GetHTTPVersion(self):

return self._httpVer

# ------------------------------------------------------------------------

def GetStatusCode(self):

return self._code

# ------------------------------------------------------------------------

def GetStatusMessage(self):

return self._msg

# ------------------------------------------------------------------------

def IsSuccess(self):

return (self._code >= 200 and self._code < 300)

# ------------------------------------------------------------------------

def IsLocationMoved(self):

return self.LocationMovedURL() is not None

# ------------------------------------------------------------------------

def LocationMovedURL(self):

if self._code >= 300 and self._code < 400:

return self._headers.get('Location', None)

return None

# ------------------------------------------------------------------------

def GetHeaders(self):

return self._headers

# ------------------------------------------------------------------------

def GetContentType(self):

return self._contentType

# ------------------------------------------------------------------------

def GetContentLength(self):

return self._contentLength

# ------------------------------------------------------------------------

def ReadContent(self, size=None):

try:

if size is None:

b = self._socket.read()

self.Close()

return b

elif size > 0:

b = self._socket.read(size)

if len(b) < size:

self.Close()

return b

except MemoryError as memEx:

self.Close()

raise MemoryError('Error to read response content (%s)' %

memEx)

except:

self.Close()

return None

# ------------------------------------------------------------------------

def ReadContentInto(self, buf, nbytes=None):

if nbytes is None:

nbytes = len(buf)

if nbytes > 0:

try:

x = self._socket.readinto(buf, nbytes)

if x < nbytes:

self.Close()

return x

except Exception as e:

print(e)

self.Close()

except:

self.Close()

return 0

# ------------------------------------------------------------------------

def ReadContentAsJSON(self):

cnt = self.ReadContent()

if cnt:

if not 'json' in globals():

import json

try:

return json.loads(cnt)

except:

raise Exception('Error to parse JSON response : %s' % cnt)

return None

# ------------------------------------------------------------------------

def WriteContentToFile(self, filepath, progressCallback=None):

fSize = self._contentLength

buf = MicroWebCli._tryAllocByteArray(

fSize if fSize and fSize < 10240 else 10240)

if not buf:

raise MemoryError('Not enough memory to allocate buffer')

buf = memoryview(buf)

try:

file = open(filepath, 'wb')

except:

raise Exception('Error to create file (%s)' % filepath)

sizeRem = fSize

pgrSize = 0

#import uhashlib, binascii

#sha = uhashlib.sha256()

while sizeRem is None or sizeRem > 0:

if sizeRem and sizeRem < len(buf):

buf = buf[:sizeRem]

x = self.ReadContentInto(buf)

if x == 0:

break

if x < len(buf):

buf = buf[:x]

if sizeRem:

sizeRem -= x

#print('len(buf)', len(buf), 'buf', bytes(buf[:len(buf)-1]))

#tmp = bytes(buf[:len(buf)])

#print(tmp)

#sha.update(tmp)

try:

file.write(buf)

except Exception as ex:

print('file.write : %s' % ex)

pgrSize += x

if progressCallback:

try:

progressCallback(self, pgrSize, fSize)

except Exception as ex:

print('Error in progressCallback : %s' % ex)

file.close()

self.Close()

#print(binascii.hexlify(sha.digest()))

if sizeRem and sizeRem > 0:

if not 'remove' in globals():

from os import remove

remove(filepath)

raise Exception('Error to receive and save file (%s)' %

filepath)

# ------------------------------------------------------------------------

def IsClosed(self):

return self._microWebCli.IsClosed()

# ------------------------------------------------------------------------

def Close(self):

self._microWebCli.Close()

# ============================================================================

# ============================================================================

# ============================================================================

import network, time, socket

from machine import UART

from fpioa_manager import fm, board_info

if 'wlan' not in locals():

# En EP8285 AT

fm.register(27, fm.fpioa.UART2_TX, force=True)

fm.register(28, fm.fpioa.UART2_RX, force=True)

uart = UART(UART.UART2, 115200*8, 8, 2, 2, timeout=3000, read_buf_len=10240)

time.sleep(3)

wlan = network.ESP8285(uart)

WIFI_SSID = "webduino.io"

WIFI_PASW = "webduino"

err = 0

while 1:

try:

wlan.connect(WIFI_SSID, WIFI_PASW)

except Exception:

err += 1

print("Connect AP failed, now try again")

if err > 3:

raise Exception("Conenct AP fail")

continue

break

print(wlan.ifconfig())

print(wlan.isconnected())

def progressCallback(microWebCli, progressSize, totalSize):

if totalSize:

pass #

print('Progress: %d bytes of %d downloaded...' % (progressSize, totalSize))

else:

pass #

print('Progress: %d bytes downloaded...' % progressSize)

filename = '/sd/face_test.kmodel'

fileurl = 'http://120.78.165.108/juwan/face.kmodel'

try:

import os

os.remove(filename)

except Exception as e:

pass

contentType = MicroWebCli.FileRequest(fileurl, filename, progressCallback)

print('File of content type "%s" was saved to "%s"' % (contentType, filename))