diff --git a/include/proto_usb.h b/include/proto_usb.h
index c75bbb2..26c6f0c 100644
--- a/include/proto_usb.h
+++ b/include/proto_usb.h
@@ -25,7 +25,7 @@ struct __attribute__((__packed__)) usbp_measurement_pkt {
     uint8_t packet_type;
     uint8_t num_channels;
     size_t num_samples[2];
-    int32_t measurements[2][2][64];
+    int32_t measurements[2][2][15];
 };
 
 
diff --git a/src/proto.c b/src/proto.c
index 460594f..48f7a20 100644
--- a/src/proto.c
+++ b/src/proto.c
@@ -51,41 +51,43 @@ void uart_handle_user_packet(struct ll_pkt *pkt, size_t len) {
         if (pkt->type == PK_FETCH_RESPONSE) {
 
             size_t index = (pkt->src - BADDR_MEAS_BASE) & 1;
-            struct pkt_adc_data *pkt = (struct pkt_adc_data *)pkt;
-            size_t offset = st_proto.adc_sp_wr_idx[index];
-            size_t num_new = pkt->sample_count - st_proto.adc_sample_count[index];
+            struct pkt_adc_data *pkt_adc = (struct pkt_adc_data *)pkt;
+            size_t wr_pos = st_proto.adc_sp_wr_idx[index];
+            size_t rd_pos = st_proto.adc_sp_rd_idx[index];
+            size_t num_new = pkt_adc->sample_count - st_proto.adc_sample_count[index];
 
-            if (num_new > COUNT_OF(pkt->samples)) {
+            if (num_new > COUNT_OF(pkt_adc->samples)) {
                 st_proto.last_error = sys_time_us;
                 st_proto.error = ERR_BUFFER_OVERFLOW;
-                num_new = COUNT_OF(pkt->samples);
+                num_new = COUNT_OF(pkt_adc->samples);
             }
 
             for (ssize_t i=num_new-1; i>=0; i--) {
                 for (size_t channel=0; channel<2; channel++) {
-                    st_proto.adc_samples[index][channel][offset] = 
-                        pkt->samples[i][channel][2]    | 
-                        pkt->samples[i][channel][1]<<8 |
-                        (((int32_t)(int8_t)pkt->samples[i][channel][0])<<16);
+                    st_proto.adc_samples[index][channel][wr_pos] = 
+                        pkt_adc->samples[i][channel][2]    | 
+                        pkt_adc->samples[i][channel][1]<<8 |
+                        (((int32_t)(int8_t)pkt_adc->samples[i][channel][0])<<16);
                 }
 
-                offset ++;
-                if (offset >= COUNT_OF(st_proto.adc_samples[0][0])) {
-                    offset = 0;
+                size_t new_wr_pos = wr_pos+1;
+                if (new_wr_pos >= COUNT_OF(st_proto.adc_samples[0][0])) {
+                    new_wr_pos = 0;
+                }
+
+                if (new_wr_pos == rd_pos) {
+                    st_proto.last_error = sys_time_us;
+                    st_proto.error = ERR_BUFFER_OVERFLOW;
+                    break;
+                } else {
+                    wr_pos = new_wr_pos;
                 }
             }
 
-            size_t old_wr_pos = st_proto.adc_sp_wr_idx[index];
-            size_t rd_pos = st_proto.adc_sp_rd_idx[index];
-            if ((old_wr_pos < rd_pos && rd_pos < offset) || !(offset < rd_pos && rd_pos < old_wr_pos)) {
-                st_proto.last_error = sys_time_us;
-                st_proto.error = ERR_BUFFER_OVERFLOW;
-            }
-
-            st_proto.adc_sp_wr_idx[index] = offset;
-            st_proto.adc_sample_timestamp[index] = pkt->timestamp;
-            st_proto.adc_sampling_interval[index] = pkt->sampling_interval_us;
-            st_proto.adc_sample_count[index] = pkt->sample_count;
+            st_proto.adc_sp_wr_idx[index] = wr_pos;
+            st_proto.adc_sample_timestamp[index] = pkt_adc->timestamp;
+            st_proto.adc_sampling_interval[index] = pkt_adc->sampling_interval_us;
+            st_proto.adc_sample_count[index] = pkt_adc->sample_count;
 
             proto_handle_host(false);
 
diff --git a/src/proto_usb.c b/src/proto_usb.c
index 7b3fb1d..50f02ad 100644
--- a/src/proto_usb.c
+++ b/src/proto_usb.c
@@ -34,16 +34,17 @@ void handle_usb_packet(void *packet, size_t len) {
                     .num_channels = 4,
                 };
 
-                for (size_t board=0; board==2; board++) {
+                for (size_t board=0; board<2; board++) {
                     size_t rd_idx = st_proto.adc_sp_rd_idx[board];
                     size_t wr_idx = st_proto.adc_sp_wr_idx[board];
                     size_t nread = 0;
 
                     while (rd_idx != wr_idx && nread < COUNT_OF(response.measurements[0][0])) {
-                        for (size_t channel=0; channel==2; channel++) {
+                        for (size_t channel=0; channel<2; channel++) {
                             response.measurements[board][channel][nread] = st_proto.adc_samples[board][channel][rd_idx];
                         }
 
+                        nread++;
                         rd_idx++;
                         if (rd_idx == COUNT_OF(st_proto.adc_samples[0][0])) {
                             rd_idx = 0;
diff --git a/src/serial.c b/src/serial.c
index f932efa..b454b26 100644
--- a/src/serial.c
+++ b/src/serial.c
@@ -84,7 +84,7 @@ void uart_interrupt(uint32_t isr) {
             return;
         }
 
-        volatile struct ll_pkt *pkt = (volatile struct ll_pkt *)&uart_st.rx_buf;
+        volatile struct ll_pkt *pkt = (volatile struct ll_pkt *)uart_st.rx_buf;
 
         if (pkt->dst != uart_st.addr && pkt->dst != SER_ADDR_BROADCAST) {
             /* we are not addressed */