Rework flipper serial (not tested)

Author: sashacmc

include/zenoh-pico/system/platform/flipper.h

@@ -44,6 +44,8 @@ typedef struct {
 #if Z_FEATURE_LINK_SERIAL == 1
     FuriStreamBuffer* _rx_stream;
     FuriHalSerialHandle* _serial;
+    uint8_t* tmp_buf;
+    uint8_t* raw_buf;
 #endif
 } _z_sys_net_socket_t;
 

src/system/flipper/network.c

@@ -77,7 +77,11 @@ z_result_t _z_open_serial_from_dev(_z_sys_net_socket_t* sock, char* dev, uint32_
     furi_hal_serial_async_rx_start(sock->_serial, _z_serial_received_byte_callback, sock->_rx_stream, false);
 
     _Z_DEBUG("Serial port opened: %s (%li)", dev, baudrate);
-    return _Z_RES_OK;
+
+    sock->tmp_buf = (uint8_t*)z_malloc(_Z_SERIAL_MFS_SIZE);
+    sock->raw_buf = (uint8_t*)z_malloc(_Z_SERIAL_MAX_COBS_BUF_SIZE);
+
+    return _z_connect_serial(*sock);
 }
 
 z_result_t _z_listen_serial_from_pins(_z_sys_net_socket_t* sock, uint32_t txpin, uint32_t rxpin, uint32_t baudrate) {
@@ -112,110 +116,42 @@ void _z_close_serial(_z_sys_net_socket_t* sock) {
 
         sock->_serial = 0;
         sock->_rx_stream = 0;
+
+        z_free(sock->tmp_buf);
+        z_free(sock->raw_buf);
     }
     _Z_DEBUG("Serial port closed");
 }
 
-size_t _z_read_serial(const _z_sys_net_socket_t sock, uint8_t* ptr, size_t len) {
-    z_result_t ret = _Z_RES_OK;
-
-    uint8_t* before_cobs = (uint8_t*)z_malloc(_Z_SERIAL_MAX_COBS_BUF_SIZE);
+size_t _z_read_serial_internal(const _z_sys_net_socket_t sock, uint8_t* header, uint8_t* ptr, size_t len) {
     size_t rb = 0;
     for (size_t i = 0; i < _Z_SERIAL_MAX_COBS_BUF_SIZE; i++) {
         size_t len = 0;
-        len = furi_stream_buffer_receive(sock._rx_stream, &before_cobs[i], 1, FLIPPER_SERIAL_TIMEOUT_MS);
+        len = furi_stream_buffer_receive(sock._rx_stream, &sock.raw_buf[i], 1, FLIPPER_SERIAL_TIMEOUT_MS);
         if (!len) {
-            z_free(before_cobs);
             return SIZE_MAX;
         }
-        rb += 1;
+        rb++;
 
-        if (before_cobs[i] == (uint8_t)0x00) {
+        if (sock.raw_buf[i] == (uint8_t)0x00) {
             break;
         }
     }
 
-    uint8_t* after_cobs = (uint8_t*)z_malloc(_Z_SERIAL_MFS_SIZE);
-    size_t trb = _z_cobs_decode(before_cobs, rb, after_cobs);
-
-    size_t i = 0;
-    uint16_t payload_len = 0;
-    for (i = 0; i < sizeof(payload_len); i++) {
-        payload_len |= (after_cobs[i] << ((uint8_t)i * (uint8_t)8));
-    }
-
-    if (trb == (size_t)(payload_len + (uint16_t)6)) {
-        (void)memcpy(ptr, &after_cobs[i], payload_len);
-        i += (size_t)payload_len;
-
-        uint32_t crc = 0;
-        for (uint8_t j = 0; j < sizeof(crc); j++) {
-            crc |= (uint32_t)(after_cobs[i] << (j * (uint8_t)8));
-            i += 1;
-        }
-
-        uint32_t c_crc = _z_crc32(ptr, payload_len);
-        if (c_crc != crc) {
-            ret = _Z_ERR_GENERIC;
-        }
-    } else {
-        ret = _Z_ERR_GENERIC;
-    }
-
-    z_free(before_cobs);
-    z_free(after_cobs);
-
-    rb = payload_len;
-    if (ret != _Z_RES_OK) {
-        rb = SIZE_MAX;
-    }
-
-    return rb;
-}
-
-size_t _z_read_exact_serial(const _z_sys_net_socket_t sock, uint8_t* ptr, size_t len) {
-    size_t n = len;
-
-    do {
-        size_t rb = _z_read_serial(sock, ptr, n);
-        if (rb == SIZE_MAX) {
-            return rb;
-        }
-        n -= rb;
-        ptr += len - n;
-    } while (n > 0);
-
-    return len;
+    return _z_serial_msg_deserialize(sock.raw_buf, rb, ptr, len, header, sock.tmp_buf, _Z_SERIAL_MFS_SIZE);
 }
 
-size_t _z_send_serial(const _z_sys_net_socket_t sock, const uint8_t* ptr, size_t len) {
-    z_result_t ret = _Z_RES_OK;
+size_t _z_send_serial_internal(const _z_sys_net_socket_t sock, uint8_t header, const uint8_t* ptr, size_t len) {
+    size_t ret = _z_serial_msg_serialize(sock.raw_buf, _Z_SERIAL_MAX_COBS_BUF_SIZE, ptr, len, header, sock.tmp_buf,
+                                         _Z_SERIAL_MFS_SIZE);
 
-    uint8_t* before_cobs = (uint8_t*)z_malloc(_Z_SERIAL_MFS_SIZE);
-    size_t i = 0;
-    for (i = 0; i < sizeof(uint16_t); ++i) {
-        before_cobs[i] = (len >> (i * (size_t)8)) & (size_t)0XFF;
+    if (ret == SIZE_MAX) {
+        return ret;
     }
 
-    (void)memcpy(&before_cobs[i], ptr, len);
-    i += len;
-
-    uint32_t crc = _z_crc32(ptr, len);
-    for (uint8_t j = 0; j < sizeof(crc); j++) {
-        before_cobs[i] = (crc >> (j * (uint8_t)8)) & (uint32_t)0XFF;
-        i++;
-    }
-
-    uint8_t* after_cobs = (uint8_t*)z_malloc(_Z_SERIAL_MAX_COBS_BUF_SIZE);
-    ssize_t twb = _z_cobs_encode(before_cobs, i, after_cobs);
-    after_cobs[twb] = 0x00;  // Manually add the COBS delimiter
-
-    furi_hal_serial_tx(sock._serial, after_cobs, twb + (ssize_t)1);
+    furi_hal_serial_tx(sock._serial, sock.raw_buf, ret);
     furi_hal_serial_tx_wait_complete(sock._serial);
 
-    z_free(before_cobs);
-    z_free(after_cobs);
-
     return len;
 }
 #endif