Merge remote-tracking branch 'origin/main' into main

Author: weblate

locale/circuitpython.pot

@@ -1042,10 +1042,6 @@ msgstr ""
 msgid "Group already used"
 msgstr ""
 
-#: shared-module/displayio/Group.c
-msgid "Group full"
-msgstr ""
-
 #: ports/mimxrt10xx/common-hal/busio/SPI.c ports/stm/common-hal/busio/I2C.c
 #: ports/stm/common-hal/busio/SPI.c ports/stm/common-hal/canio/CAN.c
 #: ports/stm/common-hal/sdioio/SDCard.c
@@ -1787,6 +1783,10 @@ msgid ""
 "constructor"
 msgstr ""
 
+#: ports/raspberrypi/common-hal/rotaryio/IncrementalEncoder.c
+msgid "Pins must be sequential"
+msgstr ""
+
 #: ports/raspberrypi/common-hal/audiopwmio/PWMAudioOut.c
 msgid "Pins must share PWM slice"
 msgstr ""
@@ -3743,6 +3743,10 @@ msgstr ""
 msgid "pressing both buttons at start up.\n"
 msgstr ""
 
+#: ports/raspberrypi/common-hal/rp2pio/StateMachine.c
+msgid "pull masks conflict with direction masks"
+msgstr ""
+
 #: ports/raspberrypi/bindings/rp2pio/StateMachine.c
 msgid "pull_threshold must be between 1 and 32"
 msgstr ""

ports/raspberrypi/bindings/rp2pio/StateMachine.c

@@ -69,6 +69,8 @@
 //|                  initial_out_pin_direction: int = 0xffffffff,
 //|                  first_in_pin: Optional[microcontroller.Pin] = None,
 //|                  in_pin_count: int = 1,
+//|                  pull_in_pin_up: int = 0,
+//|                  pull_in_pin_down: int = 0,
 //|                  first_set_pin: Optional[microcontroller.Pin] = None,
 //|                  set_pin_count: int = 1,
 //|                  initial_set_pin_state: int = 0,
@@ -99,6 +101,8 @@
 //|         :param int initial_out_pin_direction: the initial output direction for out pins starting at first_out_pin
 //|         :param ~microcontroller.Pin first_in_pin: the first pin to use with the IN instruction
 //|         :param int in_pin_count: the count of consecutive pins to use with IN starting at first_in_pin
+//|         :param int pull_in_pin_up: a 1-bit in this mask sets pull up on the corresponding in pin
+//|         :param int pull_in_pin_down: a 1-bit in this mask sets pull up on the corresponding in pin. Setting both pulls enables a "bus keep" function, i.e. a weak pull to whatever is current high/low state of GPIO.
 //|         :param ~microcontroller.Pin first_set_pin: the first pin to use with the SET instruction
 //|         :param int set_pin_count: the count of consecutive pins to use with SET starting at first_set_pin
 //|         :param int initial_set_pin_state: the initial output value for set pins starting at first_set_pin
@@ -133,6 +137,7 @@ STATIC mp_obj_t rp2pio_statemachine_make_new(const mp_obj_type_t *type, size_t n
     enum { ARG_program, ARG_frequency, ARG_init,
            ARG_first_out_pin, ARG_out_pin_count, ARG_initial_out_pin_state, ARG_initial_out_pin_direction,
            ARG_first_in_pin, ARG_in_pin_count,
+           ARG_pull_in_pin_up, ARG_pull_in_pin_down,
            ARG_first_set_pin, ARG_set_pin_count, ARG_initial_set_pin_state, ARG_initial_set_pin_direction,
            ARG_first_sideset_pin, ARG_sideset_pin_count, ARG_initial_sideset_pin_state, ARG_initial_sideset_pin_direction,
            ARG_exclusive_pin_use,
@@ -151,6 +156,8 @@ STATIC mp_obj_t rp2pio_statemachine_make_new(const mp_obj_type_t *type, size_t n
 
         { MP_QSTR_first_in_pin, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
         { MP_QSTR_in_pin_count, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 1} },
+        { MP_QSTR_pull_in_pin_up, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} },
+        { MP_QSTR_pull_in_pin_down, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} },
 
         { MP_QSTR_first_set_pin, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
         { MP_QSTR_set_pin_count, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 1} },
@@ -233,7 +240,7 @@ STATIC mp_obj_t rp2pio_statemachine_make_new(const mp_obj_type_t *type, size_t n
         args[ARG_frequency].u_int,
         init_bufinfo.buf, init_bufinfo.len / 2,
         first_out_pin, args[ARG_out_pin_count].u_int, args[ARG_initial_out_pin_state].u_int, args[ARG_initial_out_pin_direction].u_int,
-        first_in_pin, args[ARG_in_pin_count].u_int,
+        first_in_pin, args[ARG_in_pin_count].u_int, args[ARG_pull_in_pin_up].u_int, args[ARG_pull_in_pin_down].u_int,
         first_set_pin, args[ARG_set_pin_count].u_int, args[ARG_initial_set_pin_state].u_int, args[ARG_initial_set_pin_direction].u_int,
         first_sideset_pin, args[ARG_sideset_pin_count].u_int, args[ARG_initial_sideset_pin_state].u_int, args[ARG_initial_sideset_pin_direction].u_int,
         args[ARG_exclusive_pin_use].u_bool,
@@ -548,6 +555,24 @@ const mp_obj_property_t rp2pio_statemachine_rxstall_obj = {
               (mp_obj_t)&mp_const_none_obj},
 };
 
+//|     in_waiting: int
+//|     """The number of words available to readinto"""
+//|
+
+STATIC mp_obj_t rp2pio_statemachine_obj_get_in_waiting(mp_obj_t self_in) {
+    rp2pio_statemachine_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    check_for_deinit(self);
+    return MP_OBJ_NEW_SMALL_INT(common_hal_rp2pio_statemachine_get_in_waiting(self));
+}
+MP_DEFINE_CONST_FUN_OBJ_1(rp2pio_statemachine_get_in_waiting_obj, rp2pio_statemachine_obj_get_in_waiting);
+
+const mp_obj_property_t rp2pio_statemachine_in_waiting_obj = {
+    .base.type = &mp_type_property,
+    .proxy = {(mp_obj_t)&rp2pio_statemachine_get_in_waiting_obj,
+              (mp_obj_t)&mp_const_none_obj,
+              (mp_obj_t)&mp_const_none_obj},
+};
+
 STATIC const mp_rom_map_elem_t rp2pio_statemachine_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&rp2pio_statemachine_deinit_obj) },
     { MP_ROM_QSTR(MP_QSTR___enter__), MP_ROM_PTR(&default___enter___obj) },
@@ -563,7 +588,8 @@ STATIC const mp_rom_map_elem_t rp2pio_statemachine_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_write_readinto), MP_ROM_PTR(&rp2pio_statemachine_write_readinto_obj) },
 
     { MP_ROM_QSTR(MP_QSTR_frequency), MP_ROM_PTR(&rp2pio_statemachine_frequency_obj) },
-    { MP_ROM_QSTR(MP_QSTR_rxstall), MP_ROM_PTR(&rp2pio_statemachine_rxstall_obj) }
+    { MP_ROM_QSTR(MP_QSTR_rxstall), MP_ROM_PTR(&rp2pio_statemachine_rxstall_obj) },
+    { MP_ROM_QSTR(MP_QSTR_in_waiting), MP_ROM_PTR(&rp2pio_statemachine_in_waiting_obj) },
 };
 STATIC MP_DEFINE_CONST_DICT(rp2pio_statemachine_locals_dict, rp2pio_statemachine_locals_dict_table);
 

ports/raspberrypi/bindings/rp2pio/StateMachine.h

@@ -41,7 +41,7 @@ void common_hal_rp2pio_statemachine_construct(rp2pio_statemachine_obj_t *self,
     size_t frequency,
     const uint16_t* init, size_t init_len,
     const mcu_pin_obj_t * first_out_pin, uint8_t out_pin_count, uint32_t initial_out_pin_state, uint32_t initial_out_pin_direction,
-    const mcu_pin_obj_t * first_in_pin, uint8_t in_pin_count,
+    const mcu_pin_obj_t * first_in_pin, uint8_t in_pin_count, uint32_t pull_pin_up, uint32_t pull_pin_down,
     const mcu_pin_obj_t * first_set_pin, uint8_t set_pin_count, uint32_t initial_set_pin_state, uint32_t initial_set_pin_direction,
     const mcu_pin_obj_t * first_sideset_pin, uint8_t sideset_pin_count, uint32_t initial_sideset_pin_state, uint32_t initial_sideset_pin_direction,
     bool exclusive_pin_use,
@@ -69,5 +69,8 @@ void common_hal_rp2pio_statemachine_set_frequency(rp2pio_statemachine_obj_t* sel
 
 bool common_hal_rp2pio_statemachine_get_rxstall(rp2pio_statemachine_obj_t* self);
 void common_hal_rp2pio_statemachine_clear_rxfifo(rp2pio_statemachine_obj_t *self);
+size_t common_hal_rp2pio_statemachine_get_in_waiting(rp2pio_statemachine_obj_t *self);
+
+void common_hal_rp2pio_statemachine_set_interrupt_handler(rp2pio_statemachine_obj_t *self, void(*handler)(void*), void *arg, int mask);
 
 #endif // MICROPY_INCLUDED_RASPBERRYPI_BINDINGS_RP2PIO_STATEMACHINE_H

ports/raspberrypi/bindings/rp2pio/__init__.c

@@ -28,13 +28,28 @@
 #include "py/runtime.h"
 
 #include "bindings/rp2pio/StateMachine.h"
+#include "bindings/rp2pio/__init__.h"
 
 //| """Hardware interface to RP2 series' programmable IO (PIO) peripheral."""
 //|
 
+//| def pins_are_sequential(pins: List[microcontroller.Pin]) -> bool:
+//|     """Return True if the pins have sequential GPIO numbers, False otherwise"""
+//|     ...
+//|
+STATIC mp_obj_t rp2pio_pins_are_sequential(const mp_obj_t pins) {
+    size_t len;
+    mp_obj_t *items;
+    mp_obj_get_array(pins, &len, &items);
+    return mp_obj_new_bool(common_hal_rp2pio_pins_are_sequential(len, items));
+}
+
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(rp2pio_pins_are_sequential_obj, rp2pio_pins_are_sequential);
+
 STATIC const mp_rom_map_elem_t rp2pio_module_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_rp2pio) },
     { MP_ROM_QSTR(MP_QSTR_StateMachine),  MP_ROM_PTR(&rp2pio_statemachine_type) },
+    { MP_ROM_QSTR(MP_QSTR_pins_are_sequential),  MP_ROM_PTR(&rp2pio_pins_are_sequential_obj) },
 };
 
 STATIC MP_DEFINE_CONST_DICT(rp2pio_module_globals, rp2pio_module_globals_table);

ports/raspberrypi/bindings/rp2pio/__init__.h

@@ -0,0 +1,29 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2021 Jeff Epler for Adafruit Industries
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#pragma once
+
+bool common_hal_rp2pio_pins_are_sequential(size_t len, mp_obj_t *items);

ports/raspberrypi/common-hal/audiobusio/I2SOut.c

@@ -122,6 +122,7 @@ void common_hal_audiobusio_i2sout_construct(audiobusio_i2sout_obj_t* self,
         NULL, 0,
         data, 1, 0, 0xffffffff, // out pin
         NULL, 0, // in pins
+        0, 0, // in pulls
         NULL, 0, 0, 0x1f, // set pins
         bit_clock, 2, 0, 0x1f, // sideset pins
         true, // exclusive pin use

ports/raspberrypi/common-hal/audiobusio/PDMIn.c

@@ -68,6 +68,7 @@ void common_hal_audiobusio_pdmin_construct(audiobusio_pdmin_obj_t* self,
         NULL, 0,
         NULL, 1, 0, 0xffffffff, // out pin
         data_pin, 1, // in pins
+        0, 0, // in pulls
         NULL, 0, 0, 0x1f, // set pins
         clock_pin, 1, 0, 0x1f, // sideset pins
         true, // exclusive pin use
@@ -92,6 +93,7 @@ void common_hal_audiobusio_pdmin_deinit(audiobusio_pdmin_obj_t* self) {
     if (common_hal_audiobusio_pdmin_deinited(self)) {
         return;
     }
+    return common_hal_rp2pio_statemachine_deinit(&self->state_machine);
 }
 
 uint8_t common_hal_audiobusio_pdmin_get_bit_depth(audiobusio_pdmin_obj_t* self) {

ports/raspberrypi/common-hal/neopixel_write/__init__.c

@@ -67,6 +67,7 @@ void common_hal_neopixel_write(const digitalio_digitalinout_obj_t* digitalinout,
         NULL, 0, // init program
         NULL, 1, // out
         NULL, 1, // in
+        0, 0, // in pulls
         NULL, 1, // set
         digitalinout->pin, 1, // sideset
         0, pins_we_use, // initial pin state

ports/raspberrypi/common-hal/rotaryio/IncrementalEncoder.c

@@ -0,0 +1,170 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018 Scott Shawcroft for Adafruit Industries
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/runtime.h"
+
+#include <hardware/regs/pio.h>
+#include "common-hal/rotaryio/IncrementalEncoder.h"
+#include "bindings/rp2pio/__init__.h"
+#include "bindings/rp2pio/StateMachine.h"
+
+STATIC const uint16_t encoder[] = {
+    //  again:
+    //      in pins, 2
+    0x4002,
+    //      mov x, isr
+    0xa026,
+    //      jmp x!=y, push_data
+    0x00a5,
+    //      mov isr, null
+    0xa0c3,
+    //      jmp again
+    0x0000,
+    //  push_data:
+    //      push
+    0x8020,
+    //      mov y, x
+    0xa041,
+};
+
+STATIC const uint16_t encoder_init[] = {
+    //      set y, 31
+    0xe05f,
+};
+
+STATIC void incrementalencoder_interrupt_handler(void *self_in);
+
+void common_hal_rotaryio_incrementalencoder_construct(rotaryio_incrementalencoder_obj_t* self,
+    const mcu_pin_obj_t* pin_a, const mcu_pin_obj_t* pin_b) {
+    mp_obj_t pins[] = {MP_OBJ_FROM_PTR(pin_a), MP_OBJ_FROM_PTR(pin_b)};
+    if (!common_hal_rp2pio_pins_are_sequential(2, pins)) {
+        mp_raise_RuntimeError(translate("Pins must be sequential"));
+    }
+
+    self->position = 0;
+    self->quarter_count = 0;
+
+    common_hal_rp2pio_statemachine_construct(&self->state_machine,
+        encoder, MP_ARRAY_SIZE(encoder),
+        1000000,
+        encoder_init, MP_ARRAY_SIZE(encoder_init), // init
+        NULL, 1, 0, 0xffffffff, // out pin
+        pin_a, 2, // in pins
+        3, 0, // in pulls
+        NULL, 0, 0, 0x1f, // set pins
+        NULL, 0, 0, 0x1f, // sideset pins
+        true, // exclusive pin use
+        false, 32, false, // out settings
+        false, // Wait for txstall
+        false, 32, false); // in settings
+
+    common_hal_rp2pio_statemachine_run(&self->state_machine, encoder_init, MP_ARRAY_SIZE(encoder_init));
+
+    // We're guaranteed by the init code that some output will be available promptly
+    uint8_t state;
+    common_hal_rp2pio_statemachine_readinto(&self->state_machine, &state, 1, 1);
+    // Top two bits of self->last_state don't matter, because they'll be gone as soon as
+    // interrupt handler is called.
+    self->last_state = state & 3;
+
+    common_hal_rp2pio_statemachine_set_interrupt_handler(&self->state_machine, incrementalencoder_interrupt_handler, self, PIO_IRQ0_INTF_SM0_RXNEMPTY_BITS);
+}
+
+bool common_hal_rotaryio_incrementalencoder_deinited(rotaryio_incrementalencoder_obj_t* self) {
+    return common_hal_rp2pio_statemachine_deinited(&self->state_machine);
+}
+
+void common_hal_rotaryio_incrementalencoder_deinit(rotaryio_incrementalencoder_obj_t* self) {
+    if (common_hal_rotaryio_incrementalencoder_deinited(self)) {
+        return;
+    }
+    common_hal_rp2pio_statemachine_deinit(&self->state_machine);
+}
+
+mp_int_t common_hal_rotaryio_incrementalencoder_get_position(rotaryio_incrementalencoder_obj_t* self) {
+    return self->position;
+}
+
+void common_hal_rotaryio_incrementalencoder_set_position(rotaryio_incrementalencoder_obj_t* self,
+        mp_int_t new_position) {
+    self->position = new_position;
+}
+
+STATIC void incrementalencoder_interrupt_handler(void *self_in) {
+    rotaryio_incrementalencoder_obj_t* self = self_in;
+    // This table also works for detent both at 11 and 00
+    // For 11 at detent:
+    // Turning cw: 11->01->00->10->11
+    // Turning ccw: 11->10->00->01->11
+    // For 00 at detent:
+    // Turning cw: 00->10->11->10->00
+    // Turning ccw: 00->01->11->10->00
+
+    // index table by state <oldA><oldB><newA><newB>
+    #define BAD 7
+    static const int8_t transitions[16] = {
+        0,    // 00 -> 00 no movement
+        -1,   // 00 -> 01 3/4 ccw (11 detent) or 1/4 ccw (00 at detent)
+        +1,   // 00 -> 10 3/4 cw or 1/4 cw
+        BAD,  // 00 -> 11 non-Gray-code transition
+        +1,   // 01 -> 00 2/4 or 4/4 cw
+        0,    // 01 -> 01 no movement
+        BAD,  // 01 -> 10 non-Gray-code transition
+        -1,   // 01 -> 11 4/4 or 2/4 ccw
+        -1,   // 10 -> 00 2/4 or 4/4 ccw
+        BAD,  // 10 -> 01 non-Gray-code transition
+        0,    // 10 -> 10 no movement
+        +1,   // 10 -> 11 4/4 or 2/4 cw
+        BAD,  // 11 -> 00 non-Gray-code transition
+        +1,   // 11 -> 01 1/4 or 3/4 cw
+        -1,   // 11 -> 10 1/4 or 3/4 ccw
+        0,    // 11 -> 11 no movement
+    };
+
+    while (common_hal_rp2pio_statemachine_get_in_waiting(&self->state_machine)) {
+        // Bypass all the logic of StateMachine.c:_transfer, we need something
+        // very simple and fast for an interrupt!
+        uint8_t new = self->state_machine.pio->rxf[self->state_machine.state_machine];
+
+        // Shift the old AB bits to the "old" position, and set the new AB bits.
+        self->last_state = (self->last_state & 0x3) << 2 | (new & 0x3);
+
+        int8_t quarter_incr = transitions[self->last_state];
+        if (quarter_incr == BAD) {
+            // Missed a transition. We don't know which way we're going, so do nothing.
+            return;
+        }
+
+        self->quarter_count += quarter_incr;
+        if (self->quarter_count >= 4) {
+            self->position += 1;
+            self->quarter_count = 0;
+        } else if (self->quarter_count <= -4) {
+            self->position -= 1;
+            self->quarter_count = 0;
+        }
+    }
+}