sync

buzzer_tool/core/commands/put.py

@@ -76,4 +76,7 @@ def execute(conn, sources: list, target: str):
             print(f"\n  ❌ \033[31mFehler: {e}\033[0m")
 
     total_duration = time.monotonic() - start_time_all
-    print(f"\nAlle {len(resolved_files)} Dateien in {total_duration:.1f}s übertragen.")
+    total_kb = total_size_all / 1024
+    avg_speed = total_kb / total_duration if total_duration > 0 else 0
+    
+    print(f"\nÜbertragung abgeschlossen: {total_kb:.1f} KB in {total_duration:.1f}s ({avg_speed:.1f} KB/s)")

firmware/src/protocol.c

@@ -129,8 +129,8 @@ int put_binary_file(const char *filename, ssize_t filesize, uint32_t expected_cr
             continue;
         }
 
-        // ssize_t written = fs_write(&file, buffer, read);
+        ssize_t written = fs_write(&file, buffer, read);
-        ssize_t written = read;
+        //ssize_t written = read;
         if (written < 0)
         {
             LOG_ERR("Error writing to file '%s': %d", filename, (int)written);

firmware/src/usb.c

@@ -26,15 +26,25 @@ static void cdc_acm_irq_cb(const struct device *dev, void *user_data)
         return;
     }
 
-    /* Der Interrupt bleibt permanent an. Daten sofort in Ringbuffer schieben. */
     if (uart_irq_rx_ready(dev)) {
         uint8_t buffer[64];
-        int len;
+        uint32_t space = ring_buf_space_get(&rx_ringbuf);
         
-        while ((len = uart_fifo_read(dev, buffer, sizeof(buffer))) > 0) {
+        if (space == 0) {
-            ring_buf_put(&rx_ringbuf, buffer, len);
+            /* Backpressure anwenden: Ringpuffer ist voll.
+               Interrupt deaktivieren, damit Daten im HW-FIFO bleiben 
+               und der USB-Stack den Host drosselt (NAK). */
+            uart_irq_rx_disable(dev);
+        } else {
+            /* Nur so viele Daten lesen, wie Platz im Ringpuffer ist */
+            int to_read = MIN(sizeof(buffer), space);
+            int len = uart_fifo_read(dev, buffer, to_read);
+            
+            if (len > 0) {
+                ring_buf_put(&rx_ringbuf, buffer, len);
+                k_sem_give(&usb_rx_sem);
+            }
         }
-        k_sem_give(&usb_rx_sem);
     }
 
     if (uart_irq_tx_ready(dev)) {
@@ -45,26 +55,44 @@ static void cdc_acm_irq_cb(const struct device *dev, void *user_data)
 
 bool usb_wait_for_data(k_timeout_t timeout)
 {
-    /* Wenn Daten im Puffer sind, nicht blockieren */
     if (!ring_buf_is_empty(&rx_ringbuf)) {
         return true;
     }
+    
+    /* Wenn der Puffer leer ist, sicherstellen, dass der RX-Interrupt 
+       aktiviert ist, da sonst keine neuen Daten empfangen werden können. */
+    if (device_is_ready(cdc_dev)) {
+        uart_irq_rx_enable(cdc_dev);
+    }
+    
     return (k_sem_take(&usb_rx_sem, timeout) == 0);
 }
 
 int usb_read_char(uint8_t *c)
 {
-    return ring_buf_get(&rx_ringbuf, c, 1);
+    int ret = ring_buf_get(&rx_ringbuf, c, 1);
+    if (ret > 0 && device_is_ready(cdc_dev)) {
+        /* Platz geschaffen -> Empfang wieder aktivieren */
+        uart_irq_rx_enable(cdc_dev);
+    }
+    return ret;
 }
 
 int usb_read_buffer(uint8_t *buf, size_t max_len)
 {
-    return ring_buf_get(&rx_ringbuf, buf, max_len);
+    int ret = ring_buf_get(&rx_ringbuf, buf, max_len);
+    if (ret > 0 && device_is_ready(cdc_dev)) {
+        /* Platz geschaffen -> Empfang wieder aktivieren */
+        uart_irq_rx_enable(cdc_dev);
+    }
+    return ret;
 }
 
 void usb_resume_rx(void)
 {
-    /* Leere Funktion - Interrupt wird nicht mehr deaktiviert */
+    if (device_is_ready(cdc_dev)) {
+        uart_irq_rx_enable(cdc_dev);
+    }
 }
 
 void usb_write_char(uint8_t c)