add last_write property

Author: timchinowsky

ports/raspberrypi/bindings/rp2pio/StateMachine.c

@@ -565,24 +565,21 @@ static mp_obj_t rp2pio_statemachine_background_write(size_t n_args, const mp_obj
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
     mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
 
-    sm_buf_info once_info;
-    sm_buf_info loop_info;
-    sm_buf_info loop2_info;
     size_t stride_in_bytes = 0;
-    fill_buf_info(&once_info, args[ARG_once].u_obj, &stride_in_bytes, MP_BUFFER_READ);
-    fill_buf_info(&loop_info, args[ARG_loop].u_obj, &stride_in_bytes, MP_BUFFER_READ);
-    fill_buf_info(&loop2_info, args[ARG_loop2].u_obj, &stride_in_bytes, MP_BUFFER_READ);
 
     self->once_write_buf_obj = args[ARG_once].u_obj;
     self->loop_write_buf_obj = args[ARG_loop].u_obj;
     self->loop2_write_buf_obj = args[ARG_loop2].u_obj;
 
+    fill_buf_info(&self->once_write_buf_info, args[ARG_once].u_obj, &stride_in_bytes, MP_BUFFER_READ);
+    fill_buf_info(&self->loop_write_buf_info, args[ARG_loop].u_obj, &stride_in_bytes, MP_BUFFER_READ);
+    fill_buf_info(&self->loop2_write_buf_info, args[ARG_loop2].u_obj, &stride_in_bytes, MP_BUFFER_READ);
+
     if (!stride_in_bytes) {
         return mp_const_none;
     }
 
-    bool ok = common_hal_rp2pio_statemachine_background_write(self, &once_info, &loop_info, &loop2_info,
-        stride_in_bytes, args[ARG_swap].u_bool);
+    bool ok = common_hal_rp2pio_statemachine_background_write(self, stride_in_bytes, args[ARG_swap].u_bool);
 
     if (mp_hal_is_interrupted()) {
         return mp_const_none;

ports/raspberrypi/bindings/rp2pio/StateMachine.h

@@ -52,7 +52,6 @@ void common_hal_rp2pio_statemachine_run(rp2pio_statemachine_obj_t *self, const u
 bool common_hal_rp2pio_statemachine_write(rp2pio_statemachine_obj_t *self, const uint8_t *data, size_t len, uint8_t stride_in_bytes, bool swap);
 
 bool common_hal_rp2pio_statemachine_background_write(rp2pio_statemachine_obj_t *self,
-    const sm_buf_info *once_write_buf, const sm_buf_info *loop_write_buf, const sm_buf_info *loop2_write_buf,
     uint8_t stride_in_bytes, bool swap);
 
 bool common_hal_rp2pio_statemachine_background_read(rp2pio_statemachine_obj_t *self,

ports/raspberrypi/common-hal/rp2pio/StateMachine.c

@@ -1047,42 +1047,51 @@ uint8_t rp2pio_statemachine_program_offset(rp2pio_statemachine_obj_t *self) {
     return _current_program_offset[pio_index][sm];
 }
 
-bool common_hal_rp2pio_statemachine_background_write(rp2pio_statemachine_obj_t *self,
-    const sm_buf_info *once_write_buf, const sm_buf_info *loop_write_buf, const sm_buf_info *loop2_write_buf,
-    uint8_t stride_in_bytes, bool swap) {
+bool common_hal_rp2pio_statemachine_background_write(rp2pio_statemachine_obj_t *self, uint8_t stride_in_bytes, bool swap) {
 
     uint8_t pio_index = pio_get_index(self->pio);
     uint8_t sm = self->state_machine;
 
-    int pending_buffers_write = (once_write_buf->info.len != 0) + (loop_write_buf->info.len != 0) + (loop2_write_buf->info.len != 0);
+    self->switched_write_buffers = false;
+
+    int pending_buffers_write = (self->once_write_buf_info.info.len != 0) + (self->loop_write_buf_info.info.len != 0) + (self->loop2_write_buf_info.info.len != 0);
 
     // If all buffer arguments have nonzero length, write once_write_buf, loop_write_buf, loop2_write_buf and repeat last two forever
 
-    if (!once_write_buf->info.len) {
-        if (!loop_write_buf->info.len) {
+    if (!(self->once_write_buf_info.info.len)) {
+        if (!self->loop_write_buf_info.info.len) {
             // If once_write_buf and loop_write_buf have zero length, write loop2_write_buf forever
-            once_write_buf = loop2_write_buf;
-            loop_write_buf = loop2_write_buf;
+            self->once_write_buf_info = self->loop2_write_buf_info;
+            self->once_write_buf_obj = self->loop2_write_buf_obj;
+            self->loop_write_buf_info = self->loop2_write_buf_info;
+            self->loop_write_buf_obj = self->loop2_write_buf_obj;
         } else {
-            if (!loop2_write_buf->info.len) {
+            if (!(self->loop2_write_buf_info.info.len)) {
                 // If once_write_buf and loop2_write_buf have zero length, write loop_write_buf forever
-                once_write_buf = loop_write_buf;
-                loop2_write_buf = loop_write_buf;
+                self->once_write_buf_info = self->loop_write_buf_info;
+                self->once_write_buf_obj = self->loop_write_buf_obj;
+                self->loop2_write_buf_info = self->loop_write_buf_info;
+                self->loop2_write_buf_obj = self->loop_write_buf_obj;
             } else {
                 // If only once_write_buf has zero length, write loop_write_buf, loop2_write_buf, and repeat last two forever
-                once_write_buf = loop_write_buf;
-                loop_write_buf = loop2_write_buf;
-                loop2_write_buf = once_write_buf;
+                self->once_write_buf_info = self->loop_write_buf_info;
+                self->once_write_buf_obj = self->loop_write_buf_obj;
+                self->loop_write_buf_info = self->loop2_write_buf_info;
+                self->loop_write_buf_obj = self->loop2_write_buf_obj;
+                self->loop2_write_buf_info = self->once_write_buf_info;
+                self->loop2_write_buf_obj = self->once_write_buf_obj;
             }
         }
     } else {
-        if (!loop_write_buf->info.len) {
+        if (!(self->loop_write_buf_info.info.len)) {
             // If once_write_buf has nonzero length and loop_write_buf has zero length, write once_write_buf, loop2_write_buf and repeat last buf forever
-            loop_write_buf = loop2_write_buf;
+            self->loop_write_buf_info = self->loop2_write_buf_info;
+            self->loop_write_buf_obj = self->loop2_write_buf_obj;
         } else {
-            if (!loop2_write_buf->info.len) {
+            if (!self->loop2_write_buf_info.info.len) {
                 // If once_write_buf has nonzero length and loop2_write_buf have zero length, write once_write_buf, loop_write_buf and repeat last buf forever
-                loop2_write_buf = loop_write_buf;
+                self->loop2_write_buf_info = self->loop_write_buf_info;
+                self->loop2_write_buf_obj = self->loop_write_buf_obj;
             }
         }
     }
@@ -1105,9 +1114,12 @@ bool common_hal_rp2pio_statemachine_background_write(rp2pio_statemachine_obj_t *
         }
 
         common_hal_mcu_disable_interrupts();
-        self->next_write_buf_1 = *once_write_buf;
-        self->next_write_buf_2 = *loop_write_buf;
-        self->next_write_buf_3 = *loop2_write_buf;
+        self->next_write_buf_1 = self->once_write_buf_info;
+        self->next_write_buf_1_obj = self->once_write_buf_obj;
+        self->next_write_buf_2 = self->loop_write_buf_info;
+        self->next_write_buf_2_obj = self->loop_write_buf_obj;
+        self->next_write_buf_3 = self->loop2_write_buf_info;
+        self->next_write_buf_3_obj = self->loop2_write_buf_obj;
         self->pending_buffers_write = pending_buffers_write;
 
         if (self->dma_completed_write && self->next_write_buf_1.info.len) {
@@ -1133,13 +1145,18 @@ bool common_hal_rp2pio_statemachine_background_write(rp2pio_statemachine_obj_t *
 
     dma_channel_config c_write;
 
-    self->current_write_buf = *once_write_buf;
-    self->next_write_buf_1 = *loop_write_buf;
-    self->next_write_buf_2 = *loop2_write_buf;
-    self->next_write_buf_3 = *loop_write_buf;
+    self->current_write_buf = self->once_write_buf_info;
+    self->current_write_buf_obj = self->once_write_buf_obj;
+    self->next_write_buf_1 = self->loop_write_buf_info;
+    self->next_write_buf_1_obj = self->loop_write_buf_obj;
+    self->next_write_buf_2 = self->loop2_write_buf_info;
+    self->next_write_buf_2_obj = self->loop2_write_buf_obj;
+    self->next_write_buf_3 = self->loop_write_buf_info;
+    self->next_write_buf_3_obj = self->loop_write_buf_obj;
 
     self->pending_buffers_write = pending_buffers_write;
     self->dma_completed_write = false;
+
     self->background_stride_in_bytes = stride_in_bytes;
     self->byteswap = swap;
 
@@ -1151,8 +1168,8 @@ bool common_hal_rp2pio_statemachine_background_write(rp2pio_statemachine_obj_t *
     channel_config_set_bswap(&c_write, swap);
     dma_channel_configure(channel_write, &c_write,
         tx_destination,
-        once_write_buf->info.buf,
-        once_write_buf->info.len / stride_in_bytes,
+        self->once_write_buf_info.info.buf,
+        self->once_write_buf_info.info.len / stride_in_bytes,
         false);
 
     common_hal_mcu_disable_interrupts();
@@ -1169,9 +1186,13 @@ bool common_hal_rp2pio_statemachine_background_write(rp2pio_statemachine_obj_t *
 
 void rp2pio_statemachine_dma_complete_write(rp2pio_statemachine_obj_t *self, int channel_write) {
     self->current_write_buf = self->next_write_buf_1;
+    self->current_write_buf_obj = self->next_write_buf_1_obj;
     self->next_write_buf_1 = self->next_write_buf_2;
+    self->next_write_buf_1_obj = self->next_write_buf_2_obj;
     self->next_write_buf_2 = self->next_write_buf_3;
+    self->next_write_buf_2_obj = self->next_write_buf_3_obj;
     self->next_write_buf_3 = self->next_write_buf_1;
+    self->next_write_buf_3_obj = self->next_write_buf_1_obj;
 
     if (self->current_write_buf.info.buf) {
         if (self->pending_buffers_write > 0) {
@@ -1183,6 +1204,8 @@ void rp2pio_statemachine_dma_complete_write(rp2pio_statemachine_obj_t *self, int
         self->dma_completed_write = true;
         self->pending_buffers_write = 0; // should be a no-op
     }
+
+    self->switched_write_buffers = true;
 }
 
 bool common_hal_rp2pio_statemachine_stop_background_write(rp2pio_statemachine_obj_t *self) {
@@ -1212,7 +1235,7 @@ bool common_hal_rp2pio_statemachine_background_read(rp2pio_statemachine_obj_t *s
     uint8_t pio_index = pio_get_index(self->pio);
     uint8_t sm = self->state_machine;
 
-    self->switched_buffers = false;
+    self->switched_read_buffers = false;
 
     int pending_buffers_read = (self->once_read_buf_info.info.len != 0) + (self->loop_read_buf_info.info.len != 0) + (self->loop2_read_buf_info.info.len != 0);
 
@@ -1316,6 +1339,9 @@ bool common_hal_rp2pio_statemachine_background_read(rp2pio_statemachine_obj_t *s
     self->pending_buffers_read = pending_buffers_read;
     self->dma_completed_read = false;
 
+    self->background_stride_in_bytes = stride_in_bytes;
+    self->byteswap = swap;
+
     c_read = dma_channel_get_default_config(channel_read);
     channel_config_set_transfer_data_size(&c_read, _stride_to_dma_size(stride_in_bytes));
     channel_config_set_dreq(&c_read, self->rx_dreq);
@@ -1362,7 +1388,7 @@ void rp2pio_statemachine_dma_complete_read(rp2pio_statemachine_obj_t *self, int
         self->pending_buffers_read = 0; // should be a no-op
     }
 
-    self->switched_buffers = true;
+    self->switched_read_buffers = true;
 }
 
 bool common_hal_rp2pio_statemachine_stop_background_read(rp2pio_statemachine_obj_t *self) {
@@ -1409,15 +1435,19 @@ mp_obj_t common_hal_rp2pio_statemachine_get_rxfifo(rp2pio_statemachine_obj_t *se
 }
 
 mp_obj_t common_hal_rp2pio_statemachine_get_last_read(rp2pio_statemachine_obj_t *self) {
-    if (self->switched_buffers) {
-        self->switched_buffers = false;
+    if (self->switched_read_buffers) {
+        self->switched_read_buffers = false;
         return self->next_read_buf_1_obj;
     }
     return mp_const_empty_bytes;
 }
 
 mp_obj_t common_hal_rp2pio_statemachine_get_last_write(rp2pio_statemachine_obj_t *self) {
-    return mp_const_none;
+    if (self->switched_write_buffers) {
+        self->switched_write_buffers = false;
+        return self->next_write_buf_1_obj;
+    }
+    return mp_const_empty_bytes;
 }
 
 

ports/raspberrypi/common-hal/rp2pio/StateMachine.h

@@ -67,7 +67,7 @@ typedef struct {
     mp_obj_t current_write_buf_obj, next_write_buf_1_obj, next_write_buf_2_obj, next_write_buf_3_obj;
     sm_buf_info current_write_buf, next_write_buf_1, next_write_buf_2, next_write_buf_3;
 
-    bool switched_buffers;
+    bool switched_write_buffers, switched_read_buffers;
 
     int background_stride_in_bytes;
     bool dma_completed_write, byteswap;