Merge branch 'main' into esp32s2-bssid

.github/workflows/build.yml

@@ -416,6 +416,7 @@ jobs:
         - "espressif_saola_1_wroom"
         - "espressif_saola_1_wrover"
         - "microdev_micro_s2"
+        - "muselab_nanoesp32_s2"
         - "unexpectedmaker_feathers2"
 
     steps:

locale/circuitpython.pot

@@ -430,7 +430,7 @@ msgstr ""
 msgid "Buffer is not a bytearray."
 msgstr ""
 
-#: shared-bindings/displayio/Display.c
+#: ports/cxd56/common-hal/camera/Camera.c shared-bindings/displayio/Display.c
 #: shared-bindings/framebufferio/FramebufferDisplay.c
 msgid "Buffer is too small"
 msgstr ""
@@ -615,6 +615,10 @@ msgstr ""
 msgid "Corrupt raw code"
 msgstr ""
 
+#: ports/cxd56/common-hal/camera/Camera.c
+msgid "Could not initialize Camera"
+msgstr ""
+
 #: ports/cxd56/common-hal/gnss/GNSS.c
 msgid "Could not initialize GNSS"
 msgstr ""
@@ -841,6 +845,10 @@ msgstr ""
 msgid "File exists"
 msgstr ""
 
+#: ports/cxd56/common-hal/camera/Camera.c
+msgid "Format not supported"
+msgstr ""
+
 #: shared-module/framebufferio/FramebufferDisplay.c
 #, c-format
 msgid "Framebuffer requires %d bytes"
@@ -905,6 +913,10 @@ msgstr ""
 msgid "Incorrect buffer size"
 msgstr ""
 
+#: ports/atmel-samd/common-hal/pulseio/PulseIn.c
+msgid "Input taking too long"
+msgstr ""
+
 #: py/moduerrno.c
 msgid "Input/output error"
 msgstr ""
@@ -1503,6 +1515,10 @@ msgstr ""
 msgid "Server side context cannot have hostname"
 msgstr ""
 
+#: ports/cxd56/common-hal/camera/Camera.c
+msgid "Size not supported"
+msgstr ""
+
 #: shared-bindings/nvm/ByteArray.c
 msgid "Slice and value different lengths."
 msgstr ""

ports/atmel-samd/common-hal/pulseio/PulseIn.c

@@ -44,12 +44,14 @@
 #include "shared-bindings/pulseio/PulseIn.h"
 #include "supervisor/shared/tick.h"
 #include "supervisor/shared/translate.h"
+#include "supervisor/port.h"
 
 // This timer is shared amongst all PulseIn objects as a higher resolution clock.
 static uint8_t refcount = 0;
 static uint8_t pulsein_tc_index = 0xff;
 
 volatile static uint32_t overflow_count = 0;
+volatile static uint32_t start_overflow = 0;
 
 void pulsein_timer_interrupt_handler(uint8_t index) {
     if (index != pulsein_tc_index) return;
@@ -77,6 +79,8 @@ static void pulsein_set_config(pulseio_pulsein_obj_t* self, bool first_edge) {
 }
 
 void pulsein_interrupt_handler(uint8_t channel) {
+    // Turn off interrupts while in handler
+    common_hal_mcu_disable_interrupts();
     // Grab the current time first.
     uint32_t current_overflow = overflow_count;
     Tc* tc = tc_insts[pulsein_tc_index];
@@ -88,10 +92,8 @@ void pulsein_interrupt_handler(uint8_t channel) {
     uint32_t current_count = tc->COUNT16.COUNT.reg;
 
     pulseio_pulsein_obj_t* self = get_eic_channel_data(channel);
-    if (!supervisor_background_tasks_ok() || self->errored_too_fast) {
+    if (self->len == 0 ) {
-        self->errored_too_fast = true;
+        start_overflow = overflow_count;
-        common_hal_pulseio_pulsein_pause(self);
-        return;
     }
     if (self->first_edge) {
         self->first_edge = false;
@@ -112,6 +114,13 @@ void pulsein_interrupt_handler(uint8_t channel) {
         if (total_diff < duration) {
             duration = total_diff;
         }
+        //check if the input is taking too long, 15 timer overflows is approx 1 second
+        if (current_overflow - start_overflow > 15) {
+            self->errored_too_fast = true;
+            common_hal_pulseio_pulsein_pause(self);
+            common_hal_mcu_enable_interrupts();
+            return;
+        }
 
         uint16_t i = (self->start + self->len) % self->maxlen;
         self->buffer[i] = duration;
@@ -123,6 +132,7 @@ void pulsein_interrupt_handler(uint8_t channel) {
     }
     self->last_overflow = current_overflow;
     self->last_count = current_count;
+    common_hal_mcu_enable_interrupts();
 }
 
 void pulsein_reset() {
@@ -264,9 +274,6 @@ void common_hal_pulseio_pulsein_resume(pulseio_pulsein_obj_t* self,
     // Make sure we're paused.
     common_hal_pulseio_pulsein_pause(self);
 
-    // Reset erroring
-    self->errored_too_fast = false;
-
     // Send the trigger pulse.
     if (trigger_duration > 0) {
         gpio_set_pin_pull_mode(self->pin, GPIO_PULL_OFF);
@@ -280,6 +287,7 @@ void common_hal_pulseio_pulsein_resume(pulseio_pulsein_obj_t* self,
     self->first_edge = true;
     self->last_overflow = 0;
     self->last_count = 0;
+    self->errored_too_fast = false;
     gpio_set_pin_function(self->pin, GPIO_PIN_FUNCTION_A);
     uint32_t mask = 1 << self->channel;
     // Clear previous interrupt state and re-enable it.
@@ -300,12 +308,15 @@ uint16_t common_hal_pulseio_pulsein_popleft(pulseio_pulsein_obj_t* self) {
     if (self->len == 0) {
         mp_raise_IndexError_varg(translate("pop from empty %q"), MP_QSTR_PulseIn);
     }
+    if (self->errored_too_fast) {
+      self->errored_too_fast = 0;
+      mp_raise_RuntimeError(translate("Input taking too long"));
+    }
     common_hal_mcu_disable_interrupts();
     uint16_t value = self->buffer[self->start];
     self->start = (self->start + 1) % self->maxlen;
     self->len--;
     common_hal_mcu_enable_interrupts();
-
     return value;
 }
 

ports/cxd56/Makefile

@@ -201,7 +201,7 @@ all: $(BUILD)/firmware.spk
 $(FIRMWARE):
 	$(ECHO) ""
 	$(ECHO) "Download the spresense binaries zip archive from:"
-	$(ECHO) "https://developer.sony.com/file/download/download-spresense-firmware-v1-4-000"
+	$(ECHO) "https://developer.sony.com/file/download/download-spresense-firmware-v2-0-000"
 	$(ECHO) "Extract spresense binaries to $(FIRMWARE)"
 	$(ECHO) ""
 	$(ECHO) "run make flash-bootloader again to flash bootloader."

ports/cxd56/common-hal/camera/Camera.c

@@ -0,0 +1,183 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright 2020 Sony Semiconductor Solutions Corporation
+ *
+ * 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 <string.h>
+#include <fcntl.h>
+
+#include <arch/board/board.h>
+#include <nuttx/video/video.h>
+#include <nuttx/arch.h>
+
+#include "py/runtime.h"
+
+#include "shared-bindings/camera/Camera.h"
+
+typedef struct {
+    const char* devpath;
+    int fd;
+} camera_dev_t;
+
+STATIC camera_dev_t camera_dev = {"/dev/video", -1};
+
+typedef struct {
+    uint16_t width;
+    uint16_t height;
+} image_size_t;
+
+STATIC const image_size_t image_size_table[] = {
+    { VIDEO_HSIZE_QVGA, VIDEO_VSIZE_QVGA },
+    { VIDEO_HSIZE_VGA, VIDEO_VSIZE_VGA },
+    { VIDEO_HSIZE_HD, VIDEO_VSIZE_HD },
+    { VIDEO_HSIZE_QUADVGA, VIDEO_VSIZE_QUADVGA },
+    { VIDEO_HSIZE_FULLHD, VIDEO_VSIZE_FULLHD },
+    { VIDEO_HSIZE_3M, VIDEO_VSIZE_3M },
+    { VIDEO_HSIZE_5M, VIDEO_VSIZE_5M },
+};
+
+static bool camera_check_width_and_height(uint16_t width, uint16_t height) {
+    for (int i = 0; i < MP_ARRAY_SIZE(image_size_table); i++) {
+        if (image_size_table[i].width == width && image_size_table[i].height == height) {
+            return true;
+        }
+    }
+    return false;
+}
+
+static bool camera_check_buffer_length(uint16_t width, uint16_t height, camera_imageformat_t format, size_t length) {
+    if (format == IMAGEFORMAT_JPG) {
+        // In SPRESENSE SDK, JPEG compression quality=80 by default.
+        // In such setting, the maximum actual measured size of JPEG image
+        // is about width * height * 2 / 9.
+        return length >= (size_t)(width * height * 2 / 9);
+    } else {
+        return false;
+    }
+}
+
+static bool camera_check_format(camera_imageformat_t format) {
+    return format == IMAGEFORMAT_JPG;
+}
+
+static void camera_set_format(enum v4l2_buf_type type, uint32_t pixformat, uint16_t width, uint16_t height) {
+    v4l2_requestbuffers_t req = {0};
+
+    // Set Buffer Mode.
+    req.type = type;
+    req.memory = V4L2_MEMORY_USERPTR;
+    req.count = 1;
+    req.mode = V4L2_BUF_MODE_RING;
+    ioctl(camera_dev.fd, VIDIOC_REQBUFS, (unsigned long)&req);
+    v4l2_format_t fmt = {0};
+
+    // Set Format.
+    fmt.type = type;
+    fmt.fmt.pix.width = width;
+    fmt.fmt.pix.height = height;
+    fmt.fmt.pix.field = V4L2_FIELD_ANY;
+    fmt.fmt.pix.pixelformat = pixformat;
+    ioctl(camera_dev.fd, VIDIOC_S_FMT, (unsigned long)&fmt);
+}
+
+static void camera_start_streaming(enum v4l2_buf_type type) {
+    ioctl(camera_dev.fd, VIDIOC_STREAMON, (unsigned long)&type);
+}
+
+static void camera_start_preview() {
+    camera_set_format(V4L2_BUF_TYPE_VIDEO_CAPTURE, V4L2_PIX_FMT_UYVY, VIDEO_HSIZE_QVGA, VIDEO_VSIZE_QVGA);
+
+    v4l2_buffer_t buf;
+
+    memset(&buf, 0, sizeof(v4l2_buffer_t));
+    buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+    buf.memory = V4L2_MEMORY_USERPTR;
+    ioctl(camera_dev.fd, VIDIOC_QBUF, (unsigned long)&buf);
+
+    camera_start_streaming(V4L2_BUF_TYPE_VIDEO_CAPTURE);
+}
+
+void common_hal_camera_construct(camera_obj_t *self) {
+    if (camera_dev.fd < 0) {
+        if (video_initialize(camera_dev.devpath) < 0) {
+            mp_raise_ValueError(translate("Could not initialize Camera"));
+        }
+        camera_dev.fd = open(camera_dev.devpath, 0);
+        if (camera_dev.fd < 0) {
+            mp_raise_ValueError(translate("Could not initialize Camera"));
+        }
+    }
+
+    camera_start_preview();
+
+    camera_start_streaming(V4L2_BUF_TYPE_STILL_CAPTURE);
+
+    sleep(1);
+}
+
+void common_hal_camera_deinit(camera_obj_t *self) {
+    if (common_hal_camera_deinited(self)) {
+        return;
+    }
+
+    video_uninitialize();
+
+    close(camera_dev.fd);
+    camera_dev.fd = -1;
+}
+
+bool common_hal_camera_deinited(camera_obj_t *self) {
+    return camera_dev.fd < 0;
+}
+
+size_t common_hal_camera_take_picture(camera_obj_t *self, uint8_t *buffer, size_t len, uint16_t width, uint16_t height, camera_imageformat_t format) {
+    if (!camera_check_width_and_height(width, height)) {
+        mp_raise_ValueError(translate("Size not supported"));
+    }
+    if (!camera_check_buffer_length(width, height, format, len)) {
+        mp_raise_ValueError(translate("Buffer is too small"));
+    }
+    if (!camera_check_format(format)) {
+        mp_raise_ValueError(translate("Format not supported"));
+    }
+
+    camera_set_format(V4L2_BUF_TYPE_STILL_CAPTURE, V4L2_PIX_FMT_JPEG, width, height);
+
+    v4l2_buffer_t buf;
+
+    memset(&buf, 0, sizeof(v4l2_buffer_t));
+    buf.type = V4L2_BUF_TYPE_STILL_CAPTURE;
+    buf.memory = V4L2_MEMORY_USERPTR;
+    buf.m.userptr = (unsigned long)buffer;
+    buf.length = len;
+    ioctl(camera_dev.fd, VIDIOC_QBUF, (unsigned long)&buf);
+
+    ioctl(camera_dev.fd, VIDIOC_TAKEPICT_START, 0);
+
+    ioctl(camera_dev.fd, VIDIOC_DQBUF, (unsigned long)&buf);
+
+    ioctl(camera_dev.fd, VIDIOC_TAKEPICT_STOP, false);
+
+    return (size_t)buf.bytesused;
+}

ports/cxd56/common-hal/camera/Camera.h

@@ -0,0 +1,36 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright 2020 Sony Semiconductor Solutions Corporation
+ *
+ * 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.
+ */
+
+#ifndef MICROPY_INCLUDED_CXD56_COMMON_HAL_CAMERA_CAMERA_H
+#define MICROPY_INCLUDED_CXD56_COMMON_HAL_CAMERA_CAMERA_H
+
+#include "py/obj.h"
+
+typedef struct {
+    mp_obj_base_t base;
+} camera_obj_t;
+
+#endif // MICROPY_INCLUDED_CXD56_COMMON_HAL_CAMERA_CAMERA_H

ports/cxd56/common-hal/camera/__init__.c

@@ -0,0 +1 @@
+// No camera module functions.

ports/cxd56/configs/circuitpython/defconfig

@@ -165,7 +165,6 @@ CONFIG_USBDEV=y
 CONFIG_USBDEV_DMA=y
 CONFIG_USBDEV_DUALSPEED=y
 CONFIG_USEC_PER_TICK=1000
-CONFIG_USERMAIN_STACKSIZE=1064960
 CONFIG_USER_ENTRYPOINT="spresense_main"
 CONFIG_VIDEO_ISX012=y
 CONFIG_VIDEO_STREAM=y

ports/cxd56/mpconfigport.h

@@ -30,10 +30,12 @@
 #define MICROPY_PY_SYS_PLATFORM                 "CXD56"
 
 // 64kiB stack
-#define CIRCUITPY_DEFAULT_STACK_SIZE            0x10000
+#define CIRCUITPY_DEFAULT_STACK_SIZE            (0x10000)
 
 #include "py/circuitpy_mpconfig.h"
 
+#define MICROPY_BYTES_PER_GC_BLOCK              (32)
+
 #define MICROPY_PORT_ROOT_POINTERS \
     CIRCUITPY_COMMON_ROOT_POINTERS \
 

ports/cxd56/mpconfigport.mk

@@ -11,6 +11,7 @@ MPY_TOOL_LONGINT_IMPL = -mlongint-impl=mpz
 
 CIRCUITPY_AUDIOBUSIO = 0
 CIRCUITPY_AUDIOIO = 0
+CIRCUITPY_CAMERA = 1
 CIRCUITPY_COUNTIO = 0
 CIRCUITPY_DISPLAYIO = 0
 CIRCUITPY_FREQUENCYIO = 0

ports/cxd56/spresense-exported-sdk

@@ -1 +1 @@
-Subproject commit c991d439fac9c23cfcac0da16fe8055f818d40a4
+Subproject commit 752c4cd56dd0a270a559c28272ceb61ddcb7806c

ports/cxd56/supervisor/port.c

@@ -46,12 +46,22 @@
 #include "common-hal/pwmio/PWMOut.h"
 #include "common-hal/busio/UART.h"
 
+#define SPRESENSE_MEM_ALIGN (32)
+
+uint32_t* heap;
+uint32_t heap_size;
+
 safe_mode_t port_init(void) {
     boardctl(BOARDIOC_INIT, 0);
 
     // Wait until RTC is available
     while (g_rtc_enabled == false);
 
+    heap = memalign(SPRESENSE_MEM_ALIGN, 128 * 1024);
+    uint32_t size = CONFIG_RAM_START + CONFIG_RAM_SIZE - (uint32_t)heap - 2 * SPRESENSE_MEM_ALIGN;
+    heap = realloc(heap, size);
+    heap_size = size / sizeof(uint32_t);
+
     if (board_requests_safe_mode()) {
         return USER_SAFE_MODE;
     }
@@ -100,11 +110,11 @@ uint32_t *port_stack_get_top(void) {
 }
 
 uint32_t *port_heap_get_bottom(void) {
-    return port_stack_get_limit();
+    return heap;
 }
 
 uint32_t *port_heap_get_top(void) {
-    return port_stack_get_top();
+    return heap + heap_size;
 }
 
 extern uint32_t _ebss;

ports/esp32s2/boards/muselab_nanoesp32_s2/board.c

@@ -0,0 +1,47 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 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 "boards/board.h"
+#include "mpconfigboard.h"
+#include "shared-bindings/microcontroller/Pin.h"
+
+void board_init(void) {
+    // USB
+    common_hal_never_reset_pin(&pin_GPIO19);
+    common_hal_never_reset_pin(&pin_GPIO20);
+
+    // Debug UART
+    common_hal_never_reset_pin(&pin_GPIO43);
+    common_hal_never_reset_pin(&pin_GPIO44);
+}
+
+bool board_requests_safe_mode(void) {
+    return false;
+}
+
+void reset_board(void) {
+
+}

ports/esp32s2/boards/muselab_nanoesp32_s2/mpconfigboard.h

@@ -0,0 +1,34 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 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.
+ */
+
+//Micropython setup
+
+#define MICROPY_HW_BOARD_NAME       "nanoESP32-S2"
+#define MICROPY_HW_MCU_NAME         "ESP32S2"
+
+#define MICROPY_HW_NEOPIXEL (&pin_GPIO18)
+
+#define AUTORESET_DELAY_MS 500

ports/esp32s2/boards/muselab_nanoesp32_s2/mpconfigboard.mk

@@ -0,0 +1,17 @@
+USB_VID = 0x239A
+USB_PID = 0x80DE
+USB_PRODUCT = "nanoESP32-S2"
+USB_MANUFACTURER = "Muselab"
+
+INTERNAL_FLASH_FILESYSTEM = 1
+LONGINT_IMPL = MPZ
+
+# The default queue depth of 16 overflows on release builds,
+# so increase it to 32.
+CFLAGS += -DCFG_TUD_TASK_QUEUE_SZ=32
+
+CIRCUITPY_ESP_FLASH_MODE=dio
+CIRCUITPY_ESP_FLASH_FREQ=40m
+CIRCUITPY_ESP_FLASH_SIZE=4MB
+
+CIRCUITPY_MODULE=wroom

ports/esp32s2/boards/muselab_nanoesp32_s2/pins.c

@@ -0,0 +1,48 @@
+#include "shared-bindings/board/__init__.h"
+
+STATIC const mp_rom_map_elem_t board_global_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR_IO0), MP_ROM_PTR(&pin_GPIO0) },
+    { MP_ROM_QSTR(MP_QSTR_IO1), MP_ROM_PTR(&pin_GPIO1) },
+    { MP_ROM_QSTR(MP_QSTR_IO2), MP_ROM_PTR(&pin_GPIO2) },
+    { MP_ROM_QSTR(MP_QSTR_IO3), MP_ROM_PTR(&pin_GPIO3) },
+    { MP_ROM_QSTR(MP_QSTR_IO4), MP_ROM_PTR(&pin_GPIO4) },
+    { MP_ROM_QSTR(MP_QSTR_IO5), MP_ROM_PTR(&pin_GPIO5) },
+    { MP_ROM_QSTR(MP_QSTR_IO6), MP_ROM_PTR(&pin_GPIO6) },
+    { MP_ROM_QSTR(MP_QSTR_IO7), MP_ROM_PTR(&pin_GPIO7) },
+    { MP_ROM_QSTR(MP_QSTR_IO8), MP_ROM_PTR(&pin_GPIO8) },
+    { MP_ROM_QSTR(MP_QSTR_IO9), MP_ROM_PTR(&pin_GPIO9) },
+    { MP_ROM_QSTR(MP_QSTR_IO10), MP_ROM_PTR(&pin_GPIO10) },
+    { MP_ROM_QSTR(MP_QSTR_IO11), MP_ROM_PTR(&pin_GPIO11) },
+    { MP_ROM_QSTR(MP_QSTR_IO12), MP_ROM_PTR(&pin_GPIO12) },
+    { MP_ROM_QSTR(MP_QSTR_IO13), MP_ROM_PTR(&pin_GPIO13) },
+    { MP_ROM_QSTR(MP_QSTR_IO14), MP_ROM_PTR(&pin_GPIO14) },
+    { MP_ROM_QSTR(MP_QSTR_IO15), MP_ROM_PTR(&pin_GPIO15) },
+    { MP_ROM_QSTR(MP_QSTR_IO16), MP_ROM_PTR(&pin_GPIO16) },
+    { MP_ROM_QSTR(MP_QSTR_IO17), MP_ROM_PTR(&pin_GPIO17) },
+
+
+    { MP_ROM_QSTR(MP_QSTR_IO18), MP_ROM_PTR(&pin_GPIO18) },
+    { MP_ROM_QSTR(MP_QSTR_IO19), MP_ROM_PTR(&pin_GPIO19) },
+    { MP_ROM_QSTR(MP_QSTR_IO20), MP_ROM_PTR(&pin_GPIO20) },
+    { MP_ROM_QSTR(MP_QSTR_IO21), MP_ROM_PTR(&pin_GPIO21) },
+    { MP_ROM_QSTR(MP_QSTR_IO26), MP_ROM_PTR(&pin_GPIO26) },
+    { MP_ROM_QSTR(MP_QSTR_IO33), MP_ROM_PTR(&pin_GPIO33) },
+    { MP_ROM_QSTR(MP_QSTR_IO34), MP_ROM_PTR(&pin_GPIO34) },
+    { MP_ROM_QSTR(MP_QSTR_IO35), MP_ROM_PTR(&pin_GPIO35) },
+    { MP_ROM_QSTR(MP_QSTR_IO36), MP_ROM_PTR(&pin_GPIO36) },
+    { MP_ROM_QSTR(MP_QSTR_IO37), MP_ROM_PTR(&pin_GPIO37) },
+    { MP_ROM_QSTR(MP_QSTR_IO38), MP_ROM_PTR(&pin_GPIO38) },
+    { MP_ROM_QSTR(MP_QSTR_IO39), MP_ROM_PTR(&pin_GPIO39) },
+    { MP_ROM_QSTR(MP_QSTR_IO40), MP_ROM_PTR(&pin_GPIO40) },
+    { MP_ROM_QSTR(MP_QSTR_IO41), MP_ROM_PTR(&pin_GPIO41) },
+    { MP_ROM_QSTR(MP_QSTR_IO42), MP_ROM_PTR(&pin_GPIO42) },
+    { MP_ROM_QSTR(MP_QSTR_TX), MP_ROM_PTR(&pin_GPIO43) },
+    { MP_ROM_QSTR(MP_QSTR_IO43), MP_ROM_PTR(&pin_GPIO43) },
+    { MP_ROM_QSTR(MP_QSTR_RX), MP_ROM_PTR(&pin_GPIO44) },
+    { MP_ROM_QSTR(MP_QSTR_IO44), MP_ROM_PTR(&pin_GPIO44) },
+    { MP_ROM_QSTR(MP_QSTR_IO45), MP_ROM_PTR(&pin_GPIO45) },
+    { MP_ROM_QSTR(MP_QSTR_IO46), MP_ROM_PTR(&pin_GPIO46) },
+
+    { MP_ROM_QSTR(MP_QSTR_NEOPIXEL), MP_ROM_PTR(&pin_GPIO18) },
+};
+MP_DEFINE_CONST_DICT(board_module_globals, board_global_dict_table);

ports/esp32s2/common-hal/rtc/RTC.c

@@ -0,0 +1,52 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright 2019 Sony Semiconductor Solutions Corporation
+ *
+ * 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 <sys/time.h>
+
+#include "py/obj.h"
+#include "py/runtime.h"
+#include "soc/rtc_periph.h"
+#include "shared-bindings/rtc/RTC.h"
+
+void common_hal_rtc_get_time(timeutils_struct_time_t *tm) {
+    struct timeval tv_now;
+    gettimeofday(&tv_now, NULL);
+    timeutils_seconds_since_2000_to_struct_time(tv_now.tv_sec, tm);
+}
+
+void common_hal_rtc_set_time(timeutils_struct_time_t *tm) {
+    struct timeval tv_now = {0};
+    tv_now.tv_sec = timeutils_seconds_since_2000(tm->tm_year, tm->tm_mon, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec);
+    settimeofday(&tv_now, NULL);
+}
+
+int common_hal_rtc_get_calibration(void) {
+    return 0;
+}
+
+void common_hal_rtc_set_calibration(int calibration) {
+    mp_raise_NotImplementedError(translate("RTC calibration is not supported on this board"));
+}

ports/esp32s2/common-hal/rtc/RTC.h

@@ -0,0 +1,34 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018 Noralf Trønnes
+ *
+ * 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.
+ */
+
+#ifndef MICROPY_INCLUDED_NRF_COMMON_HAL_RTC_RTC_H
+#define MICROPY_INCLUDED_NRF_COMMON_HAL_RTC_RTC_H
+
+extern void rtc_init(void);
+extern void rtc_reset(void);
+extern void common_hal_rtc_init(void);
+
+#endif  // MICROPY_INCLUDED_NRF_COMMON_HAL_RTC_RTC_H

ports/esp32s2/mpconfigport.mk

@@ -21,7 +21,6 @@ CIRCUITPY_COUNTIO = 0
 CIRCUITPY_FREQUENCYIO = 0
 CIRCUITPY_I2CPERIPHERAL = 0
 CIRCUITPY_ROTARYIO = 0
-CIRCUITPY_RTC = 0
 CIRCUITPY_NVM = 0
 # We don't have enough endpoints to include MIDI.
 CIRCUITPY_USB_MIDI = 0

py/circuitpy_defns.mk

@@ -139,6 +139,9 @@ endif
 ifeq ($(CIRCUITPY_BUSIO),1)
 SRC_PATTERNS += busio/% bitbangio/OneWire.%
 endif
+ifeq ($(CIRCUITPY_CAMERA),1)
+SRC_PATTERNS += camera/%
+endif
 ifeq ($(CIRCUITPY_COUNTIO),1)
 SRC_PATTERNS += countio/%
 endif
@@ -310,6 +313,8 @@ SRC_COMMON_HAL_ALL = \
 	busio/SPI.c \
 	busio/UART.c \
 	busio/__init__.c \
+	camera/__init__.c \
+	camera/Camera.c \
 	countio/Counter.c \
 	countio/__init__.c \
 	digitalio/DigitalInOut.c \
@@ -380,6 +385,7 @@ $(filter $(SRC_PATTERNS), \
 	_bleio/Attribute.c \
 	_bleio/ScanEntry.c \
 	_eve/__init__.c \
+	camera/ImageFormat.c \
 	digitalio/Direction.c \
 	digitalio/DriveMode.c \
 	digitalio/Pull.c \

py/circuitpy_mpconfig.h

@@ -329,6 +329,13 @@ extern const struct _mp_obj_module_t busio_module;
 #define BUSIO_MODULE
 #endif
 
+#if CIRCUITPY_CAMERA
+extern const struct _mp_obj_module_t camera_module;
+#define CAMERA_MODULE        { MP_OBJ_NEW_QSTR(MP_QSTR_camera), (mp_obj_t)&camera_module },
+#else
+#define CAMERA_MODULE
+#endif
+
 #if CIRCUITPY_COUNTIO
 extern const struct _mp_obj_module_t countio_module;
 #define COUNTIO_MODULE        { MP_OBJ_NEW_QSTR(MP_QSTR_countio), (mp_obj_t)&countio_module },
@@ -758,6 +765,7 @@ extern const struct _mp_obj_module_t wifi_module;
     BLEIO_MODULE \
     BOARD_MODULE \
     BUSIO_MODULE \
+    CAMERA_MODULE \
     COUNTIO_MODULE \
     DIGITALIO_MODULE \
     DISPLAYIO_MODULE \

py/circuitpy_mpconfig.mk

@@ -90,6 +90,9 @@ CFLAGS += -DCIRCUITPY_BOARD=$(CIRCUITPY_BOARD)
 CIRCUITPY_BUSIO ?= 1
 CFLAGS += -DCIRCUITPY_BUSIO=$(CIRCUITPY_BUSIO)
 
+CIRCUITPY_CAMERA ?= 0
+CFLAGS += -DCIRCUITPY_CAMERA=$(CIRCUITPY_CAMERA)
+
 CIRCUITPY_DIGITALIO ?= 1
 CFLAGS += -DCIRCUITPY_DIGITALIO=$(CIRCUITPY_DIGITALIO)
 

py/makeqstrdata.py

@@ -12,10 +12,14 @@ from __future__ import print_function
 import re
 import sys
 
+from math import log
 import collections
 import gettext
 import os.path
 
+sys.stdout.reconfigure(encoding='utf-8')
+sys.stderr.reconfigure(errors='backslashreplace')
+
 py = os.path.dirname(sys.argv[0])
 top = os.path.dirname(py)
 
@@ -100,77 +104,173 @@ def translate(translation_file, i18ns):
             translations.append((original, translation))
         return translations
 
-def frequent_ngrams(corpus, sz, n):
+class TextSplitter:
-    return collections.Counter(corpus[i:i+sz] for i in range(len(corpus)-sz)).most_common(n)
+    def __init__(self, words):
+        words.sort(key=lambda x: len(x), reverse=True)
+        self.words = set(words)
+        self.pat = re.compile("|".join(re.escape(w) for w in words) + "|.", flags=re.DOTALL)
 
-def encode_ngrams(translation, ngrams):
+    def iter_words(self, text):
-    if len(ngrams) > 32:
+        s = []
-        start = 0xe000
+        words = self.words
+        for m in self.pat.finditer(text):
+            t = m.group(0)
+            if t in words:
+                if s:
+                    yield (False, "".join(s))
+                    s = []
+                yield (True, t)
             else:
-        start = 0x80
+                s.append(t)
-    for i, g in enumerate(ngrams):
+        if s:
-        translation = translation.replace(g, chr(start + i))
+            yield (False, "".join(s))
-    return translation
 
-def decode_ngrams(compressed, ngrams):
+    def iter(self, text):
-    if len(ngrams) > 32:
+        for m in self.pat.finditer(text):
-        start, end = 0xe000, 0xf8ff
+            yield m.group(0)
-    else:
+
-        start, end = 0x80, 0x9f
+def iter_substrings(s, minlen, maxlen):
-    return "".join(ngrams[ord(c) - start] if (start <= ord(c) <= end) else c for c in compressed)
+    len_s = len(s)
+    maxlen = min(len_s, maxlen)
+    for n in range(minlen, maxlen + 1):
+        for begin in range(0, len_s - n + 1):
+            yield s[begin : begin + n]
+
+def compute_huffman_coding(translations, compression_filename):
+    texts = [t[1] for t in translations]
+    words = []
+
+    start_unused = 0x80
+    end_unused = 0xff
+    max_ord = 0
+    for text in texts:
+        for c in text:
+            ord_c = ord(c)
+            max_ord = max(ord_c, max_ord)
+            if 0x80 <= ord_c < 0xff:
+                end_unused = min(ord_c, end_unused)
+    max_words = end_unused - 0x80
+
+    values_type = "uint16_t" if max_ord > 255 else "uint8_t"
+    max_words_len = 160 if max_ord > 255 else 255
+
+    sum_len = 0
+    while True:
+        # Until the dictionary is filled to capacity, use a heuristic to find
+        # the best "word" (2- to 9-gram) to add to it.
+        #
+        # The TextSplitter allows us to avoid considering parts of the text
+        # that are already covered by a previously chosen word, for example
+        # if "the" is in words then not only will "the" not be considered
+        # again, neither will "there" or "wither", since they have "the"
+        # as substrings.
+        extractor = TextSplitter(words)
+        counter = collections.Counter()
+        for t in texts:
+            for (found, word) in extractor.iter_words(t):
+                if not found:
+                    for substr in iter_substrings(word, minlen=2, maxlen=9):
+                        counter[substr] += 1
+
+        # Score the candidates we found.  This is an empirical formula only,
+        # chosen for its effectiveness.
+        scores = sorted(
+            (
+                (s, (len(s) - 1) ** log(max(occ - 2, 1)), occ)
+                for (s, occ) in counter.items()
+            ),
+            key=lambda x: x[1],
+            reverse=True,
+        )
+
+        # Do we have a "word" that occurred 5 times and got a score of at least
+        # 5?  Horray.  Pick the one with the highest score.
+        word = None
+        for (s, score, occ) in scores:
+            if occ < 5:
+                continue
+            if score < 5:
+                break
+            word = s
+            break
+
+        # If we can successfully add it to the dictionary, do so.  Otherwise,
+        # we've filled the dictionary to capacity and are done.
+        if not word:
+            break
+        if sum_len + len(word) - 2 > max_words_len:
+            break
+        if len(words) == max_words:
+            break
+        words.append(word)
+        sum_len += len(word) - 2
+
+    extractor = TextSplitter(words)
+    counter = collections.Counter()
+    for t in texts:
+        for atom in extractor.iter(t):
+            counter[atom] += 1
+    cb = huffman.codebook(counter.items())
+
+    word_start = start_unused
+    word_end = word_start + len(words) - 1
+    print("// # words", len(words))
+    print("// words", words)
 
-def compute_huffman_coding(translations, qstrs, compression_filename):
-    all_strings = [x[1] for x in translations]
-    all_strings_concat = "".join(all_strings)
-    ngrams = [i[0] for i in frequent_ngrams(all_strings_concat, 2, 32)]
-    all_strings_concat = encode_ngrams(all_strings_concat, ngrams)
-    counts = collections.Counter(all_strings_concat)
-    cb = huffman.codebook(counts.items())
     values = []
     length_count = {}
     renumbered = 0
-    last_l = None
+    last_length = None
     canonical = {}
-    for ch, code in sorted(cb.items(), key=lambda x: (len(x[1]), x[0])):
+    for atom, code in sorted(cb.items(), key=lambda x: (len(x[1]), x[0])):
-        values.append(ch)
+        values.append(atom)
-        l = len(code)
+        length = len(code)
-        if l not in length_count:
+        if length not in length_count:
-            length_count[l] = 0
+            length_count[length] = 0
-        length_count[l] += 1
+        length_count[length] += 1
-        if last_l:
+        if last_length:
-            renumbered <<= (l - last_l)
+            renumbered <<= (length - last_length)
-        canonical[ch] = '{0:0{width}b}'.format(renumbered, width=l)
+        canonical[atom] = '{0:0{width}b}'.format(renumbered, width=length)
-        s = C_ESCAPES.get(ch, ch)
+        # print(f"atom={repr(atom)} code={code}", file=sys.stderr)
-        print("//", ord(ch), s, counts[ch], canonical[ch], renumbered)
+        if len(atom) > 1:
+            o = words.index(atom) + 0x80
+            s = "".join(C_ESCAPES.get(ch1, ch1) for ch1 in atom)
+        else:
+            s = C_ESCAPES.get(atom, atom)
+            o = ord(atom)
+        print("//", o, s, counter[atom], canonical[atom], renumbered)
         renumbered += 1
-        last_l = l
+        last_length = length
     lengths = bytearray()
     print("// length count", length_count)
-    print("// bigrams", ngrams)
+
     for i in range(1, max(length_count) + 2):
         lengths.append(length_count.get(i, 0))
     print("// values", values, "lengths", len(lengths), lengths)
-    ngramdata = [ord(ni) for i in ngrams for ni in i]
+
-    print("// estimated total memory size", len(lengths) + 2*len(values) + 2 * len(ngramdata) + sum((len(cb[u]) + 7)//8 for u in all_strings_concat))
     print("//", values, lengths)
-    values_type = "uint16_t" if max(ord(u) for u in values) > 255 else "uint8_t"
+    values = [(atom if len(atom) == 1 else chr(0x80 + words.index(atom))) for atom in values]
-    max_translation_encoded_length = max(len(translation.encode("utf-8")) for original,translation in translations)
+    print("//", values, lengths)
+    max_translation_encoded_length = max(
+        len(translation.encode("utf-8")) for (original, translation) in translations)
+
+    wends = list(len(w) - 2 for w in words)
+    for i in range(1, len(wends)):
+        wends[i] += wends[i - 1]
+
     with open(compression_filename, "w") as f:
         f.write("const uint8_t lengths[] = {{ {} }};\n".format(", ".join(map(str, lengths))))
         f.write("const {} values[] = {{ {} }};\n".format(values_type, ", ".join(str(ord(u)) for u in values)))
         f.write("#define compress_max_length_bits ({})\n".format(max_translation_encoded_length.bit_length()))
-        f.write("const {} bigrams[] = {{ {} }};\n".format(values_type, ", ".join(str(u) for u in ngramdata)))
+        f.write("const {} words[] = {{ {} }};\n".format(values_type, ", ".join(str(ord(c)) for w in words for c in w)))
-        if len(ngrams) > 32:
+        f.write("const uint8_t wends[] = {{ {} }};\n".format(", ".join(str(p) for p in wends)))
-            bigram_start = 0xe000
+        f.write("#define word_start {}\n".format(word_start))
-        else:
+        f.write("#define word_end {}\n".format(word_end))
-            bigram_start = 0x80
+
-        bigram_end = bigram_start + len(ngrams) - 1 # End is inclusive
+    return (values, lengths, words, canonical, extractor)
-        f.write("#define bigram_start {}\n".format(bigram_start))
-        f.write("#define bigram_end {}\n".format(bigram_end))
-    return values, lengths, ngrams
 
 def decompress(encoding_table, encoded, encoded_length_bits):
-    values, lengths, ngrams = encoding_table
+    (values, lengths, words, _, _) = encoding_table
     dec = []
     this_byte = 0
     this_bit = 7
@@ -218,7 +318,8 @@ def decompress(encoding_table, encoded, encoded_length_bits):
             searched_length += lengths[bit_length]
 
         v = values[searched_length + bits - max_code]
-        v = decode_ngrams(v, ngrams)
+        if v >= chr(0x80) and v < chr(0x80 + len(words)):
+            v = words[ord(v) - 0x80]
         i += len(v.encode('utf-8'))
         dec.append(v)
     return ''.join(dec)
@@ -226,66 +327,32 @@ def decompress(encoding_table, encoded, encoded_length_bits):
 def compress(encoding_table, decompressed, encoded_length_bits, len_translation_encoded):
     if not isinstance(decompressed, str):
         raise TypeError()
-    values, lengths, ngrams = encoding_table
+    (_, _, _, canonical, extractor) = encoding_table
-    decompressed = encode_ngrams(decompressed, ngrams)
+
     enc = bytearray(len(decompressed) * 3)
-    #print(decompressed)
-    #print(lengths)
     current_bit = 7
     current_byte = 0
 
-    code = len_translation_encoded
     bits = encoded_length_bits + 1
     for i in range(bits - 1, 0, -1):
         if len_translation_encoded & (1 << (i - 1)):
             enc[current_byte] |= 1 << current_bit
         if current_bit == 0:
             current_bit = 7
-            #print("packed {0:0{width}b}".format(enc[current_byte], width=8))
             current_byte += 1
         else:
             current_bit -= 1
 
-    for c in decompressed:
+    for atom in extractor.iter(decompressed):
-        #print()
+        for b in canonical[atom]:
-        #print("char", c, values.index(c))
+            if b == "1":
-        start = 0
-        end = lengths[0]
-        bits = 1
-        compressed = None
-        code = 0
-        while compressed is None:
-            s = start
-            e = end
-            #print("{0:0{width}b}".format(code, width=bits))
-            # Binary search!
-            while e > s:
-                midpoint = (s + e) // 2
-                #print(s, e, midpoint)
-                if values[midpoint] == c:
-                    compressed = code + (midpoint - start)
-                    #print("found {0:0{width}b}".format(compressed, width=bits))
-                    break
-                elif c < values[midpoint]:
-                    e = midpoint
-                else:
-                    s = midpoint + 1
-            code += end - start
-            code <<= 1
-            start = end
-            end += lengths[bits]
-            bits += 1
-            #print("next bit", bits)
-
-        for i in range(bits - 1, 0, -1):
-            if compressed & (1 << (i - 1)):
                 enc[current_byte] |= 1 << current_bit
             if current_bit == 0:
                 current_bit = 7
-                #print("packed {0:0{width}b}".format(enc[current_byte], width=8))
                 current_byte += 1
             else:
                 current_bit -= 1
+
     if current_bit != 7:
         current_byte += 1
     return enc[:current_byte]
@@ -452,7 +519,7 @@ if __name__ == "__main__":
     if args.translation:
         i18ns = sorted(i18ns)
         translations = translate(args.translation, i18ns)
-        encoding_table = compute_huffman_coding(translations, qstrs, args.compression_filename)
+        encoding_table = compute_huffman_coding(translations, args.compression_filename)
         print_qstr_data(encoding_table, qcfgs, qstrs, translations)
     else:
         print_qstr_enums(qstrs)

shared-bindings/camera/Camera.c

@@ -0,0 +1,132 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright 2020 Sony Semiconductor Solutions Corporation
+ *
+ * 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/objproperty.h"
+#include "py/runtime.h"
+
+#include "shared-bindings/camera/Camera.h"
+#include "shared-bindings/util.h"
+
+//| class Camera:
+//|     """The class to control camera.
+//|
+//|     Usage::
+//|
+//|         import board
+//|         import sdioio
+//|         import storage
+//|         import camera
+//|
+//|         sd = sdioio.SDCard(
+//|             clock=board.SDIO_CLOCK,
+//|             command=board.SDIO_COMMAND,
+//|             data=board.SDIO_DATA,
+//|             frequency=25000000)
+//|         vfs = storage.VfsFat(sd)
+//|         storage.mount(vfs, '/sd')
+//|
+//|         cam = camera.Camera()
+//|
+//|         buffer = bytearray(512 * 1024)
+//|         file = open("/sd/image.jpg","wb")
+//|         size = cam.take_picture(buffer, width=1920, height=1080, format=camera.ImageFormat.JPG)
+//|         file.write(buffer, size)
+//|         file.close()"""
+//|
+
+//|     def __init__(self) -> None:
+//|         """Initialize camera."""
+//|         ...
+//|
+STATIC mp_obj_t camera_make_new(const mp_obj_type_t *type, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    camera_obj_t *self = m_new_obj(camera_obj_t);
+    self->base.type = &camera_type;
+    // No arguments
+    mp_arg_check_num(n_args, kw_args, 0, 0, false);
+
+    common_hal_camera_construct(self);
+    return MP_OBJ_FROM_PTR(self);
+}
+
+//|     def deinit(self) -> None:
+//|         """De-initialize camera."""
+//|         ...
+//|
+STATIC mp_obj_t camera_obj_deinit(mp_obj_t self_in) {
+    camera_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    common_hal_camera_deinit(self);
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_1(camera_deinit_obj, camera_obj_deinit);
+
+STATIC void check_for_deinit(camera_obj_t *self) {
+    if (common_hal_camera_deinited(self)) {
+        raise_deinited_error();
+    }
+}
+
+//|     def take_picture(self, buf: WriteableBuffer, format: ImageFormat) -> int:
+//|         """Take picture and save to ``buf`` in the given ``format``. The size of the picture
+//|         taken is ``width`` by ``height`` in pixels.
+//|
+//|         :return: the number of bytes written into buf
+//|         :rtype: int"""
+//|         ...
+//|
+STATIC mp_obj_t camera_obj_take_picture(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    enum { ARG_buffer, ARG_width, ARG_height, ARG_format };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_buffer, MP_ARG_REQUIRED | MP_ARG_OBJ },
+        { MP_QSTR_width, MP_ARG_KW_ONLY | MP_ARG_REQUIRED | MP_ARG_INT },
+        { MP_QSTR_height, MP_ARG_KW_ONLY | MP_ARG_REQUIRED | MP_ARG_INT },
+        { MP_QSTR_format, MP_ARG_KW_ONLY | MP_ARG_REQUIRED | MP_ARG_OBJ },
+    };
+    camera_obj_t *self = MP_OBJ_TO_PTR(pos_args[0]);
+    check_for_deinit(self);
+    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);
+
+    mp_buffer_info_t bufinfo;
+    mp_get_buffer_raise(args[ARG_buffer].u_obj, &bufinfo, MP_BUFFER_WRITE);
+
+    camera_imageformat_t format = camera_imageformat_obj_to_type(args[ARG_format].u_obj);
+
+    return MP_OBJ_NEW_SMALL_INT(common_hal_camera_take_picture(self, (uint8_t *)bufinfo.buf, bufinfo.len, args[ARG_width].u_int, args[ARG_height].u_int, format));
+}
+MP_DEFINE_CONST_FUN_OBJ_KW(camera_take_picture_obj, 2, camera_obj_take_picture);
+
+STATIC const mp_rom_map_elem_t camera_locals_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&camera_deinit_obj) },
+    { MP_ROM_QSTR(MP_QSTR_take_picture), MP_ROM_PTR(&camera_take_picture_obj) },
+};
+STATIC MP_DEFINE_CONST_DICT(camera_locals_dict, camera_locals_dict_table);
+
+const mp_obj_type_t camera_type = {
+   { &mp_type_type },
+   .name = MP_QSTR_Camera,
+   .make_new = camera_make_new,
+   .locals_dict = (mp_obj_dict_t*)&camera_locals_dict,
+};

shared-bindings/camera/Camera.h

@@ -0,0 +1,40 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright 2020 Sony Semiconductor Solutions Corporation
+ *
+ * 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.
+ */
+
+#ifndef MICROPY_INCLUDED_SHARED_BINDINGS_CAMERA_CAMERA_H
+#define MICROPY_INCLUDED_SHARED_BINDINGS_CAMERA_CAMERA_H
+
+#include "common-hal/camera/Camera.h"
+#include "shared-bindings/camera/ImageFormat.h"
+
+extern const mp_obj_type_t camera_type;
+
+void common_hal_camera_construct(camera_obj_t *self);
+void common_hal_camera_deinit(camera_obj_t *self);
+bool common_hal_camera_deinited(camera_obj_t *self);
+size_t common_hal_camera_take_picture(camera_obj_t *self, uint8_t *buffer, size_t len, uint16_t width, uint16_t height, camera_imageformat_t format);
+
+#endif // MICROPY_INCLUDED_SHARED_BINDINGS_CAMERA_CAMERA_H

shared-bindings/camera/ImageFormat.c

@@ -0,0 +1,93 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright 2020 Sony Semiconductor Solutions Corporation
+ *
+ * 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 "shared-bindings/camera/ImageFormat.h"
+
+//| class ImageFormat:
+//|     """Image format"""
+//|
+//|     def __init__(self) -> None:
+//|         """Enum-like class to define the image format."""
+//|
+//|     JPG: ImageFormat
+//|     """JPG format."""
+//|
+//|     RGB565: ImageFormat
+//|     """RGB565 format."""
+//|
+const mp_obj_type_t camera_imageformat_type;
+
+const camera_imageformat_obj_t camera_imageformat_jpg_obj = {
+    { &camera_imageformat_type },
+};
+
+const camera_imageformat_obj_t camera_imageformat_rgb565_obj = {
+    { &camera_imageformat_type },
+};
+
+camera_imageformat_t camera_imageformat_obj_to_type(mp_obj_t obj) {
+    if (obj == MP_ROM_PTR(&camera_imageformat_jpg_obj)) {
+        return IMAGEFORMAT_JPG;
+    } else if (obj == MP_ROM_PTR(&camera_imageformat_rgb565_obj)) {
+        return IMAGEFORMAT_RGB565;
+    }
+    return IMAGEFORMAT_NONE;
+}
+
+mp_obj_t camera_imageformat_type_to_obj(camera_imageformat_t format) {
+    switch (format) {
+        case IMAGEFORMAT_JPG:
+            return (mp_obj_t)MP_ROM_PTR(&camera_imageformat_jpg_obj);
+        case IMAGEFORMAT_RGB565:
+            return (mp_obj_t)MP_ROM_PTR(&camera_imageformat_rgb565_obj);
+        case IMAGEFORMAT_NONE:
+        default:
+            return (mp_obj_t)MP_ROM_PTR(&mp_const_none_obj);
+    }
+}
+
+STATIC const mp_rom_map_elem_t camera_imageformat_locals_dict_table[] = {
+    {MP_ROM_QSTR(MP_QSTR_JPG), MP_ROM_PTR(&camera_imageformat_jpg_obj)},
+    {MP_ROM_QSTR(MP_QSTR_RGB565), MP_ROM_PTR(&camera_imageformat_rgb565_obj)},
+};
+STATIC MP_DEFINE_CONST_DICT(camera_imageformat_locals_dict, camera_imageformat_locals_dict_table);
+
+STATIC void camera_imageformat_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
+    qstr format = MP_QSTR_None;
+    if (MP_OBJ_TO_PTR(self_in) == MP_ROM_PTR(&camera_imageformat_jpg_obj)) {
+        format = MP_QSTR_JPG;
+    } else if (MP_OBJ_TO_PTR(self_in) == MP_ROM_PTR(&camera_imageformat_rgb565_obj)) {
+        format = MP_QSTR_RGB565;
+    }
+    mp_printf(print, "%q.%q.%q", MP_QSTR_camera, MP_QSTR_ImageSize, format);
+}
+
+const mp_obj_type_t camera_imageformat_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_ImageFormat,
+    .print = camera_imageformat_print,
+    .locals_dict = (mp_obj_t)&camera_imageformat_locals_dict,
+};

shared-bindings/camera/ImageFormat.h

@@ -0,0 +1,49 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright 2020 Sony Semiconductor Solutions Corporation
+ *
+ * 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.
+ */
+
+#ifndef MICROPY_INCLUDED_SHARED_BINDINGS_CAMERA_IMAGEFORMAT_H
+#define MICROPY_INCLUDED_SHARED_BINDINGS_CAMERA_IMAGEFORMAT_H
+
+#include "py/obj.h"
+
+typedef enum {
+    IMAGEFORMAT_NONE,
+    IMAGEFORMAT_JPG,
+    IMAGEFORMAT_RGB565,
+} camera_imageformat_t;
+
+const mp_obj_type_t camera_imageformat_type;
+
+camera_imageformat_t camera_imageformat_obj_to_type(mp_obj_t obj);
+mp_obj_t camera_imageformat_type_to_obj(camera_imageformat_t mode);
+
+typedef struct {
+    mp_obj_base_t base;
+} camera_imageformat_obj_t;
+extern const camera_imageformat_obj_t camera_imageformat_jpg_obj;
+extern const camera_imageformat_obj_t camera_imageformat_rgb565_obj;
+
+#endif // MICROPY_INCLUDED_SHARED_BINDINGS_CAMERA_IMAGEFORMAT_H

shared-bindings/camera/__init__.c

@@ -0,0 +1,50 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright 2020 Sony Semiconductor Solutions Corporation
+ *
+ * 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/obj.h"
+#include "py/runtime.h"
+#include "py/mphal.h"
+#include "shared-bindings/camera/Camera.h"
+#include "shared-bindings/util.h"
+
+//| """Support for camera input
+//|
+//| The `camera` module contains classes to control the camera and take pictures."""
+//|
+STATIC const mp_rom_map_elem_t camera_module_globals_table[] = {
+    { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_camera) },
+    { MP_ROM_QSTR(MP_QSTR_Camera), MP_ROM_PTR(&camera_type) },
+
+    // Enum-like Classes.
+    { MP_ROM_QSTR(MP_QSTR_ImageFormat), MP_ROM_PTR(&camera_imageformat_type) },
+};
+
+STATIC MP_DEFINE_CONST_DICT(camera_module_globals, camera_module_globals_table);
+
+const mp_obj_module_t camera_module = {
+    .base = { &mp_type_module },
+    .globals = (mp_obj_dict_t*)&camera_module_globals,
+};

supervisor/shared/translate.c

@@ -47,13 +47,22 @@ STATIC int put_utf8(char *buf, int u) {
     if(u <= 0x7f) {
         *buf = u;
         return 1;
-    } else if(bigram_start <= u && u <= bigram_end) {
+    } else if(word_start <= u && u <= word_end) {
-        int n = (u - 0x80) * 2;
+        uint n = (u - word_start);
-        // (note that at present, entries in the bigrams table are
+        size_t pos = 0;
-        // guaranteed not to represent bigrams themselves, so this adds
+        if (n > 0) {
+            pos = wends[n - 1] + (n * 2);
+        }
+        int ret = 0;
+        // note that at present, entries in the words table are
+        // guaranteed not to represent words themselves, so this adds
         // at most 1 level of recursive call
-        int ret = put_utf8(buf, bigrams[n]);
+        for(; pos < wends[n] + (n + 1) * 2; pos++) {
-        return ret + put_utf8(buf + ret, bigrams[n+1]);
+            int len = put_utf8(buf, words[pos]);
+            buf += len;
+            ret += len;
+        }
+        return ret;
     } else if(u <= 0x07ff) {
         *buf++ = 0b11000000 | (u >> 6);
         *buf   = 0b10000000 | (u & 0b00111111);

supervisor/shared/translate.h

@@ -43,6 +43,19 @@
 //   (building the huffman encoding on UTF-16 code points gave better
 //   compression than building it on UTF-8 bytes)
 //
+// - code points starting at 128 (word_start) and potentially extending
+//   to 255 (word_end) (but never interfering with the target
+//   language's used code points) stand for dictionary entries in a
+//   dictionary with size up to 256 code points.  The dictionary entries
+//   are computed with a heuristic based on frequent substrings of 2 to
+//   9 code points.  These are called "words" but are not, grammatically
+//   speaking, words.  They're just spans of code points that frequently
+//   occur together.
+//
+// - dictionary entries are non-overlapping, and the _ending_ index of each
+//   entry is stored in an array.  Since the index given is the ending
+//   index, the array is called "wends".
+//
 // The "data" / "tail" construct is so that the struct's last member is a
 // "flexible array".  However, the _only_ member is not permitted to be
 // a flexible member, so we have to declare the first byte as a separte