From d0a782092205f50c1049aeb20f24023067a052c9 Mon Sep 17 00:00:00 2001 From: Stephan Linz Date: Thu, 28 Dec 2023 11:26:27 +0100 Subject: [PATCH 01/13] drivers: prepare for MFD drivers Signed-off-by: Stephan Linz --- drivers/CMakeLists.txt | 1 + drivers/Kconfig | 1 + drivers/mfd/CMakeLists.txt | 7 +++++++ drivers/mfd/Kconfig | 5 +++++ 4 files changed, 14 insertions(+) create mode 100644 drivers/mfd/CMakeLists.txt create mode 100644 drivers/mfd/Kconfig diff --git a/drivers/CMakeLists.txt b/drivers/CMakeLists.txt index d19dd3a76f..fea71ef34e 100644 --- a/drivers/CMakeLists.txt +++ b/drivers/CMakeLists.txt @@ -3,3 +3,4 @@ # SPDX-License-Identifier: Apache-2.0 add_subdirectory_ifdef(CONFIG_GPIO gpio) +add_subdirectory_ifdef(CONFIG_MFD mfd) diff --git a/drivers/Kconfig b/drivers/Kconfig index 107153b63a..ae8c68e4c9 100644 --- a/drivers/Kconfig +++ b/drivers/Kconfig @@ -5,5 +5,6 @@ menu "Device Drivers" rsource "gpio/Kconfig" +rsource "mfd/Kconfig" endmenu diff --git a/drivers/mfd/CMakeLists.txt b/drivers/mfd/CMakeLists.txt new file mode 100644 index 0000000000..5e5a91343f --- /dev/null +++ b/drivers/mfd/CMakeLists.txt @@ -0,0 +1,7 @@ +# Copyright (c) 2023 TiaC Systems +# SPDX-License-Identifier: Apache-2.0 + +# Add to the existing mfd library from zephyr instead of defining our own. +# It is actually required to add MFD drivers to that library, otherwise +# build errors can occur! +zephyr_library_amend() diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig new file mode 100644 index 0000000000..128ce52a76 --- /dev/null +++ b/drivers/mfd/Kconfig @@ -0,0 +1,5 @@ +# Copyright (c) 2023 TiaC Systems +# SPDX-License-Identifier: Apache-2.0 + +if MFD +endif # MFD From 87b26dc01a8652359e58e3710ba848cf510e1670 Mon Sep 17 00:00:00 2001 From: Stephan Linz Date: Tue, 2 Jan 2024 15:15:53 +0100 Subject: [PATCH 02/13] drivers: prepare for RTC drivers Signed-off-by: Stephan Linz --- drivers/CMakeLists.txt | 3 ++- drivers/Kconfig | 3 ++- drivers/rtc/CMakeLists.txt | 7 +++++++ drivers/rtc/Kconfig | 5 +++++ 4 files changed, 16 insertions(+), 2 deletions(-) create mode 100644 drivers/rtc/CMakeLists.txt create mode 100644 drivers/rtc/Kconfig diff --git a/drivers/CMakeLists.txt b/drivers/CMakeLists.txt index fea71ef34e..df352f98ba 100644 --- a/drivers/CMakeLists.txt +++ b/drivers/CMakeLists.txt @@ -1,6 +1,7 @@ -# Copyright (c) 2021-2023 TiaC Systems +# Copyright (c) 2021-2024 TiaC Systems # Copyright (c) 2019-2021 Li-Pro.Net # SPDX-License-Identifier: Apache-2.0 add_subdirectory_ifdef(CONFIG_GPIO gpio) add_subdirectory_ifdef(CONFIG_MFD mfd) +add_subdirectory_ifdef(CONFIG_RTC rtc) diff --git a/drivers/Kconfig b/drivers/Kconfig index ae8c68e4c9..71cab207a0 100644 --- a/drivers/Kconfig +++ b/drivers/Kconfig @@ -1,4 +1,4 @@ -# Copyright (c) 2021-2023 TiaC Systems +# Copyright (c) 2021-2024 TiaC Systems # Copyright (c) 2019-2021 Li-Pro.Net # SPDX-License-Identifier: Apache-2.0 @@ -6,5 +6,6 @@ menu "Device Drivers" rsource "gpio/Kconfig" rsource "mfd/Kconfig" +rsource "rtc/Kconfig" endmenu diff --git a/drivers/rtc/CMakeLists.txt b/drivers/rtc/CMakeLists.txt new file mode 100644 index 0000000000..ec6a7cd648 --- /dev/null +++ b/drivers/rtc/CMakeLists.txt @@ -0,0 +1,7 @@ +# Copyright (c) 2024 TiaC Systems +# SPDX-License-Identifier: Apache-2.0 + +# Add to the existing rtc library from zephyr instead of defining our own. +# It is actually required to add RTC drivers to that library, otherwise +# build errors can occur! +zephyr_library_amend() diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig new file mode 100644 index 0000000000..b1e3a18b95 --- /dev/null +++ b/drivers/rtc/Kconfig @@ -0,0 +1,5 @@ +# Copyright (c) 2024 TiaC Systems +# SPDX-License-Identifier: Apache-2.0 + +if RTC +endif # RTC From 41725b34eea60a0172cd053ffa2546c9d50c3cc1 Mon Sep 17 00:00:00 2001 From: Stephan Linz Date: Tue, 2 Jan 2024 19:01:12 +0100 Subject: [PATCH 03/13] drivers: prepare for sensor drivers Signed-off-by: Stephan Linz --- drivers/CMakeLists.txt | 1 + drivers/Kconfig | 1 + drivers/sensor/CMakeLists.txt | 7 +++++++ drivers/sensor/Kconfig | 5 +++++ 4 files changed, 14 insertions(+) create mode 100644 drivers/sensor/CMakeLists.txt create mode 100644 drivers/sensor/Kconfig diff --git a/drivers/CMakeLists.txt b/drivers/CMakeLists.txt index df352f98ba..d46ef11aee 100644 --- a/drivers/CMakeLists.txt +++ b/drivers/CMakeLists.txt @@ -5,3 +5,4 @@ add_subdirectory_ifdef(CONFIG_GPIO gpio) add_subdirectory_ifdef(CONFIG_MFD mfd) add_subdirectory_ifdef(CONFIG_RTC rtc) +add_subdirectory_ifdef(CONFIG_SENSOR sensor) diff --git a/drivers/Kconfig b/drivers/Kconfig index 71cab207a0..3d038c143f 100644 --- a/drivers/Kconfig +++ b/drivers/Kconfig @@ -7,5 +7,6 @@ menu "Device Drivers" rsource "gpio/Kconfig" rsource "mfd/Kconfig" rsource "rtc/Kconfig" +rsource "sensor/Kconfig" endmenu diff --git a/drivers/sensor/CMakeLists.txt b/drivers/sensor/CMakeLists.txt new file mode 100644 index 0000000000..ecd7e4155f --- /dev/null +++ b/drivers/sensor/CMakeLists.txt @@ -0,0 +1,7 @@ +# Copyright (c) 2024 TiaC Systems +# SPDX-License-Identifier: Apache-2.0 + +# Add to the existing sensor library from zephyr instead of defining our own. +# It is actually required to add sensor drivers to that library, otherwise +# build errors can occur! +zephyr_library_amend() diff --git a/drivers/sensor/Kconfig b/drivers/sensor/Kconfig new file mode 100644 index 0000000000..4cb7ccf9ec --- /dev/null +++ b/drivers/sensor/Kconfig @@ -0,0 +1,5 @@ +# Copyright (c) 2024 TiaC Systems +# SPDX-License-Identifier: Apache-2.0 + +if SENSOR +endif # SENSOR From e2cbacf2dc61f0195010d33adad264bb885ee6f8 Mon Sep 17 00:00:00 2001 From: Stephan Linz Date: Fri, 29 Dec 2023 16:21:20 +0100 Subject: [PATCH 04/13] drivers: prepare for display drivers Signed-off-by: Stephan Linz --- drivers/CMakeLists.txt | 1 + drivers/Kconfig | 1 + drivers/display/CMakeLists.txt | 7 +++++++ drivers/display/Kconfig | 5 +++++ 4 files changed, 14 insertions(+) create mode 100644 drivers/display/CMakeLists.txt create mode 100644 drivers/display/Kconfig diff --git a/drivers/CMakeLists.txt b/drivers/CMakeLists.txt index d46ef11aee..0f721e757e 100644 --- a/drivers/CMakeLists.txt +++ b/drivers/CMakeLists.txt @@ -2,6 +2,7 @@ # Copyright (c) 2019-2021 Li-Pro.Net # SPDX-License-Identifier: Apache-2.0 +add_subdirectory_ifdef(CONFIG_DISPLAY display) add_subdirectory_ifdef(CONFIG_GPIO gpio) add_subdirectory_ifdef(CONFIG_MFD mfd) add_subdirectory_ifdef(CONFIG_RTC rtc) diff --git a/drivers/Kconfig b/drivers/Kconfig index 3d038c143f..6a3b62babc 100644 --- a/drivers/Kconfig +++ b/drivers/Kconfig @@ -4,6 +4,7 @@ menu "Device Drivers" +rsource "display/Kconfig" rsource "gpio/Kconfig" rsource "mfd/Kconfig" rsource "rtc/Kconfig" diff --git a/drivers/display/CMakeLists.txt b/drivers/display/CMakeLists.txt new file mode 100644 index 0000000000..4855c90e81 --- /dev/null +++ b/drivers/display/CMakeLists.txt @@ -0,0 +1,7 @@ +# Copyright (c) 2023 TiaC Systems +# SPDX-License-Identifier: Apache-2.0 + +# Add to the existing display library from zephyr instead of defining our own. +# It is actually required to add display drivers to that library, otherwise +# build errors can occur! +zephyr_library_amend() diff --git a/drivers/display/Kconfig b/drivers/display/Kconfig new file mode 100644 index 0000000000..ff4161646d --- /dev/null +++ b/drivers/display/Kconfig @@ -0,0 +1,5 @@ +# Copyright (c) 2023 TiaC Systems +# SPDX-License-Identifier: Apache-2.0 + +if DISPLAY +endif # DISPLAY From 83406e4f0e905c861e5bbaa8160ce11b9d86950b Mon Sep 17 00:00:00 2001 From: Stephan Linz Date: Thu, 4 Jan 2024 15:32:16 +0100 Subject: [PATCH 05/13] drivers: mfd: ds3231: add Maxim DS3231 device Add initial MFD driver for a Maxim DS3231 device that provides a RTC with two independent alarms and one on-chip sensor for ambient temperature. Signed-off-by: Stephan Linz --- drivers/mfd/CMakeLists.txt | 4 +- drivers/mfd/Kconfig | 5 +- drivers/mfd/Kconfig.ds3231 | 21 +++ drivers/mfd/mfd_ds3231.c | 184 +++++++++++++++++++++++++ dts/bindings/mfd/maxim,ds3231-mfd.yaml | 34 +++++ include/zephyr/drivers/mfd/ds3231.h | 143 +++++++++++++++++++ 6 files changed, 389 insertions(+), 2 deletions(-) create mode 100644 drivers/mfd/Kconfig.ds3231 create mode 100644 drivers/mfd/mfd_ds3231.c create mode 100644 dts/bindings/mfd/maxim,ds3231-mfd.yaml create mode 100644 include/zephyr/drivers/mfd/ds3231.h diff --git a/drivers/mfd/CMakeLists.txt b/drivers/mfd/CMakeLists.txt index 5e5a91343f..54b8641913 100644 --- a/drivers/mfd/CMakeLists.txt +++ b/drivers/mfd/CMakeLists.txt @@ -1,7 +1,9 @@ -# Copyright (c) 2023 TiaC Systems +# Copyright (c) 2023-2024 TiaC Systems # SPDX-License-Identifier: Apache-2.0 # Add to the existing mfd library from zephyr instead of defining our own. # It is actually required to add MFD drivers to that library, otherwise # build errors can occur! zephyr_library_amend() + +zephyr_library_sources_ifdef(CONFIG_MFD_DS3231 mfd_ds3231.c) diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig index 128ce52a76..0fb96fcf48 100644 --- a/drivers/mfd/Kconfig +++ b/drivers/mfd/Kconfig @@ -1,5 +1,8 @@ -# Copyright (c) 2023 TiaC Systems +# Copyright (c) 2023-2024 TiaC Systems # SPDX-License-Identifier: Apache-2.0 if MFD + +rsource "Kconfig.ds3231" + endif # MFD diff --git a/drivers/mfd/Kconfig.ds3231 b/drivers/mfd/Kconfig.ds3231 new file mode 100644 index 0000000000..b9c267a0c6 --- /dev/null +++ b/drivers/mfd/Kconfig.ds3231 @@ -0,0 +1,21 @@ +# Maxim DS3231 MFD configuration options + +# Copyright (c) 2024 TiaC Systems +# SPDX-License-Identifier: Apache-2.0 + +menuconfig MFD_DS3231 + bool "Maxim DS3231 MFD controller" + default y if !DT_HAS_MAXIM_DS3231_ENABLED + depends on DT_HAS_MAXIM_DS3231_MFD_ENABLED + select I2C + help + Enable the Maxim DS3231 multi-function device driver to got + access to the devices for RTC and Temperature Sensor drivers. + +config MFD_DS3231_INIT_PRIORITY + int "Initialization priority" + default 55 if RTC_DS3231 + default MFD_INIT_PRIORITY + depends on MFD_DS3231 + help + Multi-function device initialization priority for Maxim DS3231. diff --git a/drivers/mfd/mfd_ds3231.c b/drivers/mfd/mfd_ds3231.c new file mode 100644 index 0000000000..91a51894cb --- /dev/null +++ b/drivers/mfd/mfd_ds3231.c @@ -0,0 +1,184 @@ +/* + * Copyright (c) 2024 TiaC Systems + * SPDX-License-Identifier: Apache-2.0 + */ + +#define DT_DRV_COMPAT maxim_ds3231_mfd + +#include +#include +#include + +#include +#include +#include + +#include + +#include +LOG_MODULE_REGISTER(mfd_ds3231, CONFIG_MFD_LOG_LEVEL); + +struct mfd_ds3231_config { + const struct i2c_dt_spec bus; + const struct gpio_dt_spec isw; +}; + +struct mfd_ds3231_data { + const struct device *dev; + struct k_sem lock; +}; + +/* + * multi functional interface --- main entries + */ + +int mfd_ds3231_reg_read(const struct device *dev, const uint8_t reg, + uint8_t *val) +{ + const struct mfd_ds3231_config * const config = dev->config; + struct mfd_ds3231_data * const data = dev->data; + int ret = 0; + + k_sem_take(&data->lock, K_FOREVER); + + ret = i2c_reg_read_byte_dt(&config->bus, reg, val); + + k_sem_give(&data->lock); + + return ret; +} + +int mfd_ds3231_reg_read_burst(const struct device *dev, const uint8_t reg, + uint8_t *buf, const size_t len) +{ + const struct mfd_ds3231_config * const config = dev->config; + struct mfd_ds3231_data * const data = dev->data; + int ret = 0; + + k_sem_take(&data->lock, K_FOREVER); + + ret = i2c_burst_read_dt(&config->bus, reg, buf, len); + + k_sem_give(&data->lock); + + return ret; +} + +int mfd_ds3231_reg_write(const struct device *dev, const uint8_t reg, + const uint8_t val) +{ + const struct mfd_ds3231_config * const config = dev->config; + struct mfd_ds3231_data * const data = dev->data; + int ret = 0; + + k_sem_take(&data->lock, K_FOREVER); + + ret = i2c_reg_write_byte_dt(&config->bus, reg, val); + + k_sem_give(&data->lock); + + return ret; +} + +int mfd_ds3231_reg_write_burst(const struct device *dev, const uint8_t reg, + const uint8_t *buf, const size_t len) +{ + const struct mfd_ds3231_config * const config = dev->config; + struct mfd_ds3231_data * const data = dev->data; + int ret = 0; + + k_sem_take(&data->lock, K_FOREVER); + + ret = i2c_burst_write_dt(&config->bus, reg, buf, len); + + k_sem_give(&data->lock); + + return ret; +} + +/* + * driver initialization --- configure and setup internal driver mechanic + */ + +static int mfd_ds3231_init(const struct device *dev) +{ + const struct mfd_ds3231_config * const config = dev->config; + struct mfd_ds3231_data * const data = dev->data; + int ret = 0; + + /* Initialize and take the lock */ + k_sem_init(&data->lock, 0, 1); + + /* Save device instance */ + data->dev = dev; + + if (!i2c_is_ready_dt(&config->bus)) { + LOG_ERR("%s: I2C device %s not ready", dev->name, + config->bus.bus->name); + ret = -ENODEV; + goto out_locked; + } + + /* Disable alarm interrupt requests and squarewave output */ + ret = i2c_reg_write_byte_dt(&config->bus, DS3231_CTRL, 0x00); + if (ret < 0) { + LOG_ERR("%s: can't disable nINT/SQW output", dev->name); + } + + if (config->isw.port != NULL) { + if (!gpio_is_ready_dt(&config->isw)) { + LOG_ERR("%s: GPIO pin: %s not ready", dev->name, + config->isw.port ? config->isw.port->name : + "null"); + ret = -ENODEV; + goto out_locked; + } + + ret = gpio_pin_configure_dt(&config->isw, GPIO_INPUT); + if (ret < 0) { + LOG_ERR("%s: can't configure nINT/SQW pin %d as input", + dev->name, config->isw.pin); + goto out_locked; + } + } + +out_locked: + k_sem_give(&data->lock); + + LOG_DBG("%s: ready!", dev->name); + return ret; +} + +#ifdef CONFIG_PM_DEVICE +static int mfd_ds3231_pm_device_pm_action(const struct device *dev, + enum pm_device_action action) +{ + ARG_UNUSED(dev); + ARG_UNUSED(action); + + return 0; +} +#endif + +#if CONFIG_MFD_DS3231_INIT_PRIORITY <= CONFIG_I2C_INIT_PRIORITY +#error MFD_DS3231_INIT_PRIORITY must be greater than I2C_INIT_PRIORITY +#endif + +#define MFD_DS3231_DEFINE(n) \ + \ + static const struct mfd_ds3231_config mfd_ds3231_config_##n = { \ + .bus = I2C_DT_SPEC_INST_GET(n), \ + .isw = GPIO_DT_SPEC_INST_GET_OR(n, isw_gpios, {0}), \ + }; \ + \ + static struct mfd_ds3231_data mfd_ds3231_data_##n; \ + \ + PM_DEVICE_DT_INST_DEFINE(n, mfd_ds3231_pm_device_pm_action); \ + \ + DEVICE_DT_INST_DEFINE(n, mfd_ds3231_init, \ + PM_DEVICE_DT_INST_GET(n), \ + &mfd_ds3231_data_##n, \ + &mfd_ds3231_config_##n, POST_KERNEL, \ + CONFIG_MFD_DS3231_INIT_PRIORITY, NULL); + +DT_INST_FOREACH_STATUS_OKAY(MFD_DS3231_DEFINE) diff --git a/dts/bindings/mfd/maxim,ds3231-mfd.yaml b/dts/bindings/mfd/maxim,ds3231-mfd.yaml new file mode 100644 index 0000000000..44673f7c93 --- /dev/null +++ b/dts/bindings/mfd/maxim,ds3231-mfd.yaml @@ -0,0 +1,34 @@ +# Copyright (c) 2024 TiaC Systems +# SPDX-License-Identifier: Apache-2.0 + +description: Maxim DS3231 I2C RTC/TCXO + +compatible: "maxim,ds3231-mfd" + +include: i2c-device.yaml + +properties: + reg: + required: true + + 32k-gpios: + type: phandle-array + description: | + + 32 KiHz open drain output + + The DS3231 defaults to providing a 32 KiHz square wave on this + signal. The driver does not make use of this, but applications + may want access. + + isw-gpios: + type: phandle-array + description: | + + interrupt/square wave open drain output + + The DS3231 uses this signal to notify when an alarm has triggered, + and also to produce a square wave aligned to the countdown chain. + Both capabilities are used within the driver. This signal must be + present to support time set and read operations that preserve + sub-second accuracy. diff --git a/include/zephyr/drivers/mfd/ds3231.h b/include/zephyr/drivers/mfd/ds3231.h new file mode 100644 index 0000000000..255f842d95 --- /dev/null +++ b/include/zephyr/drivers/mfd/ds3231.h @@ -0,0 +1,143 @@ +/* + * Copyright (c) 2023 TiaC Systems + * SPDX-License-Identifier: Apache-2.0 + */ +#ifndef ZEPHYR_INCLUDE_DRIVERS_MFD_DS3231_H_ +#define ZEPHYR_INCLUDE_DRIVERS_MFD_DS3231_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @defgroup mdf_interface_ds3231 MFD DS3231 Interface + * @ingroup mfd_interfaces + * @{ + */ + +#include +#include + +#include + +/* @todo Move DS3231 register definitions to MFD private area. */ + +#include /* for GENMASK() */ + +/* DS3231 registers */ +#define DS3231_SECONDS 0x00 +#define DS3231_SECONDS_BITS GENMASK(6, 0) + +#define DS3231_MINUTES 0x01 +#define DS3231_MINUTES_BITS GENMASK(6, 0) + +#define DS3231_HOURS 0x02 +#define DS3231_HOURS_BITS GENMASK(5, 0) +#define DS3231_VALIDATE_24HR BIT(6) + +#define DS3231_DAY 0x03 +#define DS3231_DAY_BITS GENMASK(2, 0) + +#define DS3231_DATE 0x04 +#define DS3231_DATE_BITS GENMASK(5, 0) + +#define DS3231_MONTH 0x05 +#define DS3231_MONTHS_BITS GENMASK(4, 0) +#define DS3231_VALIDATE_CENTURY BIT(7) + +#define DS3231_YEAR 0x06 +#define DS3231_YEAR_BITS GENMASK(7, 0) + +#define DS3231_CAL_NUM_REGS (DS3231_YEAR - DS3231_SECONDS + 1) + +/* @todo Define registers for alarm 1, 0x07 - 0x0A. */ + +/* @todo Define registers for alarm 2, 0x0B - 0x0D. */ + +#define DS3231_CTRL 0x0E +#define DS3231_CTRL_EOSC BIT(7) +#define DS3231_CTRL_BBSQW BIT(6) +#define DS3231_CTRL_CONV BIT(5) +#define DS3231_CTRL_RS2 BIT(4) +#define DS3231_CTRL_RS1 BIT(3) +#define DS3231_CTRL_INTCN BIT(2) +#define DS3231_CTRL_A2IE BIT(1) +#define DS3231_CTRL_A1IE BIT(0) + +#define DS3231_CTRL_STAT 0x0F +#define DS3231_STAT_OSF BIT(7) +#define DS3231_STAT_EN32KHZ BIT(3) +#define DS3231_STAT_BSY BIT(2) +#define DS3231_STAT_A2F BIT(1) +#define DS3231_STAT_A1F BIT(0) + +#define DS3231_AGE_OFFS 0x10 +#define DS3231_AGE_OFFS_BITS GENMASK(7, 0) + +#define DS3231_TEMP_MSB 0x11 +#define DS3231_TEMP_MSB_BITS GENMASK(7, 0) + +#define DS3231_TEMP_LSB 0x12 +#define DS3231_TEMP_LSB_BITS GENMASK(7, 6) + +#define DS3231_TEMP_NUM_REGS (DS3231_TEMP_LSB - DS3231_TEMP_MSB + 1) +#define DS3231_TEMP_MSB_IDX (DS3231_TEMP_MSB - DS3231_TEMP_MSB) +#define DS3231_TEMP_LSB_IDX (DS3231_TEMP_LSB - DS3231_TEMP_MSB) + +/** + * @brief Read single register from DS3231 + * + * @param dev ds3231 mfd device + * @param reg Register address + * @param val Pointer to buffer for received data + * @retval 0 If successful + * @retval -errno In case of any bus error (see i2c_reg_read_byte_dt()) + */ +int mfd_ds3231_reg_read(const struct device *dev, const uint8_t reg, + uint8_t *val); + +/** + * @brief Read multiple registers from DS3231 + * + * @param dev ds3231 mfd device + * @param reg Register address + * @param buf Pointer to buffer for received data + * @param len Number of bytes to read + * @retval 0 If successful + * @retval -errno In case of any bus error (see i2c_burst_write_dt()) + */ +int mfd_ds3231_reg_read_burst(const struct device *dev, const uint8_t reg, + uint8_t *buf, const size_t len); + +/** + * @brief Write single register to DS3231 + * + * @param dev ds3231 mfd device + * @param reg Register address + * @param val Data to be sent + * @retval 0 If successful + * @retval -errno In case of any bus error (see i2c_reg_write_byte_dt()) + */ +int mfd_ds3231_reg_write(const struct device *dev, const uint8_t reg, + const uint8_t val); + +/** + * @brief Write multiple registers to DS3231 + * + * @param dev ds3231 mfd device + * @param reg Register address + * @param buf Pointer to buffer with data to be sent + * @param len Number of bytes to write + * @retval 0 If successful + * @retval -errno In case of any bus error (see i2c_burst_read_dt()) + */ +int mfd_ds3231_reg_write_burst(const struct device *dev, const uint8_t reg, + const uint8_t *buf, const size_t len); + +/** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* ZEPHYR_INCLUDE_DRIVERS_MFD_DS3231_H_ */ From 1302ffefa11ded09c9916548a85eadc806890c1a Mon Sep 17 00:00:00 2001 From: Stephan Linz Date: Tue, 2 Jan 2024 17:28:45 +0100 Subject: [PATCH 06/13] drivers: rtc: ds3231: add Maxim DS3231 RTC device Add initial RTC driver for DS3231 devices. It allows to read and set the date and time. Signed-off-by: Stephan Linz --- drivers/rtc/CMakeLists.txt | 2 + drivers/rtc/Kconfig | 3 + drivers/rtc/Kconfig.ds3231 | 19 +++ drivers/rtc/rtc_ds3231.c | 157 +++++++++++++++++++++++++ dts/bindings/rtc/maxim,ds3231-rtc.yaml | 8 ++ 5 files changed, 189 insertions(+) create mode 100644 drivers/rtc/Kconfig.ds3231 create mode 100644 drivers/rtc/rtc_ds3231.c create mode 100644 dts/bindings/rtc/maxim,ds3231-rtc.yaml diff --git a/drivers/rtc/CMakeLists.txt b/drivers/rtc/CMakeLists.txt index ec6a7cd648..ec6bb139e5 100644 --- a/drivers/rtc/CMakeLists.txt +++ b/drivers/rtc/CMakeLists.txt @@ -5,3 +5,5 @@ # It is actually required to add RTC drivers to that library, otherwise # build errors can occur! zephyr_library_amend() + +zephyr_library_sources_ifdef(CONFIG_RTC_DS3231 rtc_ds3231.c) diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig index b1e3a18b95..9f2a882504 100644 --- a/drivers/rtc/Kconfig +++ b/drivers/rtc/Kconfig @@ -2,4 +2,7 @@ # SPDX-License-Identifier: Apache-2.0 if RTC + +rsource "Kconfig.ds3231" + endif # RTC diff --git a/drivers/rtc/Kconfig.ds3231 b/drivers/rtc/Kconfig.ds3231 new file mode 100644 index 0000000000..723a294305 --- /dev/null +++ b/drivers/rtc/Kconfig.ds3231 @@ -0,0 +1,19 @@ +# Maxim DS3231 RTC configuration options + +# Copyright (c) 2024 TiaC Systems +# SPDX-License-Identifier: Apache-2.0 + +menuconfig RTC_DS3231 + bool "Maxim DS3231 Real-Time-Clock" + default y + depends on DT_HAS_MAXIM_DS3231_RTC_ENABLED + select MFD + help + Enable the Maxim DS3231 RTC driver. + +config RTC_DS3231_INIT_PRIORITY + int "Initialization priority" + default 60 + depends on RTC_DS3231 + help + RTC device initialization priority for the Maxim DS3231 RTC. diff --git a/drivers/rtc/rtc_ds3231.c b/drivers/rtc/rtc_ds3231.c new file mode 100644 index 0000000000..66a356f6ba --- /dev/null +++ b/drivers/rtc/rtc_ds3231.c @@ -0,0 +1,157 @@ +/* + * Copyright (c) 2024 TiaC Systems + * SPDX-License-Identifier: Apache-2.0 + */ + +#define DT_DRV_COMPAT maxim_ds3231_rtc + +#include +#include +#include + +#include + +#include + +#include +LOG_MODULE_REGISTER(rtc_ds3231, CONFIG_RTC_LOG_LEVEL); + +struct rtc_ds3231_config { + const struct device *mfd; +}; + +struct rtc_ds3231_data { + struct k_spinlock lock; +}; + +static int rtc_ds3231_set_time(const struct device *dev, + const struct rtc_time *tm) +{ + const struct rtc_ds3231_config * const config = dev->config; + struct rtc_ds3231_data * const data = dev->data; + k_spinlock_key_t key; + uint8_t regs[DS3231_CAL_NUM_REGS]; + int ret; + + key = k_spin_lock(&data->lock); + + LOG_DBG("%s: set time: year = %d, mon = %d, mday = %d, wday = %d, " + "hour = %d, min = %d, sec = %d", dev->name, + tm->tm_year, tm->tm_mon, tm->tm_mday, tm->tm_wday, + tm->tm_hour, tm->tm_min, tm->tm_sec); + + regs[DS3231_SECONDS] = bin2bcd(tm->tm_sec) & DS3231_SECONDS_BITS; + regs[DS3231_MINUTES] = bin2bcd(tm->tm_min); + regs[DS3231_HOURS] = bin2bcd(tm->tm_hour); + regs[DS3231_DAY] = bin2bcd(tm->tm_wday); + regs[DS3231_DATE] = bin2bcd(tm->tm_mday); + regs[DS3231_MONTH] = bin2bcd(tm->tm_mon); + regs[DS3231_YEAR] = bin2bcd((tm->tm_year % 100)); + + ret = mfd_ds3231_reg_write_burst(config->mfd, DS3231_SECONDS, + regs, sizeof(regs)); + + k_spin_unlock(&data->lock, key); + + return ret; +} + +static int rtc_ds3231_get_time(const struct device *dev, struct rtc_time *tm) +{ + + const struct rtc_ds3231_config * const config = dev->config; + struct rtc_ds3231_data * const data = dev->data; + k_spinlock_key_t key; + uint8_t regs[DS3231_CAL_NUM_REGS]; + int ret; + + key = k_spin_lock(&data->lock); + + ret = mfd_ds3231_reg_read_burst(config->mfd, DS3231_SECONDS, + regs, sizeof(regs)); + if (ret != 0) { + goto unlock; + } + + tm->tm_sec = bcd2bin(regs[DS3231_SECONDS] & DS3231_SECONDS_BITS); + tm->tm_min = bcd2bin(regs[DS3231_MINUTES] & DS3231_MINUTES_BITS); + tm->tm_hour = bcd2bin(regs[DS3231_HOURS] & DS3231_HOURS_BITS); /* 24hr mode */ + tm->tm_wday = bcd2bin(regs[DS3231_DAY] & DS3231_DAY_BITS); + tm->tm_mday = bcd2bin(regs[DS3231_DATE] & DS3231_DATE_BITS); + tm->tm_mon = bcd2bin(regs[DS3231_MONTH] & DS3231_MONTHS_BITS); + tm->tm_year = bcd2bin(regs[DS3231_YEAR] & DS3231_YEAR_BITS); + tm->tm_year = tm->tm_year + 100; + + /* Not used */ + tm->tm_nsec = 0; + tm->tm_isdst = -1; + tm->tm_yday = -1; + + /* Validate the chip in 24hr mode */ + if (regs[DS3231_HOURS] & DS3231_VALIDATE_24HR) { + ret = -ENODATA; + goto unlock; + } + + LOG_DBG("%s: get time: year = %d, mon = %d, mday = %d, wday = %d, " + "hour = %d, min = %d, sec = %d", dev->name, + tm->tm_year, tm->tm_mon, tm->tm_mday, tm->tm_wday, + tm->tm_hour, tm->tm_min, tm->tm_sec); + +unlock: + k_spin_unlock(&data->lock, key); + + return ret; +} + +static const struct rtc_driver_api rtc_ds3231_driver_api = { + .set_time = rtc_ds3231_set_time, + .get_time = rtc_ds3231_get_time, +}; + +static int rtc_ds3231_init(const struct device *dev) +{ + const struct rtc_ds3231_config * const config = dev->config; + + if (!device_is_ready(config->mfd)) { + return -ENODEV; + } + + LOG_DBG("%s: ready with MFD backend over %s!", dev->name, + config->mfd->name); + return 0; +} + +#ifdef CONFIG_PM_DEVICE +static int rtc_ds3231_pm_device_pm_action(const struct device *dev, + enum pm_device_action action) +{ + ARG_UNUSED(dev); + ARG_UNUSED(action); + + return 0; +} +#endif + +#if CONFIG_RTC_DS3231_INIT_PRIORITY <= CONFIG_MFD_DS3231_INIT_PRIORITY +#error RTC_DS3231_INIT_PRIORITY must be greater than MFD_DS3231_INIT_PRIORITY +#endif + +#define RTC_DS3231_DEFINE(n) \ + \ + static const struct rtc_ds3231_config rtc_ds3231_config_##n = { \ + .mfd = DEVICE_DT_GET(DT_INST_PARENT(n)), \ + }; \ + \ + static struct rtc_ds3231_data rtc_ds3231_data_##n; \ + \ + PM_DEVICE_DT_INST_DEFINE(n, rtc_ds3231_pm_device_pm_action); \ + \ + DEVICE_DT_INST_DEFINE(n, rtc_ds3231_init, \ + PM_DEVICE_DT_INST_GET(n), \ + &rtc_ds3231_data_##n, \ + &rtc_ds3231_config_##n, POST_KERNEL, \ + CONFIG_RTC_DS3231_INIT_PRIORITY, \ + &rtc_ds3231_driver_api); + +DT_INST_FOREACH_STATUS_OKAY(RTC_DS3231_DEFINE) diff --git a/dts/bindings/rtc/maxim,ds3231-rtc.yaml b/dts/bindings/rtc/maxim,ds3231-rtc.yaml new file mode 100644 index 0000000000..e10123e171 --- /dev/null +++ b/dts/bindings/rtc/maxim,ds3231-rtc.yaml @@ -0,0 +1,8 @@ +# Copyright (c) 2024 TiaC Systems +# SPDX-License-Identifier: Apache-2.0 + +description: Maxim DS3231 RTC + +compatible: "maxim,ds3231-rtc" + +include: [rtc-device.yaml] From d13069fdde55690b2870e7a6919bf5a85bf397cf Mon Sep 17 00:00:00 2001 From: Stephan Linz Date: Wed, 3 Jan 2024 10:51:08 +0100 Subject: [PATCH 07/13] drivers: sensor: ds3231: add Maxim DS3231 temperature sensor Add initial temperature sensor for DS3231 devices. It allows to read the ambient temperature. Signed-off-by: Stephan Linz --- drivers/sensor/CMakeLists.txt | 2 + drivers/sensor/Kconfig | 3 + drivers/sensor/Kconfig.ds3231_temp | 21 +++ drivers/sensor/ds3231_temp.c | 141 +++++++++++++++++++++ dts/bindings/sensor/maxim,ds3231-temp.yaml | 8 ++ 5 files changed, 175 insertions(+) create mode 100644 drivers/sensor/Kconfig.ds3231_temp create mode 100644 drivers/sensor/ds3231_temp.c create mode 100644 dts/bindings/sensor/maxim,ds3231-temp.yaml diff --git a/drivers/sensor/CMakeLists.txt b/drivers/sensor/CMakeLists.txt index ecd7e4155f..892d95004a 100644 --- a/drivers/sensor/CMakeLists.txt +++ b/drivers/sensor/CMakeLists.txt @@ -5,3 +5,5 @@ # It is actually required to add sensor drivers to that library, otherwise # build errors can occur! zephyr_library_amend() + +zephyr_library_sources_ifdef(CONFIG_DS3231_TEMP ds3231_temp.c) diff --git a/drivers/sensor/Kconfig b/drivers/sensor/Kconfig index 4cb7ccf9ec..9b2e364dc1 100644 --- a/drivers/sensor/Kconfig +++ b/drivers/sensor/Kconfig @@ -2,4 +2,7 @@ # SPDX-License-Identifier: Apache-2.0 if SENSOR + +rsource "Kconfig.ds3231_temp" + endif # SENSOR diff --git a/drivers/sensor/Kconfig.ds3231_temp b/drivers/sensor/Kconfig.ds3231_temp new file mode 100644 index 0000000000..efb609566c --- /dev/null +++ b/drivers/sensor/Kconfig.ds3231_temp @@ -0,0 +1,21 @@ +# Maxim DS3231 RTC temperature sensor configuration options + +# Copyright (c) 2024 TiaC Systems +# SPDX-License-Identifier: Apache-2.0 + +menuconfig DS3231_TEMP + bool "Maxim DS3231 Ambient Temperature Sensor" + default y + depends on DT_HAS_MAXIM_DS3231_TEMP_ENABLED + select MFD + help + Enable the driver for the digital temperature sensor inside + the Maxim DS3231 RTC device. + +config DS3231_TEMP_INIT_PRIORITY + int "Initialization priority" + default SENSOR_INIT_PRIORITY + depends on DS3231_TEMP + help + Sensor device initialization priority for the digital temperature + sensor inside the Maxim DS3231 RTC device. diff --git a/drivers/sensor/ds3231_temp.c b/drivers/sensor/ds3231_temp.c new file mode 100644 index 0000000000..ea26becd72 --- /dev/null +++ b/drivers/sensor/ds3231_temp.c @@ -0,0 +1,141 @@ +/* + * Copyright (c) 2024 TiaC Systems + * SPDX-License-Identifier: Apache-2.0 + */ + +#define DT_DRV_COMPAT maxim_ds3231_temp + +#include +#include +#include + +#include + +#include + +#include +LOG_MODULE_REGISTER(ds3231_temp, CONFIG_SENSOR_LOG_LEVEL); + +struct ds3231_temp_config { + const struct device *mfd; +}; + +struct ds3231_temp_data { + int16_t temp; /* temperature in 0.01°C */ +}; + +static inline int ds3231_temp_fetch(const struct ds3231_temp_config *config, + struct ds3231_temp_data *data) +{ + int ret; + uint8_t regs[DS3231_TEMP_NUM_REGS]; + int16_t temp; + + ret = mfd_ds3231_reg_read_burst(config->mfd, DS3231_TEMP_MSB, + regs, sizeof(regs)); + if (ret) { + LOG_ERR("Could not fetch temperature [%d]", ret); + return -EIO; + } + + /* temp is in two's complement; bit 7 and 6 + * in the LSB part corresponds to 0.25°C */ + temp = (regs[DS3231_TEMP_MSB_IDX] & DS3231_TEMP_MSB_BITS) << 8; + temp |= (regs[DS3231_TEMP_LSB_IDX] & DS3231_TEMP_LSB_BITS); + + /* shift right by 6 to align data + * multiply by 100 to get 0.01 + * and divide by 4 to get °C */ + data->temp = (temp / 64) * 100 / 4; + + return 0; +} + +static int ds3231_temp_sample_fetch(const struct device *dev, + enum sensor_channel chan) +{ + const struct ds3231_temp_config * const config = dev->config; + struct ds3231_temp_data * const data = dev->data; + int ret; + + switch (chan) { + case SENSOR_CHAN_ALL: + case SENSOR_CHAN_AMBIENT_TEMP: + ret = ds3231_temp_fetch(config, data); + break; + default: + ret = -ENOTSUP; + break; + } + + return ret; +} + +static int ds3231_temp_channel_get(const struct device *dev, + enum sensor_channel chan, + struct sensor_value *val) +{ + struct ds3231_temp_data * const data = dev->data; + + switch (chan) { + case SENSOR_CHAN_AMBIENT_TEMP: + val->val1 = data->temp / 100; + val->val2 = (data->temp % 100) * 10000U; + return 0; + default: + return -ENOTSUP; + } +} + +static const struct sensor_driver_api ds3231_temp_driver_api = { + .sample_fetch = ds3231_temp_sample_fetch, + .channel_get = ds3231_temp_channel_get, +}; + +int ds3231_temp_init(const struct device *dev) +{ + const struct ds3231_temp_config * const config = dev->config; + + if (!device_is_ready(config->mfd)) { + return -ENODEV; + } + + LOG_DBG("%s: ready with MFD backend over %s!", dev->name, + config->mfd->name); + return 0; +} + +#ifdef CONFIG_PM_DEVICE +static int ds3231_temp_pm_device_pm_action(const struct device *dev, + enum pm_device_action action) +{ + ARG_UNUSED(dev); + ARG_UNUSED(action); + + return 0; +} +#endif + +#if CONFIG_DS3231_TEMP_INIT_PRIORITY <= CONFIG_MFD_DS3231_INIT_PRIORITY +#error DS3231_TEMP_INIT_PRIORITY must be greater than MFD_DS3231_INIT_PRIORITY +#endif + +#define DS3231_TEMP_DEFINE(n) \ + \ + static const struct ds3231_temp_config ds3231_temp_config_##n = { \ + .mfd = DEVICE_DT_GET(DT_INST_PARENT(n)), \ + }; \ + \ + static struct ds3231_temp_data ds3231_temp_data_##n; \ + \ + PM_DEVICE_DT_INST_DEFINE(n, ds3231_temp_pm_device_pm_action); \ + \ + SENSOR_DEVICE_DT_INST_DEFINE(n, ds3231_temp_init, \ + PM_DEVICE_DT_INST_GET(n), \ + &ds3231_temp_data_##n, \ + &ds3231_temp_config_##n, \ + POST_KERNEL, \ + CONFIG_DS3231_TEMP_INIT_PRIORITY, \ + &ds3231_temp_driver_api); + +DT_INST_FOREACH_STATUS_OKAY(DS3231_TEMP_DEFINE) diff --git a/dts/bindings/sensor/maxim,ds3231-temp.yaml b/dts/bindings/sensor/maxim,ds3231-temp.yaml new file mode 100644 index 0000000000..0e5f8f7a7c --- /dev/null +++ b/dts/bindings/sensor/maxim,ds3231-temp.yaml @@ -0,0 +1,8 @@ +# Copyright (c) 2024 TiaC Systems +# SPDX-License-Identifier: Apache-2.0 + +description: Digital Temperature Sensor inside Maxim DS3231 RTC + +compatible: "maxim,ds3231-temp" + +include: [sensor-device.yaml] From c9f79074424d9683cd501e498a4cf6b700aebee4 Mon Sep 17 00:00:00 2001 From: Stephan Linz Date: Thu, 28 Dec 2023 23:01:51 +0100 Subject: [PATCH 08/13] drivers: mfd: sipomuxgp: add SIPO/MUX GP matrix Add initial MFD driver for a General Purpose (GP) matrix controller, implemented in software, using a generic latched serial in parallel out (SIPO) shift register for the data (columns) and a multiplexing X to 1-of-2^X decoder (MUX) for the addresses (rows). Signed-off-by: Stephan Linz --- drivers/mfd/CMakeLists.txt | 3 + drivers/mfd/Kconfig | 1 + drivers/mfd/Kconfig.sipomuxgp | 63 ++++ drivers/mfd/mfd_sipomuxgp.c | 495 +++++++++++++++++++++++++ drivers/mfd/mfd_sipomuxgp.h | 79 ++++ drivers/mfd/mfd_sipomuxgp_spi.c | 95 +++++ drivers/mfd/mfd_sipomuxgp_spi.h | 32 ++ drivers/mfd/mfd_sipomuxgp_workq.c | 29 ++ dts/bindings/mfd/sipo-mux-gp-spi.yaml | 18 + dts/bindings/mfd/sipo-mux-gp.yaml | 85 +++++ include/zephyr/drivers/mfd/sipomuxgp.h | 110 ++++++ 11 files changed, 1010 insertions(+) create mode 100644 drivers/mfd/Kconfig.sipomuxgp create mode 100644 drivers/mfd/mfd_sipomuxgp.c create mode 100644 drivers/mfd/mfd_sipomuxgp.h create mode 100644 drivers/mfd/mfd_sipomuxgp_spi.c create mode 100644 drivers/mfd/mfd_sipomuxgp_spi.h create mode 100644 drivers/mfd/mfd_sipomuxgp_workq.c create mode 100644 dts/bindings/mfd/sipo-mux-gp-spi.yaml create mode 100644 dts/bindings/mfd/sipo-mux-gp.yaml create mode 100644 include/zephyr/drivers/mfd/sipomuxgp.h diff --git a/drivers/mfd/CMakeLists.txt b/drivers/mfd/CMakeLists.txt index 54b8641913..9916467089 100644 --- a/drivers/mfd/CMakeLists.txt +++ b/drivers/mfd/CMakeLists.txt @@ -7,3 +7,6 @@ zephyr_library_amend() zephyr_library_sources_ifdef(CONFIG_MFD_DS3231 mfd_ds3231.c) +zephyr_library_sources_ifdef(CONFIG_MFD_SIPOMUXGP mfd_sipomuxgp.c + mfd_sipomuxgp_workq.c) +zephyr_library_sources_ifdef(CONFIG_MFD_SIPOMUXGP_SPI mfd_sipomuxgp_spi.c) diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig index 0fb96fcf48..ba219baf68 100644 --- a/drivers/mfd/Kconfig +++ b/drivers/mfd/Kconfig @@ -4,5 +4,6 @@ if MFD rsource "Kconfig.ds3231" +rsource "Kconfig.sipomuxgp" endif # MFD diff --git a/drivers/mfd/Kconfig.sipomuxgp b/drivers/mfd/Kconfig.sipomuxgp new file mode 100644 index 0000000000..4eb0fc6799 --- /dev/null +++ b/drivers/mfd/Kconfig.sipomuxgp @@ -0,0 +1,63 @@ +# Generic latched SIPO/MUX GP matrix configuration options + +# Copyright (c) 2023 TiaC Systems +# SPDX-License-Identifier: Apache-2.0 + +menu "Generic latched SIPO/MUX GP matrix controller" + +config MFD_SIPOMUXGP + bool + help + Enable the generic latched SIPO/MUX General Purpose (GP) matrix + controller to have access to each GP signal individually. The + controller is implemented in software and supports currently + only outputs. + + Hidden configuration entry for all SIPO/MUX GP backend drivers. + +config MFD_SIPOMUXGP_XFR_WORKQUEUE_STACK_SIZE + int "Stack size for the transfer work queue" + default 1024 + depends on MFD_SIPOMUXGP + help + Size of the stack used for the internal SIPO/MUX GP transfer + work queue. + +config MFD_SIPOMUXGP_XFR_WORKQUEUE_NO_YIELD + bool "Select whether transfer work queue yields" + help + By default, the internal SIPO/MUX GP transfer work queue yields + between each work item, to prevent other threads from being starved. + Selecting this removes this yield, which may be useful if the work + queue thread is cooperative and a sequence of work items is expected + to complete without yielding. + +config MFD_SIPOMUXGP_XFR_WORKQUEUE_PRIORITY + int "Priority for transfer work queue" + default 0 if !COOP_ENABLED + default 8 + depends on MFD_SIPOMUXGP + help + Priority level of the internal SIPO/MUX GP transfer work queue. + +config MFD_SIPOMUXGP_INIT_PRIORITY + int "Initialization priority" + default MFD_INIT_PRIORITY + depends on MFD_SIPOMUXGP + help + Multi-function device initialization priority for the generic + latched SIPO/MUX General Purpose (GP) matrix controller. It + must be greater than the underlying controller init priority + of selected backend, e.g. SPI or GPIO. + +config MFD_SIPOMUXGP_SPI + bool "SPI driver backend" + default y + depends on DT_HAS_SIPO_MUX_GP_SPI_ENABLED + depends on SPI + select MFD_SIPOMUXGP + help + The SPI driver is portable, as long as a Zephyr SPI API driver + is available on the SoC. + +endmenu diff --git a/drivers/mfd/mfd_sipomuxgp.c b/drivers/mfd/mfd_sipomuxgp.c new file mode 100644 index 0000000000..95ad2884da --- /dev/null +++ b/drivers/mfd/mfd_sipomuxgp.c @@ -0,0 +1,495 @@ +/* + * Copyright (c) 2023 TiaC Systems + * SPDX-License-Identifier: Apache-2.0 + */ + +#include "mfd_sipomuxgp.h" + +#include +LOG_MODULE_REGISTER(mfd_sipomuxgp, CONFIG_MFD_LOG_LEVEL); + +/* + * multi functional interface --- main entries + */ + +int mfd_sipomuxgp_num_bits(const struct device *dev) +{ + const mfd_sipomuxgp_config_t * const config = dev->config; + + return config->num_bits; +} + +static int mfd_sipomuxgp_get_bit(const struct device *dev, + uint32_t bit, uint8_t *value); + +int mfd_sipomuxgp_bits(const struct device *dev, size_t offs, uint32_t *val) +{ + const mfd_sipomuxgp_config_t * const config = dev->config; + + if (offs >= (config->num_bits - NUM_BITS(uint32_t))) { + LOG_ERR("%s: invalid number of offset: got=%u, expected<%u", + dev->name, offs, config->num_bits - NUM_BITS(uint32_t)); + return -EINVAL; + } + + for (size_t idx = 0; idx < 32; idx++) { + uint8_t bit_val = 0; + mfd_sipomuxgp_get_bit(dev, idx + offs, &bit_val); + *val |= (bit_val << idx); + } + + return 0; +} + +static int mfd_sipomuxgp_set_bit(const struct device *dev, + uint32_t bit, uint8_t value); + +int mfd_sipomuxgp_bit_on(const struct device *dev, size_t bit) +{ + const mfd_sipomuxgp_config_t * const config = dev->config; + + if (bit >= config->num_bits) { + LOG_ERR("%s: invalid number of bit: got=%u, expected<%u", + dev->name, bit, config->num_bits); + return -EINVAL; + } + + return mfd_sipomuxgp_set_bit(dev, bit, 100); +} + +int mfd_sipomuxgp_bit_off(const struct device *dev, size_t bit) +{ + const mfd_sipomuxgp_config_t * const config = dev->config; + + if (bit >= config->num_bits) { + LOG_ERR("%s: invalid number of bit: got=%u, expected<%u", + dev->name, bit, config->num_bits); + return -EINVAL; + } + + return mfd_sipomuxgp_set_bit(dev, bit, 0); +} + +int mfd_sipomuxgp_xy_on(const struct device *dev, size_t x, size_t y) +{ + const mfd_sipomuxgp_config_t * const config = dev->config; + size_t bit = x + y * config->columns; + + if (x >= config->columns) { + LOG_ERR("%s: invalid number of x: got=%u, expected<%u", + dev->name, x, config->columns); + return -EINVAL; + } + + if (y >= config->rows) { + LOG_ERR("%s: invalid number of y: got=%u, expected<%u", + dev->name, y, config->rows); + return -EINVAL; + } + + return mfd_sipomuxgp_bit_on(dev, bit); +} + +int mfd_sipomuxgp_xy_off(const struct device *dev, size_t x, size_t y) +{ + const mfd_sipomuxgp_config_t * const config = dev->config; + size_t bit = x + y * config->columns; + + if (x >= config->columns) { + LOG_ERR("%s: invalid number of x: got=%u, expected<%u", + dev->name, x, config->columns); + return -EINVAL; + } + + if (y >= config->rows) { + LOG_ERR("%s: invalid number of y: got=%u, expected<%u", + dev->name, y, config->rows); + return -EINVAL; + } + + return mfd_sipomuxgp_bit_off(dev, bit); +} + +int mfd_sipomuxgp_output_ratio(const struct device *dev, uint8_t percent) +{ + mfd_sipomuxgp_data_t * const data = dev->data; + k_spinlock_key_t key; + + if (percent > 100) { + return -EINVAL; + } + + key = k_spin_lock(&data->lock); + data->oe_noblank = (percent > 0); + data->oe_noratio = (percent > 50); + k_spin_unlock(&data->lock, key); + + return 0; +} + +/* + * default data changing --- manipulate the bit matrix buffer + */ + +static int mfd_sipomuxgp_get_bit(const struct device *dev, + uint32_t bit, uint8_t *value) +{ + const mfd_sipomuxgp_config_t * const config = dev->config; + mfd_sipomuxgp_data_t * const data = dev->data; + k_spinlock_key_t key; + + if (!value) { + return -EINVAL; + } + + key = k_spin_lock(&data->lock); + + uint8_t byte = data->bitbuf[__BITBUF_IDX(bit, config->columns)]; + uint8_t bitv = (byte >> __BITBUF_BIT(bit, config->columns)); + *value = bitv & 1; + + k_spin_unlock(&data->lock, key); + return 0; +} + +static int mfd_sipomuxgp_set_bit(const struct device *dev, + uint32_t bit, uint8_t value) +{ + const mfd_sipomuxgp_config_t * const config = dev->config; + mfd_sipomuxgp_data_t * const data = dev->data; + k_spinlock_key_t key; + + if (value > 100) { + return -EINVAL; + } + + key = k_spin_lock(&data->lock); + + if (value > 0) { + data->bitbuf[__BITBUF_IDX(bit, config->columns)] + |= BIT(__BITBUF_BIT(bit, config->columns)); + } else { + data->bitbuf[__BITBUF_IDX(bit, config->columns)] + &= ~BIT(__BITBUF_BIT(bit, config->columns)); + } + + LOG_HEXDUMP_DBG(data->bitbuf, data->bitbuf_sz, "bitbuf"); + + k_spin_unlock(&data->lock, key); + return 0; +} + +/* + * default data output prcessing --- calling the data transfer from backend + */ + +static void mfd_sipomuxgp_process(const struct device *dev) +{ + const mfd_sipomuxgp_config_t * const config = dev->config; + mfd_sipomuxgp_data_t * const data = dev->data; + uint8_t *col_data; + size_t col_count; + k_spinlock_key_t key; + + key = k_spin_lock(&data->lock); + + col_count = __TOTAL_BYTES(config->columns); + col_data = &data->bitbuf[data->row_count * col_count]; + + config->backend.xfr_data(dev, data->row_count, col_data, col_count, + data->padding_sz); + + if (++data->row_count >= config->rows) { + data->row_count = 0; + data->oe_count++; + } + + k_spin_unlock(&data->lock, key); +} + +/* + * default signal handling --- configure and setup hardware signals + */ + +static int mfd_sipomuxgp_set_oe(const struct device *dev, const uint8_t value) +{ + const mfd_sipomuxgp_config_t * const config = dev->config; + mfd_sipomuxgp_data_t * const data = dev->data; + uint8_t enable; + int ret; + + enable = value && data->oe_noblank && (data->oe_noratio || \ + (data->oe_count % 2)); + ret = gpio_pin_set_dt(&config->enable, enable); + if (ret < 0) { + LOG_ERR("%s: can't %s output!", dev->name, + value ? "enable" : "disable"); + return ret; + } + + return 0; +} + +static int mfd_sipomuxgp_set_addr(const struct device *dev, const uint8_t addr) +{ + const mfd_sipomuxgp_config_t * const config = dev->config; + int ret; + + for (size_t addr_bit = 0; addr_bit < config->num_addr; addr_bit++) { + + ret = gpio_pin_set_dt(&config->addr[addr_bit], + ((addr >> addr_bit) & 1)); + if (ret < 0) { + LOG_ERR("%s: can't change address bit %u!", dev->name, + addr_bit); + return ret; + } + } + + return 0; +} + +static int mfd_sipomuxgp_cfg_oe(const struct device *dev) +{ + const mfd_sipomuxgp_config_t * const config = dev->config; + int ret; + + if (!gpio_is_ready_dt(&config->enable)) { + LOG_ERR("%s: GPIO pin: %s not ready", dev->name, + config->enable.port ? config->enable.port->name : + "null"); + return -ENODEV; + } + + ret = gpio_pin_configure_dt(&config->enable, GPIO_OUTPUT_INACTIVE); + if (ret < 0) { + LOG_ERR("%s: can't configure enable pin %d as output", + dev->name, config->enable.pin); + return ret; + } + + LOG_DBG("%s: ready with GPIO enable over %s at pin %d!", dev->name, + config->enable.port ? config->enable.port->name : "null", + config->enable.pin); + return 0; +} + +static int mfd_sipomuxgp_cfg_addr(const struct device *dev) +{ + const mfd_sipomuxgp_config_t * const config = dev->config; + int ret; + + for (size_t addr_idx = 0; addr_idx < config->num_addr; addr_idx++) { + if (!gpio_is_ready_dt(&config->addr[addr_idx])) { + LOG_ERR("%s: GPIO pin: %s not ready", dev->name, + config->addr[addr_idx].port ? + config->addr[addr_idx].port->name : "null"); + return -ENODEV; + } + + ret = gpio_pin_configure_dt(&config->addr[addr_idx], + GPIO_OUTPUT_INACTIVE); + if (ret < 0) { + LOG_ERR("%s: can't configure address pin %d as output", + dev->name, config->addr[addr_idx].pin); + return ret; + } + + LOG_DBG("%s: ready with GPIO address bit %d over %s at pin %d!", + dev->name, addr_idx, config->addr[addr_idx].port ? + config->addr[addr_idx].port->name : "null", + config->addr[addr_idx].pin); + } + return 0; +} + +/* + * internal driver mechanic --- timed worker to tirgger the refresh processing + */ + +static void mfd_sipomuxgp_refresh_worker(struct k_work *work) +{ + mfd_sipomuxgp_data_t * const data = + CONTAINER_OF(work, mfd_sipomuxgp_data_t, refresh_worker); + + /* Processing the SIPO/MOX data, put out the data on hardware. */ + mfd_sipomuxgp_process(data->dev); +} + +static void mfd_sipomuxgp_refresh_timer(struct k_timer *timer) +{ + mfd_sipomuxgp_data_t * const data = + CONTAINER_OF(timer, mfd_sipomuxgp_data_t, refresh_timer); + + /* Submit the SIPO/MOX data processing worker to the system queue. */ + k_work_submit_to_queue(&mfd_sipomuxgp_xfr_workq, &data->refresh_worker); +} + +/* + * driver initialization --- configure and setup internal driver mechanic + */ + +static int mfd_sipomuxgp_init(const struct device *dev) +{ + const mfd_sipomuxgp_config_t * const config = dev->config; + mfd_sipomuxgp_data_t * const data = dev->data; + k_spinlock_key_t key; + int ret; + + ret = config->backend.init(dev); + if (ret < 0) { + return ret; + } + + key = k_spin_lock(&data->lock); + + if (config->num_bits != config->columns * config->rows) { + LOG_ERR("%s: invalid columns (%u) or rows (%u)", + dev->name, config->columns, config->rows); + return -EINVAL; + } + + data->row_count = 0; + data->dev = dev; + + k_work_init(&data->refresh_worker, mfd_sipomuxgp_refresh_worker); + k_timer_init(&data->refresh_timer, mfd_sipomuxgp_refresh_timer, NULL); + k_timer_start(&data->refresh_timer, K_NO_WAIT, + K_USEC(data->refresh_time_us)); + + k_spin_unlock(&data->lock, key); + + LOG_DBG("%s: ready for %u x %u (%u) bit!", dev->name, + config->rows, config->columns, config->num_bits); + LOG_DBG("%s: - with bit buffer of %u byte%s", dev->name, + data->bitbuf_sz, data->bitbuf_sz > 1 ? "s" : ""); + LOG_DBG("%s: - with zero padding of %u byte%s", dev->name, + data->padding_sz, data->padding_sz > 1 ? "s" : ""); + return 0; +} + +#ifdef CONFIG_PM_DEVICE +static int mfd_sipomuxgp_pm_device_pm_action(const struct device *dev, + enum pm_device_action action) +{ + ARG_UNUSED(dev); + ARG_UNUSED(action); + + return 0; +} +#endif + +#define INST_DT_SIPOMUXGP(n, b) DT_INST(n, sipo_mux_gp_##b) + +#define MFD_SIPOMUXGP_CTX_SPEC_ELEM(_node_id, _prop, _idx) \ + GPIO_DT_SPEC_GET_BY_IDX(_node_id, _prop, _idx), + +#define MFD_SIPOMUXGP_CTX_FOREACH_ELEM(n, b, p) \ + DT_FOREACH_PROP_ELEM(INST_DT_SIPOMUXGP(n, b), p, \ + MFD_SIPOMUXGP_CTX_SPEC_ELEM) + +#define MFD_SIPOMUXGP_CTX_GPIOS_ADDR(n, b) \ + (const struct gpio_dt_spec[]){ \ + MFD_SIPOMUXGP_CTX_FOREACH_ELEM(n, b, addr_gpios) \ + } + +#define MFD_SIPOMUXGP_CTX_GPIO_ENABLE(n, b) \ + GPIO_DT_SPEC_GET_OR(INST_DT_SIPOMUXGP(n, b), oe_gpios, {0}) + +#define MFD_SIPOMUXGP_CTX_NUM_ADDR(n, b) \ + DT_PROP_LEN(INST_DT_SIPOMUXGP(n, b), addr_gpios) + +#define MFD_SIPOMUXGP_CTX_ROWS(n, b) \ + BIT(MFD_SIPOMUXGP_CTX_NUM_ADDR(n, b)) + +#define MFD_SIPOMUXGP_CTX_COLUMNS(n, b) \ + DT_PROP(INST_DT_SIPOMUXGP(n, b), data_width) + +#define MFD_SIPOMUXGP_CTX_NUM_BITS(n, b) \ + (MFD_SIPOMUXGP_CTX_ROWS(n, b) * MFD_SIPOMUXGP_CTX_COLUMNS(n, b)) + +#define MFD_SIPOMUXGP_CTX_BITBUF_SZ(n, b) \ + (__TOTAL_BYTES(MFD_SIPOMUXGP_CTX_NUM_BITS(n, b))) + +#define MFD_SIPOMUXGP_CTX_BITBUF(n, b) \ + (uint8_t [(MFD_SIPOMUXGP_CTX_BITBUF_SZ(n, b))]){} + +#define MFD_SIPOMUXGP_CTX_SHIFTING(n, b) \ + DT_PROP(INST_DT_SIPOMUXGP(n, b), shift_width) + +#define MFD_SIPOMUXGP_CTX_PADDING(n, b) \ + (MFD_SIPOMUXGP_CTX_SHIFTING(n, b) - MFD_SIPOMUXGP_CTX_COLUMNS(n, b)) + +#define MFD_SIPOMUXGP_CTX_PADDING_SZ(n, b) \ + (__TOTAL_BYTES(MFD_SIPOMUXGP_CTX_PADDING(n, b))) + +#define MFD_SIPOMUXGP_CTX_RFSTIME(n, b) \ + DT_PROP(INST_DT_SIPOMUXGP(n, b), refresh_time_us) + +#define MFD_SIPOMUXGP_CTX_BACKEND(n, b) { \ + .config = (const void *)&mfd_sipomuxgp_##b##_config_##n, \ + .init = mfd_sipomuxgp_##b##_init, \ + .cfg_oe = mfd_sipomuxgp_##b##_cfg_oe, \ + .cfg_addr = mfd_sipomuxgp_##b##_cfg_addr, \ + .set_oe = mfd_sipomuxgp_##b##_set_oe, \ + .set_addr = mfd_sipomuxgp_##b##_set_addr, \ + .xfr_data = mfd_sipomuxgp_##b##_transmit, \ + } + + +#define SIPOMUXGP_INIT(n, b) \ + MFD_SIPOMUXGP_##b##_CFG_INIT(n, b); \ + \ + static const mfd_sipomuxgp_config_t mfd_sipomuxgp_config_##n = { \ + .addr = MFD_SIPOMUXGP_CTX_GPIOS_ADDR(n, b), \ + .enable = MFD_SIPOMUXGP_CTX_GPIO_ENABLE(n, b), \ + .num_addr = MFD_SIPOMUXGP_CTX_NUM_ADDR(n, b), \ + .num_bits = MFD_SIPOMUXGP_CTX_NUM_BITS(n, b), \ + .columns = MFD_SIPOMUXGP_CTX_COLUMNS(n, b), \ + .rows = MFD_SIPOMUXGP_CTX_ROWS(n, b), \ + .backend = MFD_SIPOMUXGP_CTX_BACKEND(n, b), \ + }; \ + \ + BUILD_ASSERT(500 <= MFD_SIPOMUXGP_CTX_RFSTIME(n, b), \ + "Bad refresh time, refresh-time-us must be >= 500 usec"); \ + \ + BUILD_ASSERT(0 < MFD_SIPOMUXGP_CTX_ROWS(n, b), \ + "Bad rows, addr-gpios needs at least one entry"); \ + \ + BUILD_ASSERT(8 <= MFD_SIPOMUXGP_CTX_COLUMNS(n, b), \ + "Bad columns, data-width must be equal or greater than 8"); \ + \ + BUILD_ASSERT( MFD_SIPOMUXGP_CTX_COLUMNS(n, b) \ + <= MFD_SIPOMUXGP_CTX_SHIFTING(n, b), \ + "Too many bits, data-width does not fit into shift-width"); \ + \ + static mfd_sipomuxgp_data_t mfd_sipomuxgp_data_##n = { \ + .refresh_time_us = MFD_SIPOMUXGP_CTX_RFSTIME(n, b), \ + .padding_sz = MFD_SIPOMUXGP_CTX_PADDING_SZ(n, b), \ + .bitbuf_sz = MFD_SIPOMUXGP_CTX_BITBUF_SZ(n, b), \ + .bitbuf = MFD_SIPOMUXGP_CTX_BITBUF(n, b), \ + .oe_noblank = true, \ + .oe_noratio = true, \ + .oe_count = 0, \ + }; \ + \ + PM_DEVICE_DT_DEFINE(INST_DT_SIPOMUXGP(n, b), \ + mfd_sipomuxgp_pm_device_pm_action); \ + \ + DEVICE_DT_DEFINE(INST_DT_SIPOMUXGP(n, b), mfd_sipomuxgp_init, \ + PM_DEVICE_DT_GET(INST_DT_SIPOMUXGP(n, b)), \ + &mfd_sipomuxgp_data_##n, \ + &mfd_sipomuxgp_config_##n, POST_KERNEL, \ + CONFIG_MFD_SIPOMUXGP_INIT_PRIORITY, NULL) + +#define DT_INST_FOREACH_SIPOMUXGP_STATUS_OKAY(b) LISTIFY( \ + DT_NUM_INST_STATUS_OKAY(sipo_mux_gp_##b), SIPOMUXGP_INIT, (;), b) + +#ifdef CONFIG_MFD_SIPOMUXGP_SPI +#include "mfd_sipomuxgp_spi.h" +#define mfd_sipomuxgp_spi_cfg_oe mfd_sipomuxgp_cfg_oe +#define mfd_sipomuxgp_spi_cfg_addr mfd_sipomuxgp_cfg_addr +#define mfd_sipomuxgp_spi_set_oe mfd_sipomuxgp_set_oe +#define mfd_sipomuxgp_spi_set_addr mfd_sipomuxgp_set_addr +DT_INST_FOREACH_SIPOMUXGP_STATUS_OKAY(spi); +#endif diff --git a/drivers/mfd/mfd_sipomuxgp.h b/drivers/mfd/mfd_sipomuxgp.h new file mode 100644 index 0000000000..0a5e948e6d --- /dev/null +++ b/drivers/mfd/mfd_sipomuxgp.h @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2023 TiaC Systems + * SPDX-License-Identifier: Apache-2.0 + */ + +#ifndef DRIVERS_MFD_MFD_SIPOMUXGP_H_ +#define DRIVERS_MFD_MFD_SIPOMUXGP_H_ + +#include +#include +#include + +#include +#include + +#include + +#include + +typedef struct mfd_sipomuxgp_backend { + const void *config; + int (*init)(const struct device *dev); + int (*cfg_oe)(const struct device *dev); + int (*cfg_addr)(const struct device *dev); + int (*set_oe)(const struct device *dev, const uint8_t value); + int (*set_addr)(const struct device *dev, const uint8_t addr); + int (*xfr_data)(const struct device *dev, const uint8_t addr, + const uint8_t *tx_data, const size_t tx_count, + const size_t padding_sz); +} mfd_sipomuxgp_backend_t; + +typedef struct mfd_sipomuxgp_config { + const mfd_sipomuxgp_backend_t backend; + const struct gpio_dt_spec enable; + const struct gpio_dt_spec *addr; + const size_t num_addr; + const size_t num_bits; + const size_t columns; + const size_t rows; +} mfd_sipomuxgp_config_t; + +typedef struct mfd_sipomuxgp_data { + const struct device *dev; + struct k_spinlock lock; + struct k_work refresh_worker; + struct k_timer refresh_timer; + uint32_t refresh_time_us; + const size_t padding_sz; + const size_t bitbuf_sz; + uint8_t *bitbuf; + size_t row_count; + bool oe_noblank; + bool oe_noratio; + uint8_t oe_count; +} mfd_sipomuxgp_data_t; + +#define __BITBUF_COL(bit,cols) ((bit) % (cols)) +#define __BITBUF_ROW(bit,cols) ((bit) / (cols)) +#define __BITBUF_BIT(bit,cols) ( \ + (NUM_BITS(uint8_t) - 1) \ + - (((bit) % (cols)) % NUM_BITS(uint8_t)) \ + ) +#define __BITBUF_IDX(bit,cols) ( \ + (__BITBUF_COL((bit),(cols)) / NUM_BITS(uint8_t)) \ + + (__BITBUF_ROW((bit),(cols)) * ((cols) / NUM_BITS(uint8_t)))\ + ) + +#define __TOTAL_BYTES(total_bits) (DIV_ROUND_UP(DIV_ROUND_UP( \ + total_bits, NUM_BITS(uint8_t)), sizeof(uint8_t)) \ + ) + +extern struct k_work_q mfd_sipomuxgp_xfr_workq; + +#define MFD_SIPOMUXGP_NUM_INSTS ( \ + DT_NUM_INST_STATUS_OKAY(sipo_mux_gp) \ + + DT_NUM_INST_STATUS_OKAY(sipo_mux_gp_spi) \ + ) + +#endif /* DRIVERS_MFD_MFD_SIPOMUXGP_H_ */ diff --git a/drivers/mfd/mfd_sipomuxgp_spi.c b/drivers/mfd/mfd_sipomuxgp_spi.c new file mode 100644 index 0000000000..63b6710c64 --- /dev/null +++ b/drivers/mfd/mfd_sipomuxgp_spi.c @@ -0,0 +1,95 @@ +/* + * Copyright (c) 2023 TiaC Systems + * SPDX-License-Identifier: Apache-2.0 + */ + +#include "mfd_sipomuxgp_spi.h" + +#include +LOG_MODULE_REGISTER(mfd_sipomuxgp_spi, CONFIG_MFD_LOG_LEVEL); + +int mfd_sipomuxgp_spi_transmit(const struct device *dev, const uint8_t addr, + const uint8_t *tx_data, const size_t tx_count, + const size_t padding_sz) +{ + const mfd_sipomuxgp_config_t * const config = dev->config; + const mfd_sipomuxgp_spi_config_t * const backend_config = + (const mfd_sipomuxgp_spi_config_t *)config->backend.config; + uint8_t padbuf[padding_sz]; + struct spi_buf tx_buf[2] = { + [0] = { .buf = (void *)tx_data, .len = tx_count }, + [1] = { .buf = (void *)&padbuf, .len = ARRAY_SIZE(padbuf) }, + }; + struct spi_buf_set tx_bufs = { .buffers = &tx_buf[0], .count = 2U }; + int ret = 0; + + /* initialize 'zero' padding buffer (if ARRAY_SIZE() > 0) */ + memset(padbuf, 0, ARRAY_SIZE(padbuf)); + + /* disable output drivers before data will be changed */ + if ((ret = config->backend.set_oe(dev, 0)) < 0) return ret; + + /* stream out new data (if any) */ + if (tx_data != NULL) { + ret = spi_write_dt(&backend_config->bus, &tx_bufs); + if (ret < 0) { + LOG_ERR("%s: can't shift data bits!", dev->name); + return ret; + } + } + + /* set new address */ + if ((ret = config->backend.set_addr(dev, addr)) < 0) return ret; + + /* enable output drivers after data were changed */ + if ((ret = config->backend.set_oe(dev, 1)) < 0) return ret; + + return 0; +} + +int mfd_sipomuxgp_spi_init(const struct device *dev) +{ + const mfd_sipomuxgp_config_t * const config = dev->config; + const mfd_sipomuxgp_spi_config_t * const backend_config = + (const mfd_sipomuxgp_spi_config_t *)config->backend.config; + int ret; + + /* verify backup configuration */ + if (!backend_config) { + LOG_ERR("%s: backend: missing SPI configuration", dev->name); + } + + if (!config->backend.cfg_oe) { + LOG_ERR("%s: backend: missing cfg_oe() callback", dev->name); + } + + if (!config->backend.cfg_addr) { + LOG_ERR("%s: backend: missing cfg_addr() callback", dev->name); + } + + if (!config->backend.set_oe) { + LOG_ERR("%s: backend: missing set_oe() callback", dev->name); + } + + if (!config->backend.set_addr) { + LOG_ERR("%s: backend: missing set_addr() callback", dev->name); + } + + if (!config->backend.xfr_data) { + LOG_ERR("%s: backend: missing xfr_data() callback", dev->name); + } + + /* configure backup resources */ + if ((ret = config->backend.cfg_oe(dev)) < 0) return ret; + if ((ret = config->backend.cfg_addr(dev)) < 0) return ret; + + if (!spi_is_ready_dt(&backend_config->bus)) { + LOG_ERR("%s: SPI device %s not ready", dev->name, + backend_config->bus.bus->name); + return -ENODEV; + } + + LOG_DBG("%s: ready with SPI backend over %s!", dev->name, + backend_config->bus.bus->name); + return 0; +} diff --git a/drivers/mfd/mfd_sipomuxgp_spi.h b/drivers/mfd/mfd_sipomuxgp_spi.h new file mode 100644 index 0000000000..8c0585fa7b --- /dev/null +++ b/drivers/mfd/mfd_sipomuxgp_spi.h @@ -0,0 +1,32 @@ +/* + * Copyright (c) 2023 TiaC Systems + * SPDX-License-Identifier: Apache-2.0 + */ + +#ifndef DRIVERS_MFD_MFD_SIPOMUXGP_SPI_H_ +#define DRIVERS_MFD_MFD_SIPOMUXGP_SPI_H_ + +#include "mfd_sipomuxgp.h" + +#include + +typedef struct mfd_sipomuxgp_spi_config { + const struct spi_dt_spec bus; +} mfd_sipomuxgp_spi_config_t; + +#define MFD_SIPOMUXGP_spi_CFG_INIT(n, b) \ + static const mfd_sipomuxgp_spi_config_t \ + mfd_sipomuxgp_spi_config_##n = \ + { \ + .bus = SPI_DT_SPEC_GET(INST_DT_SIPOMUXGP(n, b), \ + SPI_OP_MODE_MASTER | \ + SPI_TRANSFER_MSB | \ + SPI_WORD_SET(8), 0), \ + }; + +int mfd_sipomuxgp_spi_init(const struct device *dev); +int mfd_sipomuxgp_spi_transmit(const struct device *dev, const uint8_t addr, + const uint8_t *tx_data, const size_t tx_count, + const size_t padding_sz); + +#endif /* DRIVERS_MFD_MFD_SIPOMUXGP_SPI_H_ */ diff --git a/drivers/mfd/mfd_sipomuxgp_workq.c b/drivers/mfd/mfd_sipomuxgp_workq.c new file mode 100644 index 0000000000..90e1e68de1 --- /dev/null +++ b/drivers/mfd/mfd_sipomuxgp_workq.c @@ -0,0 +1,29 @@ +/* + * Copyright (c) 2023 TiaC Systems + * SPDX-License-Identifier: Apache-2.0 + */ + +#include "mfd_sipomuxgp.h" + +#include + +struct k_work_q mfd_sipomuxgp_xfr_workq; +static K_KERNEL_STACK_DEFINE(mfd_sipomuxgp_xfr_workq_stack, + MFD_SIPOMUXGP_NUM_INSTS * CONFIG_MFD_SIPOMUXGP_XFR_WORKQUEUE_STACK_SIZE); + +static int mfd_sipomuxgp_xfr_workq_init(void) +{ + struct k_work_queue_config config = { + .name = "mfd_sipomuxgp_xfr_workq", + .no_yield = IS_ENABLED(CONFIG_MFD_SIPOMUXGP_XFR_WORKQUEUE_NO_YIELD), + }; + + k_work_queue_start(&mfd_sipomuxgp_xfr_workq, + mfd_sipomuxgp_xfr_workq_stack, + K_KERNEL_STACK_SIZEOF(mfd_sipomuxgp_xfr_workq_stack), + K_PRIO_COOP(CONFIG_MFD_SIPOMUXGP_XFR_WORKQUEUE_PRIORITY), + &config); + return 0; +} + +SYS_INIT(mfd_sipomuxgp_xfr_workq_init, POST_KERNEL, CONFIG_KERNEL_INIT_PRIORITY_DEFAULT); diff --git a/dts/bindings/mfd/sipo-mux-gp-spi.yaml b/dts/bindings/mfd/sipo-mux-gp-spi.yaml new file mode 100644 index 0000000000..e653983a3d --- /dev/null +++ b/dts/bindings/mfd/sipo-mux-gp-spi.yaml @@ -0,0 +1,18 @@ +# Copyright (c) 2023 TiaC Systems +# SPDX-License-Identifier: Apache-2.0 + +description: | + Generic latched SIPO/MUX GP matrix controller, SPI binding + + Driver bindings for controlling a latched SIPO/MUX General + Purpose (GP) matrix with a SPI master. + + The SPI driver should be usable as long as a Zephyr SPI API + driver is available for your board. Hardware specific tuning + is required using these properties: + + - spi-max-frequency + +compatible: "sipo-mux-gp-spi" + +include: [spi-device.yaml, sipo-mux-gp.yaml] diff --git a/dts/bindings/mfd/sipo-mux-gp.yaml b/dts/bindings/mfd/sipo-mux-gp.yaml new file mode 100644 index 0000000000..60a67e2a2d --- /dev/null +++ b/dts/bindings/mfd/sipo-mux-gp.yaml @@ -0,0 +1,85 @@ +# Copyright (c) 2023 TiaC Systems +# SPDX-License-Identifier: Apache-2.0 + +description: | + Generic latched SIPO/MUX GP matrix controller + + General Purpose (GP) matrix controller, implemented in software, + using a latched serial-in-parallel-out shift register (SIPO) for + the data (columns) and a multiplexing (MUX) X:1-of-2^X decoder + for the addresses (rows). + + shift-width + ,----------------------´`----------------------, + + data-width + ,----------´`----------, + + 0 1 2 3 4 5 6 7 + +-----+ | | | | | | | | + A0 -+ +--<--<--<--<--<--<--<--<--0 + A1 -+ MUX | | | | | | | | | + | +--<--<--<--<--<--<--<--<--1 + | DEC | | | | | | | | | + | +--<--<--<--<--<--<--<--<--2 + | DRV | | | | | | | | | + | +--<--<--<--<--<--<--<--<--3 + +-----+ | | | | | | | | + +-+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ + SDI --------+ D0 D1 D2 D3 D4 D5 D6 D7 D8 D9 Da Db Dc Dd De Df +- SDO + CLK --------+ | + (nCS) LE --------+ SIPO shift register (DRV) | + /OE --------+ | + +-------------------------------------------------+ + + - example for the MUX/DEC LED driver: Sunmoon SM5166P + - example for the SIPO/SR LED driver: Sunmoon SM16106, SM16206, SM16306 + +properties: + shift-width: + type: int + required: true + enum: + - 8 + - 16 + - 24 + - 32 + description: | + Width of columns bits totally shifted out by the SIPO shift register. + This value must be equal or greater then the data width. + + data-width: + type: int + required: true + enum: + - 8 + - 16 + - 24 + - 32 + description: | + Width of columns data bits shifted out by the SIPO shift register and + usable on hardware in reality. + + addr-gpios: + type: phandle-array + required: true + description: | + GPIO phandle and specifier for the pins connected to the rows + address MUX decoder pins. At least one pin should be given for + a single or two rows. Pins of multiples of two should be given + for more rows. + + oe-gpios: + type: phandle-array + required: true + description: | + GPIO phandle and specifier for the pin connected to the columns + data SIPO shift register's output enable pin. Exactly one pin + should be given. + + refresh-time-us: + type: int + default: 1000 + description: | + How often to iterate over the addresses and refresh the data + signal lines. diff --git a/include/zephyr/drivers/mfd/sipomuxgp.h b/include/zephyr/drivers/mfd/sipomuxgp.h new file mode 100644 index 0000000000..875a3de8cd --- /dev/null +++ b/include/zephyr/drivers/mfd/sipomuxgp.h @@ -0,0 +1,110 @@ +/* + * Copyright (c) 2023 TiaC Systems + * SPDX-License-Identifier: Apache-2.0 + */ +#ifndef ZEPHYR_INCLUDE_DRIVERS_MFD_SIPOMUXGP_H_ +#define ZEPHYR_INCLUDE_DRIVERS_MFD_SIPOMUXGP_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @defgroup mdf_interface_sipomuxgp MFD SIPO/MUX GP Interface + * @ingroup mfd_interfaces + * @{ + */ + +#include +#include + +#include + +/** + * @brief Get number of available bits from SIPO/MUX GP + * + * @param dev sipomuxgp mfd device + * @retval num_bits Number of bits + */ +int mfd_sipomuxgp_num_bits(const struct device *dev); + +/** + * @brief Read 32 bits from SIPO/MUX GP + * + * @param dev sipomuxgp mfd device + * @param offs Offset number where starting to read bits + * @param val Pointer to buffer for exactly 32-bit data + * @retval 0 If successful + * @retval -errno In case of any error + */ +int mfd_sipomuxgp_bits(const struct device *dev, size_t offs, uint32_t *val); + +/** + * @brief Write logical one to a single bit on SIPO/MUX GP + * + * @param dev sipomuxgp mfd device + * @param bit Number of the bit where to write logical one + * @retval 0 If successful + * @retval -errno In case of any error + */ +int mfd_sipomuxgp_bit_on(const struct device *dev, size_t bit); + +/** + * @brief Write logical zero to a single bit on SIPO/MUX GP + * + * @param dev sipomuxgp mfd device + * @param bit Number of the bit where to write logical zero + * @retval 0 If successful + * @retval -errno In case of any error + */ +int mfd_sipomuxgp_bit_off(const struct device *dev, size_t bit); + +/** + * @brief Write logical one to a single XY position on SIPO/MUX GP + * + * @param dev sipomuxgp mfd device + * @param x Number of the X coordinate where to write logical one + * @param y Number of the Y coordinate where to write logical one + * @retval 0 If successful + * @retval -errno In case of any error + */ +int mfd_sipomuxgp_xy_on(const struct device *dev, size_t x, size_t y); + +/** + * @brief Write logical zero to a single XY position on SIPO/MUX GP + * + * @param dev sipomuxgp mfd device + * @param x Number of the X coordinate where to write logical zero + * @param y Number of the Y coordinate where to write logical zero + * @retval 0 If successful + * @retval -errno In case of any error + */ +int mfd_sipomuxgp_xy_off(const struct device *dev, size_t x, size_t y); + +/** + * @brief Change ratio of SIPO/MUX GP output enable signal + * + * The percentage value affects the duty cycle of the outgoing data. + * If the matrix is used to drive LEDs, for example, this affects the + * brightness. + * + * Only three ratios are supported due to the time critical design: + * + * - full force (100%), or + * - half force (50%), or + * - none (0%) + * + * @param dev sipomuxgp mfd device + * @param percent Percentage ratio of the ON phase + * @retval 0 If successful + * @retval -errno In case of any error + */ +int mfd_sipomuxgp_output_ratio(const struct device *dev, uint8_t percent); + +/** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* ZEPHYR_INCLUDE_DRIVERS_MFD_SIPOMUXGP_H_ */ From 64c4a10482688d5298b92e993d967a5c70ad8241 Mon Sep 17 00:00:00 2001 From: Stephan Linz Date: Fri, 29 Dec 2023 13:49:44 +0100 Subject: [PATCH 09/13] drivers: gpio: sipomux: add SIPO/MUX GPIO controller Add initial GPIO driver for using a SIPO/MUX GP matrix as GPIO controller. Signed-off-by: Stephan Linz --- drivers/gpio/CMakeLists.txt | 1 + drivers/gpio/Kconfig | 1 + drivers/gpio/Kconfig.sipomux | 20 ++ drivers/gpio/gpio_sipomux.c | 266 +++++++++++++++++++++++++++ dts/bindings/gpio/sipo-mux-gpio.yaml | 25 +++ 5 files changed, 313 insertions(+) create mode 100644 drivers/gpio/Kconfig.sipomux create mode 100644 drivers/gpio/gpio_sipomux.c create mode 100644 dts/bindings/gpio/sipo-mux-gpio.yaml diff --git a/drivers/gpio/CMakeLists.txt b/drivers/gpio/CMakeLists.txt index a92043d99e..d10b46d790 100644 --- a/drivers/gpio/CMakeLists.txt +++ b/drivers/gpio/CMakeLists.txt @@ -8,3 +8,4 @@ zephyr_library_amend() zephyr_library_sources_ifdef(CONFIG_GPIO_PCA9554 gpio_pca9554.c) zephyr_library_sources_ifdef(CONFIG_GPIO_PCA9555 gpio_pca9555.c) +zephyr_library_sources_ifdef(CONFIG_GPIO_SIPOMUX gpio_sipomux.c) diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig index 2288d88016..fcd5f7a6e8 100644 --- a/drivers/gpio/Kconfig +++ b/drivers/gpio/Kconfig @@ -5,5 +5,6 @@ if GPIO rsource "Kconfig.pca9554" rsource "Kconfig.pca9555" +rsource "Kconfig.sipomux" endif # GPIO diff --git a/drivers/gpio/Kconfig.sipomux b/drivers/gpio/Kconfig.sipomux new file mode 100644 index 0000000000..265b3c2ab7 --- /dev/null +++ b/drivers/gpio/Kconfig.sipomux @@ -0,0 +1,20 @@ +# Latched SIPO/MUX GPIO configuration options + +# Copyright (c) 2023 TiaC Systems +# SPDX-License-Identifier: Apache-2.0 + +menuconfig GPIO_SIPOMUX + bool "Generic latched SIPO/MUX GPIO controller" + default y + depends on DT_HAS_SIPO_MUX_GPIO_ENABLED + select MFD + help + Enable the generic latched SIPO/MUX GPIO driver. + +config GPIO_SIPOMUX_INIT_PRIORITY + int "Initialization priority" + default 85 + depends on GPIO_SIPOMUX + help + Initialization priority for the generic latched SIPO/MUX GPIO + driver. It must be greater than the MFD controller init priority. diff --git a/drivers/gpio/gpio_sipomux.c b/drivers/gpio/gpio_sipomux.c new file mode 100644 index 0000000000..e650acca67 --- /dev/null +++ b/drivers/gpio/gpio_sipomux.c @@ -0,0 +1,266 @@ +/* + * Copyright (c) 2023-2024 TiaC Systems + * SPDX-License-Identifier: Apache-2.0 + */ + +#define DT_DRV_COMPAT sipo_mux_gpio + +#include +#include +#include + +#include +#include + +#include + +#include +LOG_MODULE_REGISTER(gpio_sipomux, CONFIG_GPIO_LOG_LEVEL); + +/** + * @brief SIPO/MUX GPIO controller configuration data + * + * This structure contains all of the state for a given SIPO/MUX GPIO + * controller as well as all of the pins associated with it. + * + * @a num_pins must be in the range [1, @ref GPIO_MAX_PINS_PER_PORT]. + * + * @a num_offs must be in the range [1, SIPO/MUX GP maximum minus @a num_pins]. + * + * Pin direction as well as other pin properties are set using + * specific bits in @a flags. For more details, see @ref gpio_interface. + */ +typedef struct gpio_sipomux_config { + /** Common @ref gpio_driver_config (needs to be first) */ + struct gpio_driver_config common; + /** Number of pins available in the given GPIO controller instance */ + const gpio_pin_t num_pins; + /** Number of pins postponed in the given GPIO controller instance */ + const gpio_port_pins_t num_offs; + /** Backend MFD device for real operations on hardware */ + const struct device *mfd; +} gpio_sipomux_config_t; + +/** + * @brief SIPO/MUX GPIO controller data + * + * This structure contains data structures used by a SIPO/MUX GPIO + * controller. + * + * Changes are to @ref gpio_sipomux_data and @ref gpio_sipomux_config are + * synchronized using @a k_sem. + */ +typedef struct gpio_sipomux_data { + /** Common @ref gpio_driver_data (needs to be first) */ + struct gpio_driver_data common; + /** Semaphore to synchronize accesses to driver data and config */ + struct k_sem lock; + /** Variable for internal operations to avoid optimization effects */ + gpio_port_value_t value; +} gpio_sipomux_data_t; + +/* + * GPIO Driver API + * + * API is documented at drivers/gpio.h + */ + +static int gpio_sipomux_port_get_raw(const struct device *dev, + gpio_port_value_t *value) +{ + const gpio_sipomux_config_t * const config = dev->config; + + return mfd_sipomuxgp_bits(config->mfd, config->num_offs, value); +} + +static int gpio_sipomux_port_set_masked_raw(const struct device *dev, + gpio_port_pins_t mask, + gpio_port_value_t value) +{ + const gpio_sipomux_config_t * const config = dev->config; + gpio_sipomux_data_t * const data = dev->data; + int ret = 0; + + k_sem_take(&data->lock, K_FOREVER); + + for (size_t idx = 0; idx < config->num_pins; idx++) { + if ((mask & BIT(idx)) != 0U) { + if ((value & BIT(idx)) != 0U) { + ret = mfd_sipomuxgp_bit_on(config->mfd, + config->num_offs + idx); + } else { + ret = mfd_sipomuxgp_bit_off(config->mfd, + config->num_offs + idx); + } + if (ret != 0U) { + goto done; + } + } + } + +done: + k_sem_give(&data->lock); + return ret; +} + +static int gpio_sipomux_port_set_bits_raw(const struct device *dev, + gpio_port_pins_t pins) +{ + return gpio_sipomux_port_set_masked_raw(dev, pins, pins); +} + +static int gpio_sipomux_port_clear_bits_raw(const struct device *dev, + gpio_port_pins_t pins) +{ + return gpio_sipomux_port_set_masked_raw(dev, pins, 0U); +} + +static inline int gpio_sipomux_configure(const struct device *dev, + gpio_pin_t pin, gpio_flags_t flags) +{ + const gpio_sipomux_config_t * const config = dev->config; + gpio_sipomux_data_t * const data = dev->data; + int ret = 0; + + /* Can't do bus operations from an ISR */ + if (k_is_in_isr()) { + return -EWOULDBLOCK; + } + + if (pin >= config->num_pins) { + return -EINVAL; + } + + /* Does not support disconnected pin */ + if ((flags & (GPIO_INPUT | GPIO_OUTPUT)) == GPIO_DISCONNECTED) { + return -ENOTSUP; + } + + /* Does not support open-drain pin */ + if ((flags & GPIO_SINGLE_ENDED) != 0U) { + return -ENOTSUP; + } + + /* Does not support pulls-up/-down pin */ + if (((flags & GPIO_PULL_UP) != 0U) || + ((flags & GPIO_PULL_DOWN) != 0U)) { + return -ENOTSUP; + } + + k_sem_take(&data->lock, K_FOREVER); + + /* Configure mode */ + if ((flags & GPIO_INPUT) != 0U) { + ret = -ENOTSUP; + goto done; + } else if ((flags & GPIO_OUTPUT_INIT_HIGH) != 0U) { + ret = mfd_sipomuxgp_bit_on(config->mfd, + config->num_offs + pin); + } else if ((flags & GPIO_OUTPUT) != 0U) { + ret = mfd_sipomuxgp_bit_off(config->mfd, + config->num_offs + pin); + } + +done: + k_sem_give(&data->lock); + return ret; +} + +static int gpio_sipomux_port_toggle_bits(const struct device *dev, + gpio_port_pins_t pins) +{ + gpio_sipomux_data_t * const data = dev->data; + int ret; + + k_sem_take(&data->lock, K_FOREVER); + + ret = gpio_sipomux_port_get_raw(dev, &data->value); + if (ret < 0) { + return ret; + } + + data->value ^= pins; + + k_sem_give(&data->lock); + + return gpio_sipomux_port_set_masked_raw(dev, pins, data->value); +} + +static const struct gpio_driver_api gpio_sipomux_api = { + .pin_configure = gpio_sipomux_configure, + .port_get_raw = gpio_sipomux_port_get_raw, + .port_set_masked_raw = gpio_sipomux_port_set_masked_raw, + .port_set_bits_raw = gpio_sipomux_port_set_bits_raw, + .port_clear_bits_raw = gpio_sipomux_port_clear_bits_raw, + .port_toggle_bits = gpio_sipomux_port_toggle_bits, +}; + +static int gpio_sipomux_init(const struct device *dev) +{ + const gpio_sipomux_config_t * const config = dev->config; + gpio_sipomux_data_t * const data = dev->data; + size_t av_pins, rq_pins; + + if (!device_is_ready(config->mfd)) { + return -ENODEV; + } + + rq_pins = config->num_pins; + av_pins = mfd_sipomuxgp_num_bits(config->mfd) - config->num_offs; + + if (rq_pins > av_pins) { + LOG_ERR("%s: invalid number of requested pins: %u > %u", + dev->name, rq_pins, av_pins); + return -EINVAL; + } + + k_sem_init(&data->lock, 1, 1); + + LOG_DBG("%s: ready for %u pins with MFD backend over %s!", dev->name, + config->num_pins, config->mfd->name); + return 0; +} + +#ifdef CONFIG_PM_DEVICE +static int gpio_sipomux_pm_device_pm_action(const struct device *dev, + enum pm_device_action action) +{ + ARG_UNUSED(dev); + ARG_UNUSED(action); + + return 0; +} +#endif + +#if CONFIG_GPIO_SIPOMUX_INIT_PRIORITY <= CONFIG_MFD_SIPOMUXGP_INIT_PRIORITY +#error GPIO_SIPOMUX_INIT_PRIORITY must be greater than MFD_SIPOMUXGP_INIT_PRIORITY +#endif + +#define GPIO_SIPOMUX_DEFINE(n) \ + \ + static const gpio_sipomux_config_t gpio_sipomux_config_##n = \ + { \ + .common = { \ + .port_pin_mask = \ + GPIO_PORT_PIN_MASK_FROM_DT_INST(n), \ + }, \ + .num_pins = DT_INST_PROP(n, ngpios), \ + .num_offs = DT_INST_PROP(n, offset), \ + .mfd = DEVICE_DT_GET(DT_INST_PARENT(n)), \ + }; \ + BUILD_ASSERT( \ + DT_INST_PROP(n, ngpios) <= GPIO_MAX_PINS_PER_PORT, \ + "Too many ngpios"); \ + \ + static gpio_sipomux_data_t gpio_sipomux_data_##n; \ + \ + PM_DEVICE_DT_INST_DEFINE(n, gpio_sipomux_pm_device_pm_action); \ + \ + DEVICE_DT_INST_DEFINE(n, gpio_sipomux_init, \ + PM_DEVICE_DT_INST_GET(n), \ + &gpio_sipomux_data_##n, \ + &gpio_sipomux_config_##n, POST_KERNEL, \ + CONFIG_GPIO_SIPOMUX_INIT_PRIORITY, \ + &gpio_sipomux_api); + +DT_INST_FOREACH_STATUS_OKAY(GPIO_SIPOMUX_DEFINE) diff --git a/dts/bindings/gpio/sipo-mux-gpio.yaml b/dts/bindings/gpio/sipo-mux-gpio.yaml new file mode 100644 index 0000000000..bbe93e1c67 --- /dev/null +++ b/dts/bindings/gpio/sipo-mux-gpio.yaml @@ -0,0 +1,25 @@ +# Copyright (c) 2023 TiaC Systems +# SPDX-License-Identifier: Apache-2.0 + +description: Generic latched SIPO/MUX GPIO Controller + +compatible: "sipo-mux-gpio" + +include: [gpio-controller.yaml, base.yaml] + +gpio-cells: + - pin + - flags + +properties: + offset: + type: int + default: 0 + description: | + This property indicates the number of alway in-use slots of available + slots for GPIOs in the underlying SIPO/MUX GP Controller instance + by any GPIO previous declared nodes of this same class. The typical + example is something like this: the first node has register 32 GPIOs + with "ngpios = <32>;" and "offset = <0>;", the second node then have + to register their 32 GPIOs with "ngpios = <32>;" and "offset = <32>;" + and the third node with "ngpios = <32>;" and "offset = <64>;" and so on. From f21e565aeb6c69692856389ed490ea0db03ce39a Mon Sep 17 00:00:00 2001 From: Stephan Linz Date: Fri, 29 Dec 2023 16:26:44 +0100 Subject: [PATCH 10/13] drivers: display: sipomux: add SIPO/MUX display controller Add initial display driver for using a SIPO/MUX GP matrix as display controller. Signed-off-by: Stephan Linz --- drivers/display/CMakeLists.txt | 2 + drivers/display/Kconfig | 3 + drivers/display/Kconfig.sipomux | 20 ++ drivers/display/display_sipomux.c | 253 +++++++++++++++++++++ dts/bindings/display/sipo-mux-display.yaml | 31 +++ 5 files changed, 309 insertions(+) create mode 100644 drivers/display/Kconfig.sipomux create mode 100644 drivers/display/display_sipomux.c create mode 100644 dts/bindings/display/sipo-mux-display.yaml diff --git a/drivers/display/CMakeLists.txt b/drivers/display/CMakeLists.txt index 4855c90e81..cd84e11b59 100644 --- a/drivers/display/CMakeLists.txt +++ b/drivers/display/CMakeLists.txt @@ -5,3 +5,5 @@ # It is actually required to add display drivers to that library, otherwise # build errors can occur! zephyr_library_amend() + +zephyr_library_sources_ifdef(CONFIG_DISPLAY_SIPOMUX display_sipomux.c) diff --git a/drivers/display/Kconfig b/drivers/display/Kconfig index ff4161646d..1d94e0c803 100644 --- a/drivers/display/Kconfig +++ b/drivers/display/Kconfig @@ -2,4 +2,7 @@ # SPDX-License-Identifier: Apache-2.0 if DISPLAY + +rsource "Kconfig.sipomux" + endif # DISPLAY diff --git a/drivers/display/Kconfig.sipomux b/drivers/display/Kconfig.sipomux new file mode 100644 index 0000000000..d7b146a58f --- /dev/null +++ b/drivers/display/Kconfig.sipomux @@ -0,0 +1,20 @@ +# Latched SIPO/MUX display configuration options + +# Copyright (c) 2023 TiaC Systems +# SPDX-License-Identifier: Apache-2.0 + +menuconfig DISPLAY_SIPOMUX + bool "Generic latched SIPO/MUX display controller" + default y + depends on DT_HAS_SIPO_MUX_DISPLAY_ENABLED + select MFD + help + Enable the generic latched SIPO/MUX display driver. + +config DISPLAY_SIPOMUX_INIT_PRIORITY + int "Initialization priority" + default DISPLAY_INIT_PRIORITY + depends on DISPLAY_SIPOMUX + help + Initialization priority for the generic latched SIPO/MUX display + driver. It must be greater than the MFD controller init priority. diff --git a/drivers/display/display_sipomux.c b/drivers/display/display_sipomux.c new file mode 100644 index 0000000000..8f7dca8e36 --- /dev/null +++ b/drivers/display/display_sipomux.c @@ -0,0 +1,253 @@ +/* + * Copyright (c) 2023-2024 TiaC Systems + * SPDX-License-Identifier: Apache-2.0 + */ + +#define DT_DRV_COMPAT sipo_mux_display + +#include +#include +#include + +#include + +#include + +#include +LOG_MODULE_REGISTER(display_sipomux, CONFIG_DISPLAY_LOG_LEVEL); + +typedef struct display_sipomux_cfg { + const uint16_t height; + const uint16_t width; + const uint16_t gap_front; + const uint16_t gap_top; + const bool inversion_on; + const struct device *mfd; +} display_sipomux_cfg_t; + +typedef struct display_sipomux_data { + enum display_pixel_format current_pixel_format; +} display_sipomux_data_t; + +static inline int display_sipomux_set(const struct device *dev, unsigned set, + const size_t x, const size_t y) +{ + const display_sipomux_cfg_t * const config = dev->config; + size_t xpos = config->gap_front + x; + size_t ypos = config->gap_top + y; + + set = config->inversion_on ? ~set : set; + + if (set) { + return mfd_sipomuxgp_xy_on(config->mfd, xpos, ypos); + } else { + return mfd_sipomuxgp_xy_off(config->mfd, xpos, ypos); + } +} + +static int display_sipomux_write(const struct device *dev, + const uint16_t x, const uint16_t y, + const struct display_buffer_descriptor *desc, + const void *buf) +{ + const display_sipomux_cfg_t * const config = dev->config; + uint8_t *byte = (uint8_t *)buf; + size_t bit = 0; + int ret = 0; + + __ASSERT(desc->width <= desc->pitch, "Pitch is smaller then width"); + __ASSERT(desc->pitch <= config->width, + "Pitch in descriptor is larger than screen size"); + __ASSERT(desc->height <= config->height, + "Height in descriptor is larger than screen size"); + __ASSERT(x + desc->pitch <= config->width, + "Writing outside screen boundaries in horizontal direction"); + __ASSERT(y + desc->height <= config->height, + "Writing outside screen boundaries in vertical direction"); + + if (desc->width > desc->pitch || + x + desc->pitch > config->width || + y + desc->height > config->height) { + LOG_ERR("%s: writing outside screen boundaries", dev->name); + return -EINVAL; + } + + if (desc->height * desc->width > desc->buf_size * NUM_BITS(uint8_t)) { + LOG_ERR("%s: not enough data, buffer too small", dev->name); + return -EINVAL; + } + + for (size_t ypos = y; ypos < (y + desc->height); ypos++) { + for (size_t xpos = x; xpos < (x + desc->width); xpos++) { + + if (*byte & BIT(NUM_BITS(uint8_t) - bit - 1)) { + ret = display_sipomux_set(dev, ~0, xpos, ypos); + } else { + ret = display_sipomux_set(dev, 0, xpos, ypos); + } + + if (ret != 0U) { + return ret; + } + + if (!(++bit % NUM_BITS(uint8_t))) { + bit = 0; + byte++; + } + } + } + + return 0; +} + +static int display_sipomux_read(const struct device *dev, + const uint16_t x, const uint16_t y, + const struct display_buffer_descriptor *desc, + void *buf) +{ + LOG_DBG("%s: READ not supported", dev->name); + return -ENOTSUP; +} + +static void *display_sipomux_get_framebuffer(const struct device *dev) +{ + LOG_DBG("%s: DIRECT FB ADDR not supported", dev->name); + return NULL; +} + +static int display_sipomux_blanking_off(const struct device *dev) +{ + const display_sipomux_cfg_t * const config = dev->config; + + return mfd_sipomuxgp_output_ratio(config->mfd, 100); +} + +static int display_sipomux_blanking_on(const struct device *dev) +{ + const display_sipomux_cfg_t * const config = dev->config; + + return mfd_sipomuxgp_output_ratio(config->mfd, 0); +} + +static int display_sipomux_set_brightness(const struct device *dev, + const uint8_t brightness) +{ + const display_sipomux_cfg_t * const config = dev->config; + + return mfd_sipomuxgp_output_ratio(config->mfd, brightness); +} + +static int display_sipomux_set_contrast(const struct device *dev, + const uint8_t contrast) +{ + LOG_DBG("%s: CONTRAST not supported", dev->name); + return 0; +} + +static void display_sipomux_get_capabilities(const struct device *dev, + struct display_capabilities *capabilities) +{ + const display_sipomux_cfg_t * const config = dev->config; + display_sipomux_data_t * const data = dev->data; + + memset(capabilities, 0, sizeof(struct display_capabilities)); + capabilities->x_resolution = config->width; + capabilities->y_resolution = config->height; + capabilities->supported_pixel_formats = PIXEL_FORMAT_MONO01; + capabilities->current_pixel_format = data->current_pixel_format; + capabilities->screen_info = SCREEN_INFO_MONO_VTILED | + SCREEN_INFO_MONO_MSB_FIRST; +} + +static int display_sipomux_set_pixel_format(const struct device *dev, + const enum display_pixel_format pixel_format) +{ + display_sipomux_data_t * const data = dev->data; + + if (pixel_format != PIXEL_FORMAT_MONO01) { + LOG_ERR("%s: unsupported pixel format", dev->name); + return -EINVAL; + } + + data->current_pixel_format = pixel_format; + + return 0; +} + +static const struct display_driver_api display_sipomux_api = { + .blanking_on = display_sipomux_blanking_on, + .blanking_off = display_sipomux_blanking_off, + .write = display_sipomux_write, + .read = display_sipomux_read, + .get_framebuffer = display_sipomux_get_framebuffer, + .set_brightness = display_sipomux_set_brightness, + .set_contrast = display_sipomux_set_contrast, + .get_capabilities = display_sipomux_get_capabilities, + .set_pixel_format = display_sipomux_set_pixel_format, +}; + +static int display_sipomux_init(const struct device *dev) +{ + const display_sipomux_cfg_t * const config = dev->config; + display_sipomux_data_t * const data = dev->data; + uint16_t av_pixel, rq_pixel; + + if (!device_is_ready(config->mfd)) { + return -ENODEV; + } + + rq_pixel = (config->gap_front + config->width) \ + * (config->gap_top + config->height); + av_pixel = mfd_sipomuxgp_num_bits(config->mfd); + + if (rq_pixel > av_pixel) { + LOG_ERR("%s: invalid number of requested pixel: %u > %u", + dev->name, rq_pixel, av_pixel); + return -EINVAL; + } + + data->current_pixel_format = PIXEL_FORMAT_MONO01; + + LOG_DBG("%s: ready for %u x %u (+%u:+%u) with MFD backend over %s!", + dev->name, config->width, config->height, config->gap_front, + config->gap_top, config->mfd->name); + return 0; +} + +#ifdef CONFIG_PM_DEVICE +static int display_sipomux_pm_device_pm_action(const struct device *dev, + enum pm_device_action action) +{ + ARG_UNUSED(dev); + ARG_UNUSED(action); + + return 0; +} +#endif + +#if CONFIG_DISPLAY_SIPOMUX_INIT_PRIORITY <= CONFIG_MFD_SIPOMUXGP_INIT_PRIORITY +#error DISPLAY_SIPOMUX_INIT_PRIORITY must be greater than MFD_SIPOMUXGP_INIT_PRIORITY +#endif + +#define DISPLAY_SIPOMUX_DEFINE(n) \ + static const display_sipomux_cfg_t display_sipomux_cfg_##n = { \ + .height = DT_INST_PROP(n, height), \ + .width = DT_INST_PROP(n, width), \ + .gap_front = DT_INST_PROP_BY_IDX(n, offset, 0), \ + .gap_top = DT_INST_PROP_BY_IDX(n, offset, 1), \ + .inversion_on = DT_INST_PROP(n, inversion_on), \ + .mfd = DEVICE_DT_GET(DT_INST_PARENT(n)), \ + }; \ + \ + static display_sipomux_data_t display_sipomux_data_##n; \ + \ + PM_DEVICE_DT_INST_DEFINE(n, display_sipomux_pm_device_pm_action);\ + \ + DEVICE_DT_INST_DEFINE(n, display_sipomux_init, NULL, \ + &display_sipomux_data_##n, \ + &display_sipomux_cfg_##n, \ + POST_KERNEL, \ + CONFIG_DISPLAY_SIPOMUX_INIT_PRIORITY, \ + &display_sipomux_api); + +DT_INST_FOREACH_STATUS_OKAY(DISPLAY_SIPOMUX_DEFINE) diff --git a/dts/bindings/display/sipo-mux-display.yaml b/dts/bindings/display/sipo-mux-display.yaml new file mode 100644 index 0000000000..f5bd8a209f --- /dev/null +++ b/dts/bindings/display/sipo-mux-display.yaml @@ -0,0 +1,31 @@ +# Copyright (c) 2023 TiaC Systems +# SPDX-License-Identifier: Apache-2.0 + +description: Generic latched SIPO/MUX Display Controller + +compatible: "sipo-mux-display" + +include: display-controller.yaml + +properties: + offset: + type: array + default: [0, 0] + description: | + Optional offset for top and front pixel shifting. This property + indicates the x offset for front pixel shifting as first element + and the y offset for top pixel shifting as second element. More + than two alements are not allowed. + + For example, setting "offset = <2 1>;" means in front of each row + is a gap of two unused pixels and on top of each column is a gap + of one unused pixel. In case of an underlying SIPO/MUX GP Controller + with 16 x 32 usable bits the display width and height must be set + consistent and appropriate to the offset to "width = <30>;" and + "height = <15>;". + + inversion-on: + type: boolean + description: | + Display inversion mode. Every bit is inverted on writing to the + display frame memory. From 8de914f30726f4be31fa66546d6901304d358195 Mon Sep 17 00:00:00 2001 From: Stephan Linz Date: Sat, 16 Mar 2024 09:42:14 +0100 Subject: [PATCH 11/13] shields: add Waveshare Pico-Clock-Green supported features: * General-Purpose Input/Output API (zephyr/samples/basic/button|blinky) * Analog-to-Digital Converter API (zephyr/samples/drivers/adc) * Input API (zephyr/samples/subsys/input/input_dump) * Display API (zephyr/samples/drivers/display) * On-Board Buzzer (bridle/samples/buzzer) * Real-Time Clock API supported platforms: * Raspberry Pi Pico (rpi_pico) * Raspberry Pi Pico W (rpi_pico_w) * Waveshare RP2040 Plus 4MB (waveshare_rp2040_plus) * Waveshare RP2040 Plus 16MB (waveshare_rp2040_plus@16mb) Signed-off-by: Stephan Linz --- .../shields/rpi_pico_clock/Kconfig.defconfig | 24 + boards/shields/rpi_pico_clock/Kconfig.shield | 5 + .../rpi_pico_clock/boards/rpi_pico.conf | 5 + .../rpi_pico_clock/boards/rpi_pico.overlay | 7 + .../rpi_pico_clock/boards/rpi_pico_w.conf | 5 + .../rpi_pico_clock/boards/rpi_pico_w.overlay | 7 + .../boards/rpipico_r3-pinctrl.dtsi | 22 + .../rpi_pico_clock/boards/rpipico_r3.dtsi | 33 + .../ds3231-mfd.dtsi | 27 + .../led_matrix-boot_hogs.dtsi | 118 +++ .../led_matrix.dtsi | 133 +++ .../rpi_pico.overlay | 6 + .../rpi_pico_w.overlay | 6 + .../rpipico_r3.dtsi | 300 +++++++ .../waveshare_rp2040_plus.overlay | 6 + .../boards/waveshare_rp2040_plus.conf | 5 + .../boards/waveshare_rp2040_plus.overlay | 7 + boards/shields/rpi_pico_clock/doc/index.rst | 620 ++++++++++++++ .../doc/waveshare_pico_clock_green.drawio | 1 + .../waveshare_pico_clock_green/display.gif | Bin 0 -> 32791 bytes .../waveshare_pico_clock_green/hardware.jpg | Bin 0 -> 117957 bytes .../waveshare_pico_clock_green/hardware.rsti | 58 ++ .../helloshell.rsti | 208 +++++ .../waveshare_pico_clock_green/pinouts.jpg | Bin 0 -> 183141 bytes .../waveshare_pico_clock_green/pinouts.rsti | 787 ++++++++++++++++++ .../waveshare_pico_clock_green/positions.jpg | Bin 0 -> 89217 bytes .../waveshare_pico_clock_green/positions.rsti | 78 ++ .../sipomuxgp-spi.svg | 1 + .../waveshare_pico_clock_green.overlay | 215 +++++ doc/bridle/links.txt | 215 +++++ doc/bridle/shortcuts.txt | 3 + 31 files changed, 2902 insertions(+) create mode 100644 boards/shields/rpi_pico_clock/Kconfig.defconfig create mode 100644 boards/shields/rpi_pico_clock/Kconfig.shield create mode 100644 boards/shields/rpi_pico_clock/boards/rpi_pico.conf create mode 100644 boards/shields/rpi_pico_clock/boards/rpi_pico.overlay create mode 100644 boards/shields/rpi_pico_clock/boards/rpi_pico_w.conf create mode 100644 boards/shields/rpi_pico_clock/boards/rpi_pico_w.overlay create mode 100644 boards/shields/rpi_pico_clock/boards/rpipico_r3-pinctrl.dtsi create mode 100644 boards/shields/rpi_pico_clock/boards/rpipico_r3.dtsi create mode 100644 boards/shields/rpi_pico_clock/boards/waveshare_pico_clock_green/ds3231-mfd.dtsi create mode 100644 boards/shields/rpi_pico_clock/boards/waveshare_pico_clock_green/led_matrix-boot_hogs.dtsi create mode 100644 boards/shields/rpi_pico_clock/boards/waveshare_pico_clock_green/led_matrix.dtsi create mode 100644 boards/shields/rpi_pico_clock/boards/waveshare_pico_clock_green/rpi_pico.overlay create mode 100644 boards/shields/rpi_pico_clock/boards/waveshare_pico_clock_green/rpi_pico_w.overlay create mode 100644 boards/shields/rpi_pico_clock/boards/waveshare_pico_clock_green/rpipico_r3.dtsi create mode 100644 boards/shields/rpi_pico_clock/boards/waveshare_pico_clock_green/waveshare_rp2040_plus.overlay create mode 100644 boards/shields/rpi_pico_clock/boards/waveshare_rp2040_plus.conf create mode 100644 boards/shields/rpi_pico_clock/boards/waveshare_rp2040_plus.overlay create mode 100644 boards/shields/rpi_pico_clock/doc/index.rst create mode 100644 boards/shields/rpi_pico_clock/doc/waveshare_pico_clock_green.drawio create mode 100644 boards/shields/rpi_pico_clock/doc/waveshare_pico_clock_green/display.gif create mode 100644 boards/shields/rpi_pico_clock/doc/waveshare_pico_clock_green/hardware.jpg create mode 100644 boards/shields/rpi_pico_clock/doc/waveshare_pico_clock_green/hardware.rsti create mode 100644 boards/shields/rpi_pico_clock/doc/waveshare_pico_clock_green/helloshell.rsti create mode 100644 boards/shields/rpi_pico_clock/doc/waveshare_pico_clock_green/pinouts.jpg create mode 100644 boards/shields/rpi_pico_clock/doc/waveshare_pico_clock_green/pinouts.rsti create mode 100644 boards/shields/rpi_pico_clock/doc/waveshare_pico_clock_green/positions.jpg create mode 100644 boards/shields/rpi_pico_clock/doc/waveshare_pico_clock_green/positions.rsti create mode 100644 boards/shields/rpi_pico_clock/doc/waveshare_pico_clock_green/sipomuxgp-spi.svg create mode 100644 boards/shields/rpi_pico_clock/waveshare_pico_clock_green.overlay diff --git a/boards/shields/rpi_pico_clock/Kconfig.defconfig b/boards/shields/rpi_pico_clock/Kconfig.defconfig new file mode 100644 index 0000000000..1162ba3547 --- /dev/null +++ b/boards/shields/rpi_pico_clock/Kconfig.defconfig @@ -0,0 +1,24 @@ +# Copyright (c) 2023-2024 TiaC Systems +# SPDX-License-Identifier: Apache-2.0 + +config SHIELD_RPI_PICO_CLOCK + bool + default y if SHIELD_WAVESHARE_PICO_CLOCK_GREEN + default n + +config SHIELD_RPI_PICO_CLOCK_HIYOU + bool + default y if SHIELD_WAVESHARE_PICO_CLOCK_GREEN + default n + +config SPI + default y if DT_HAS_SIPO_MUX_GP_SPI_ENABLED + depends on SHIELD_RPI_PICO_CLOCK + +config GPIO_HOGS + default y if DT_HAS_SIPO_MUX_GPIO_ENABLED + depends on SHIELD_RPI_PICO_CLOCK_HIYOU && GPIO + +config GPIO_HOGS_INIT_PRIORITY + default 85 if DT_HAS_SIPO_MUX_GPIO_ENABLED + depends on SHIELD_RPI_PICO_CLOCK_HIYOU && GPIO_HOGS diff --git a/boards/shields/rpi_pico_clock/Kconfig.shield b/boards/shields/rpi_pico_clock/Kconfig.shield new file mode 100644 index 0000000000..5fc08acea3 --- /dev/null +++ b/boards/shields/rpi_pico_clock/Kconfig.shield @@ -0,0 +1,5 @@ +# Copyright (c) 2023-2024 TiaC Systems +# SPDX-License-Identifier: Apache-2.0 + +config SHIELD_WAVESHARE_PICO_CLOCK_GREEN + def_bool $(shields_list_contains,waveshare_pico_clock_green) diff --git a/boards/shields/rpi_pico_clock/boards/rpi_pico.conf b/boards/shields/rpi_pico_clock/boards/rpi_pico.conf new file mode 100644 index 0000000000..a5452d4cd0 --- /dev/null +++ b/boards/shields/rpi_pico_clock/boards/rpi_pico.conf @@ -0,0 +1,5 @@ +# Copyright (c) 2023-2024 TiaC Systems +# SPDX-License-Identifier: Apache-2.0 + +CONFIG_USB_SELF_POWERED=n +CONFIG_USB_MAX_POWER=50 diff --git a/boards/shields/rpi_pico_clock/boards/rpi_pico.overlay b/boards/shields/rpi_pico_clock/boards/rpi_pico.overlay new file mode 100644 index 0000000000..8d7f8e560e --- /dev/null +++ b/boards/shields/rpi_pico_clock/boards/rpi_pico.overlay @@ -0,0 +1,7 @@ +/* + * Copyright (c) 2023-2024 TiaC Systems + * SPDX-License-Identifier: Apache-2.0 + */ + +#include "rpipico_r3-pinctrl.dtsi" +#include "rpipico_r3.dtsi" diff --git a/boards/shields/rpi_pico_clock/boards/rpi_pico_w.conf b/boards/shields/rpi_pico_clock/boards/rpi_pico_w.conf new file mode 100644 index 0000000000..a5452d4cd0 --- /dev/null +++ b/boards/shields/rpi_pico_clock/boards/rpi_pico_w.conf @@ -0,0 +1,5 @@ +# Copyright (c) 2023-2024 TiaC Systems +# SPDX-License-Identifier: Apache-2.0 + +CONFIG_USB_SELF_POWERED=n +CONFIG_USB_MAX_POWER=50 diff --git a/boards/shields/rpi_pico_clock/boards/rpi_pico_w.overlay b/boards/shields/rpi_pico_clock/boards/rpi_pico_w.overlay new file mode 100644 index 0000000000..8d7f8e560e --- /dev/null +++ b/boards/shields/rpi_pico_clock/boards/rpi_pico_w.overlay @@ -0,0 +1,7 @@ +/* + * Copyright (c) 2023-2024 TiaC Systems + * SPDX-License-Identifier: Apache-2.0 + */ + +#include "rpipico_r3-pinctrl.dtsi" +#include "rpipico_r3.dtsi" diff --git a/boards/shields/rpi_pico_clock/boards/rpipico_r3-pinctrl.dtsi b/boards/shields/rpi_pico_clock/boards/rpipico_r3-pinctrl.dtsi new file mode 100644 index 0000000000..3c3d3006f1 --- /dev/null +++ b/boards/shields/rpi_pico_clock/boards/rpipico_r3-pinctrl.dtsi @@ -0,0 +1,22 @@ +/* + * Copyright (c) 2023-2024 TiaC Systems + * SPDX-License-Identifier: Apache-2.0 + */ + +#include + +&pinctrl { + spi1_wpcg_leds: spi1-wpcg-leds-pinctrl { + group1011-spi { + pinmux = , /* GP10: SPI1_SCK */ + ; /* GP11: SPI1_TX */ + }; + /* GP9: SPI1_CSN not used for LED access */ + /* GP12: SPI1_RX not used for LED access */ + }; + pwm_wpcg_buzzer: pwm-wpcg-buzzer-pinctrl { + group14-pwm { + pinmux = ; /* GP14: PWM7A (14) */ + }; + }; +}; diff --git a/boards/shields/rpi_pico_clock/boards/rpipico_r3.dtsi b/boards/shields/rpi_pico_clock/boards/rpipico_r3.dtsi new file mode 100644 index 0000000000..e691ee36dc --- /dev/null +++ b/boards/shields/rpi_pico_clock/boards/rpipico_r3.dtsi @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2023-2024 TiaC Systems + * SPDX-License-Identifier: Apache-2.0 + */ + +#include +#include + +&rpipico_i2c1 { + status = "okay"; + clock-frequency = ; +}; + +rpipico_i2c_rtc: &rpipico_i2c1 {}; + +&spi1 { + status = "okay"; + clock-frequency = ; +}; + +rpipico_spi_leds: &spi1 {}; + +&pwm { + status = "okay"; +}; + +rpipico_pwm_buzzers: &pwm {}; + +&gpio0 { + status = "okay"; +}; + +rpipico_gpio_keys: &gpio0 {}; diff --git a/boards/shields/rpi_pico_clock/boards/waveshare_pico_clock_green/ds3231-mfd.dtsi b/boards/shields/rpi_pico_clock/boards/waveshare_pico_clock_green/ds3231-mfd.dtsi new file mode 100644 index 0000000000..4c6265fd9c --- /dev/null +++ b/boards/shields/rpi_pico_clock/boards/waveshare_pico_clock_green/ds3231-mfd.dtsi @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2023-2024 TiaC Systems + * SPDX-License-Identifier: Apache-2.0 + */ + +&clock_i2c_rtc { + ds3231_mfd: ds3231-mfd@68 { + compatible = "maxim,ds3231-mfd"; + reg = <0x68>; + + status = "disabled"; + + ds3231_rtc: ds3231-rtc { + compatible = "maxim,ds3231-rtc"; + status = "disabled"; + }; + + ds3231_dts: ds3231-dts { + compatible = "maxim,ds3231-temp"; + status = "disabled"; + }; + }; +}; + +clock_mfd: &ds3231_mfd {}; +clock_rtc: &ds3231_rtc {}; +clock_dts: &ds3231_dts {}; diff --git a/boards/shields/rpi_pico_clock/boards/waveshare_pico_clock_green/led_matrix-boot_hogs.dtsi b/boards/shields/rpi_pico_clock/boards/waveshare_pico_clock_green/led_matrix-boot_hogs.dtsi new file mode 100644 index 0000000000..81167aedaa --- /dev/null +++ b/boards/shields/rpi_pico_clock/boards/waveshare_pico_clock_green/led_matrix-boot_hogs.dtsi @@ -0,0 +1,118 @@ +/* + * Copyright (c) 2023-2024 TiaC Systems + * SPDX-License-Identifier: Apache-2.0 + */ + +&clock_gpio_1 { + boot-hogs-framing { + gpio-hog; + gpios = <2 GPIO_ACTIVE_HIGH>, <3 GPIO_ACTIVE_HIGH>, + <4 GPIO_ACTIVE_HIGH>, <5 GPIO_ACTIVE_HIGH>, + <6 GPIO_ACTIVE_HIGH>, <7 GPIO_ACTIVE_HIGH>, + <8 GPIO_ACTIVE_HIGH>, <9 GPIO_ACTIVE_HIGH>, + <10 GPIO_ACTIVE_HIGH>, <11 GPIO_ACTIVE_HIGH>, + <12 GPIO_ACTIVE_HIGH>, <13 GPIO_ACTIVE_HIGH>, + <14 GPIO_ACTIVE_HIGH>, <15 GPIO_ACTIVE_HIGH>, + <16 GPIO_ACTIVE_HIGH>, <17 GPIO_ACTIVE_HIGH>, + <18 GPIO_ACTIVE_HIGH>, <19 GPIO_ACTIVE_HIGH>, + <20 GPIO_ACTIVE_HIGH>, <21 GPIO_ACTIVE_HIGH>, + <22 GPIO_ACTIVE_HIGH>, <23 GPIO_ACTIVE_HIGH>; + output-high; + line-name = "framing"; + }; +}; + +&clock_gpio_2 { + boot-hogs-framing { + gpio-hog; + gpios = <2 GPIO_ACTIVE_HIGH>, <23 GPIO_ACTIVE_HIGH>; + output-high; + line-name = "framing"; + }; +}; + +&clock_gpio_3 { + boot-hogs-framing { + gpio-hog; + gpios = <2 GPIO_ACTIVE_HIGH>, <23 GPIO_ACTIVE_HIGH>; + output-high; + line-name = "framing"; + }; + boot-hogs-hello { + gpio-hog; + gpios = <4 GPIO_ACTIVE_HIGH>, <6 GPIO_ACTIVE_HIGH>, + <8 GPIO_ACTIVE_HIGH>, <11 GPIO_ACTIVE_HIGH>, + <13 GPIO_ACTIVE_HIGH>, <15 GPIO_ACTIVE_HIGH>, + <16 GPIO_ACTIVE_HIGH>, <17 GPIO_ACTIVE_HIGH>, + <19 GPIO_ACTIVE_HIGH>, <21 GPIO_ACTIVE_HIGH>; + output-high; + line-name = "hello"; + }; +}; + +&clock_gpio_4 { + boot-hogs-framing { + gpio-hog; + gpios = <2 GPIO_ACTIVE_HIGH>, <23 GPIO_ACTIVE_HIGH>; + output-high; + line-name = "framing"; + }; + boot-hogs-hello { + gpio-hog; + gpios = <4 GPIO_ACTIVE_HIGH>, <5 GPIO_ACTIVE_HIGH>, + <6 GPIO_ACTIVE_HIGH>, <8 GPIO_ACTIVE_HIGH>, + <12 GPIO_ACTIVE_HIGH>, <15 GPIO_ACTIVE_HIGH>, + <17 GPIO_ACTIVE_HIGH>, <19 GPIO_ACTIVE_HIGH>, + <21 GPIO_ACTIVE_HIGH>; + output-high; + line-name = "hello"; + }; +}; + +&clock_gpio_5 { + boot-hogs-framing { + gpio-hog; + gpios = <2 GPIO_ACTIVE_HIGH>, <23 GPIO_ACTIVE_HIGH>; + output-high; + line-name = "framing"; + }; + boot-hogs-hello { + gpio-hog; + gpios = <4 GPIO_ACTIVE_HIGH>, <6 GPIO_ACTIVE_HIGH>, + <8 GPIO_ACTIVE_HIGH>, <12 GPIO_ACTIVE_HIGH>, + <8 GPIO_ACTIVE_HIGH>, <15 GPIO_ACTIVE_HIGH>, + <16 GPIO_ACTIVE_HIGH>, <17 GPIO_ACTIVE_HIGH>, + <19 GPIO_ACTIVE_HIGH>, <20 GPIO_ACTIVE_HIGH>, + <21 GPIO_ACTIVE_HIGH>; + output-high; + line-name = "hello"; + }; +}; + +&clock_gpio_6 { + boot-hogs-framing { + gpio-hog; + gpios = <2 GPIO_ACTIVE_HIGH>, <23 GPIO_ACTIVE_HIGH>; + output-high; + line-name = "framing"; + }; +}; + +&clock_gpio_7 { + boot-hogs-framing { + gpio-hog; + gpios = <2 GPIO_ACTIVE_HIGH>, <3 GPIO_ACTIVE_HIGH>, + <4 GPIO_ACTIVE_HIGH>, <5 GPIO_ACTIVE_HIGH>, + <6 GPIO_ACTIVE_HIGH>, <7 GPIO_ACTIVE_HIGH>, + <8 GPIO_ACTIVE_HIGH>, <9 GPIO_ACTIVE_HIGH>, + <10 GPIO_ACTIVE_HIGH>, <11 GPIO_ACTIVE_HIGH>, + <12 GPIO_ACTIVE_HIGH>, <13 GPIO_ACTIVE_HIGH>, + <14 GPIO_ACTIVE_HIGH>, <15 GPIO_ACTIVE_HIGH>, + <16 GPIO_ACTIVE_HIGH>, <17 GPIO_ACTIVE_HIGH>, + <18 GPIO_ACTIVE_HIGH>, <19 GPIO_ACTIVE_HIGH>, + <20 GPIO_ACTIVE_HIGH>, <21 GPIO_ACTIVE_HIGH>, + <22 GPIO_ACTIVE_HIGH>, <23 GPIO_ACTIVE_HIGH>; + output-high; + line-name = "framing"; + }; +}; diff --git a/boards/shields/rpi_pico_clock/boards/waveshare_pico_clock_green/led_matrix.dtsi b/boards/shields/rpi_pico_clock/boards/waveshare_pico_clock_green/led_matrix.dtsi new file mode 100644 index 0000000000..a32216f1fb --- /dev/null +++ b/boards/shields/rpi_pico_clock/boards/waveshare_pico_clock_green/led_matrix.dtsi @@ -0,0 +1,133 @@ +/* + * Copyright (c) 2023-2024 TiaC Systems + * SPDX-License-Identifier: Apache-2.0 + */ + +#include + +&clock_spi_leds { + sipo_mux_gp: sipo-mux-gp@0 { + compatible = "sipo-mux-gp-spi"; + spi-max-frequency = ; + reg = <0>; + + status = "disabled"; + + refresh-time-us = <500>; + shift-width = <32>; + data-width = <24>; + + #address-cells = <1>; + #size-cells = <0>; + + sipo_mux_gpio_0: sipo-mux-gpio@0 { + compatible = "sipo-mux-gpio"; + gpio-controller; + #gpio-cells = <2>; + ngpios = <24>; + offset = <0>; + reg = <0>; + + status = "disabled"; + }; + + sipo_mux_gpio_1: sipo-mux-gpio@1 { + compatible = "sipo-mux-gpio"; + gpio-controller; + #gpio-cells = <2>; + ngpios = <24>; + offset = <24>; + reg = <1>; + + status = "disabled"; + }; + + sipo_mux_gpio_2: sipo-mux-gpio@2 { + compatible = "sipo-mux-gpio"; + gpio-controller; + #gpio-cells = <2>; + ngpios = <24>; + offset = <48>; + reg = <2>; + + status = "disabled"; + }; + + sipo_mux_gpio_3: sipo-mux-gpio@3 { + compatible = "sipo-mux-gpio"; + gpio-controller; + #gpio-cells = <2>; + ngpios = <24>; + offset = <72>; + reg = <3>; + + status = "disabled"; + }; + + sipo_mux_gpio_4: sipo-mux-gpio@4 { + compatible = "sipo-mux-gpio"; + gpio-controller; + #gpio-cells = <2>; + ngpios = <24>; + offset = <96>; + reg = <4>; + + status = "disabled"; + }; + + sipo_mux_gpio_5: sipo-mux-gpio@5 { + compatible = "sipo-mux-gpio"; + gpio-controller; + #gpio-cells = <2>; + ngpios = <24>; + offset = <120>; + reg = <5>; + + status = "disabled"; + }; + + sipo_mux_gpio_6: sipo-mux-gpio@6 { + compatible = "sipo-mux-gpio"; + gpio-controller; + #gpio-cells = <2>; + ngpios = <24>; + offset = <144>; + reg = <6>; + + status = "disabled"; + }; + + sipo_mux_gpio_7: sipo-mux-gpio@7 { + compatible = "sipo-mux-gpio"; + gpio-controller; + #gpio-cells = <2>; + ngpios = <24>; + offset = <168>; + reg = <7>; + + status = "disabled"; + }; + + sipo_mux_display_8: sipo-mux-display@8 { + compatible = "sipo-mux-display"; + reg = <8>; + + height = <7>; + width = <22>; + offset = <2 1>; + + status = "disabled"; + }; + }; +}; + +clock_sipo_mux: &sipo_mux_gp {}; +clock_gpio_0: &sipo_mux_gpio_0 {}; +clock_gpio_1: &sipo_mux_gpio_1 {}; +clock_gpio_2: &sipo_mux_gpio_2 {}; +clock_gpio_3: &sipo_mux_gpio_3 {}; +clock_gpio_4: &sipo_mux_gpio_4 {}; +clock_gpio_5: &sipo_mux_gpio_5 {}; +clock_gpio_6: &sipo_mux_gpio_6 {}; +clock_gpio_7: &sipo_mux_gpio_7 {}; +clock_display: &sipo_mux_display_8 {}; diff --git a/boards/shields/rpi_pico_clock/boards/waveshare_pico_clock_green/rpi_pico.overlay b/boards/shields/rpi_pico_clock/boards/waveshare_pico_clock_green/rpi_pico.overlay new file mode 100644 index 0000000000..199666c54a --- /dev/null +++ b/boards/shields/rpi_pico_clock/boards/waveshare_pico_clock_green/rpi_pico.overlay @@ -0,0 +1,6 @@ +/* + * Copyright (c) 2023-2024 TiaC Systems + * SPDX-License-Identifier: Apache-2.0 + */ + +#include "rpipico_r3.dtsi" diff --git a/boards/shields/rpi_pico_clock/boards/waveshare_pico_clock_green/rpi_pico_w.overlay b/boards/shields/rpi_pico_clock/boards/waveshare_pico_clock_green/rpi_pico_w.overlay new file mode 100644 index 0000000000..199666c54a --- /dev/null +++ b/boards/shields/rpi_pico_clock/boards/waveshare_pico_clock_green/rpi_pico_w.overlay @@ -0,0 +1,6 @@ +/* + * Copyright (c) 2023-2024 TiaC Systems + * SPDX-License-Identifier: Apache-2.0 + */ + +#include "rpipico_r3.dtsi" diff --git a/boards/shields/rpi_pico_clock/boards/waveshare_pico_clock_green/rpipico_r3.dtsi b/boards/shields/rpi_pico_clock/boards/waveshare_pico_clock_green/rpipico_r3.dtsi new file mode 100644 index 0000000000..2ac270a077 --- /dev/null +++ b/boards/shields/rpi_pico_clock/boards/waveshare_pico_clock_green/rpipico_r3.dtsi @@ -0,0 +1,300 @@ +/* + * Copyright (c) 2023-2024 TiaC Systems + * SPDX-License-Identifier: Apache-2.0 + */ + +clock_i2c_rtc: &rpipico_i2c_rtc {}; +clock_spi_leds: &rpipico_spi_leds {}; +clock_gpio_keys: &rpipico_gpio_keys {}; +clock_pwm_buzzers: &rpipico_pwm_buzzers {}; + +#include "ds3231-mfd.dtsi" +#include "led_matrix.dtsi" +#include "led_matrix-boot_hogs.dtsi" + +#include +#include + +&clock_dts { + status = "okay"; +}; + +&clock_rtc { + status = "okay"; +}; + +&clock_mfd { /* GP3 */ + isw-gpios = <&rpipico_header 3 (GPIO_PULL_UP | GPIO_ACTIVE_LOW)>; + status = "okay"; +}; + +&clock_i2c_rtc { + clock-frequency = ; +}; + +&clock_display { + status = "okay"; +}; + +&clock_led_signal_0 { + gpios = <&clock_gpio_0 2 GPIO_ACTIVE_HIGH>; /* SIG0 */ +}; +&clock_led_signal_1 { + gpios = <&clock_gpio_0 5 GPIO_ACTIVE_HIGH>; /* SIG1 */ +}; + +&clock_led_monday_0 { + gpios = <&clock_gpio_0 3 GPIO_ACTIVE_HIGH>; /* MON0 */ +}; +&clock_led_monday_1 { + gpios = <&clock_gpio_0 4 GPIO_ACTIVE_HIGH>; /* MON1 */ +}; + +&clock_led_tuesday_0 { + gpios = <&clock_gpio_0 6 GPIO_ACTIVE_HIGH>; /* TUE0 */ +}; +&clock_led_tuesday_1 { + gpios = <&clock_gpio_0 7 GPIO_ACTIVE_HIGH>; /* TUE1 */ +}; + +&clock_led_wednesday_0 { + gpios = <&clock_gpio_0 9 GPIO_ACTIVE_HIGH>; /* WED0 */ +}; +&clock_led_wednesday_1 { + gpios = <&clock_gpio_0 10 GPIO_ACTIVE_HIGH>; /* WED1 */ +}; + +&clock_led_thursday_0 { + gpios = <&clock_gpio_0 12 GPIO_ACTIVE_HIGH>; /* THU0 */ +}; +&clock_led_thursday_1 { + gpios = <&clock_gpio_0 13 GPIO_ACTIVE_HIGH>; /* THU1 */ +}; + +&clock_led_friday_0 { + gpios = <&clock_gpio_0 15 GPIO_ACTIVE_HIGH>; /* FRI0 */ +}; +&clock_led_friday_1 { + gpios = <&clock_gpio_0 16 GPIO_ACTIVE_HIGH>; /* FRI1 */ +}; + +&clock_led_saturday_0 { + gpios = <&clock_gpio_0 18 GPIO_ACTIVE_HIGH>; /* SAT0 */ +}; +&clock_led_saturday_1 { + gpios = <&clock_gpio_0 19 GPIO_ACTIVE_HIGH>; /* SAT1 */ +}; + +&clock_led_sunday_0 { + gpios = <&clock_gpio_0 21 GPIO_ACTIVE_HIGH>; /* SUN0 */ +}; +&clock_led_sunday_1 { + gpios = <&clock_gpio_0 22 GPIO_ACTIVE_HIGH>; /* SUN1 */ +}; + +&clock_led_move_on_0 { + gpios = <&clock_gpio_0 0 GPIO_ACTIVE_HIGH>; /* MOV0 */ +}; +&clock_led_move_on_1 { + gpios = <&clock_gpio_0 1 GPIO_ACTIVE_HIGH>; /* MOV1 */ +}; + +&clock_led_alarm_on_0 { + gpios = <&clock_gpio_1 0 GPIO_ACTIVE_HIGH>; /* ALM0 */ +}; +&clock_led_alarm_on_1 { + gpios = <&clock_gpio_1 1 GPIO_ACTIVE_HIGH>; /* ALM1 */ +}; + +&clock_led_count_down_0 { + gpios = <&clock_gpio_2 0 GPIO_ACTIVE_HIGH>; /* CDN0 */ +}; +&clock_led_count_down_1 { + gpios = <&clock_gpio_2 1 GPIO_ACTIVE_HIGH>; /* CDN1 */ +}; + +&clock_led_degrees_fahrenheit { + gpios = <&clock_gpio_3 0 GPIO_ACTIVE_HIGH>; /* DEGF */ +}; +&clock_led_degrees_celsius { + gpios = <&clock_gpio_3 1 GPIO_ACTIVE_HIGH>; /* DEGC */ +}; + +&clock_led_time_am { + gpios = <&clock_gpio_4 0 GPIO_ACTIVE_HIGH>; /* TMAM */ +}; +&clock_led_time_pm { + gpios = <&clock_gpio_4 1 GPIO_ACTIVE_HIGH>; /* TMPM */ +}; + +&clock_led_count_up_0 { + gpios = <&clock_gpio_5 0 GPIO_ACTIVE_HIGH>; /* CUP0 */ +}; +&clock_led_count_up_1 { + gpios = <&clock_gpio_5 1 GPIO_ACTIVE_HIGH>; /* CUP1 */ +}; + +&clock_led_hourly_0 { + gpios = <&clock_gpio_6 0 GPIO_ACTIVE_HIGH>; /* HLY0 */ +}; +&clock_led_hourly_1 { + gpios = <&clock_gpio_6 1 GPIO_ACTIVE_HIGH>; /* HLY1 */ +}; + +&clock_led_auto_light_0 { + gpios = <&clock_gpio_7 0 GPIO_ACTIVE_HIGH>; /* AUT0 */ +}; +&clock_led_auto_light_1 { + gpios = <&clock_gpio_7 1 GPIO_ACTIVE_HIGH>; /* AUT1 */ +}; + +&clock_gpio_0 { + /* namespace and positions without LEDs or not wired bits */ + gpio-reserved-ranges = + <8 1>, <11 1>, + <14 1>, <17 1>, + <20 1>, <23 1>; + gpio-line-names = + "MOV0", "MOV1", "SIG0", + "MON0", "MON1", "SIG1", + "TUE0", "TUE1", "", /* not wired: <8 1> */ + "WED0", "WED1", "", /* not wired: <11 1> */ + "THU0", "THU1", "", /* not wired: <14 1> */ + "FRI0", "FRI1", "", /* not wired: <17 1> */ + "SAT0", "SAT1", "", /* not wired: <20 1> */ + "SUN0", "SUN1", ""; /* not wired: <23 1> */ + status = "okay"; +}; + +&clock_gpio_1 { + /* namespace and positions without LEDs or not wired bits */ + gpio-line-names = + "ALM0", "ALM1", "L102", "L103", + "L104", "L105", "L106", "L107", + "L108", "L109", "L110", "L111", + "L112", "L113", "L114", "L115", + "L116", "L117", "L118", "L119", + "L120", "L121", "L122", "L123"; /* not wired: <24 8> */ + status = "okay"; +}; + +&clock_gpio_2 { + /* namespace and positions without LEDs or not wired bits */ + gpio-line-names = + "CDN0", "CDN1", "L202", "L203", + "L204", "L205", "L206", "L207", + "L208", "L209", "L210", "L211", + "L212", "L213", "L214", "L215", + "L216", "L217", "L218", "L219", + "L220", "L221", "L222", "L223"; /* not wired: <24 8> */ + status = "okay"; +}; + +&clock_gpio_3 { + /* namespace and positions without LEDs or not wired bits */ + gpio-line-names = + "DEGF", "DEGC", "L302", "L303", + "L304", "L305", "L306", "L307", + "L308", "L309", "L310", "L311", + "L312", "L313", "L314", "L315", + "L316", "L317", "L318", "L319", + "L320", "L321", "L322", "L323"; /* not wired: <24 8> */ + status = "okay"; +}; + +&clock_gpio_4 { + /* namespace and positions without LEDs or not wired bits */ + gpio-line-names = + "TMAM", "TMPM", "L402", "L403", + "L404", "L405", "L406", "L407", + "L408", "L409", "L410", "L411", + "L412", "L413", "L414", "L415", + "L416", "L417", "L418", "L419", + "L420", "L421", "L422", "L423"; /* not wired: <24 8> */ + status = "okay"; +}; + +&clock_gpio_5 { + /* namespace and positions without LEDs or not wired bits */ + gpio-line-names = + "CUP0", "CUP1", "L502", "L503", + "L504", "L505", "L506", "L507", + "L508", "L509", "L510", "L511", + "L512", "L513", "L514", "L515", + "L516", "L517", "L518", "L519", + "L520", "L521", "L522", "L523"; /* not wired: <24 8> */ + status = "okay"; +}; + +&clock_gpio_6 { + /* namespace and positions without LEDs or not wired bits */ + gpio-line-names = + "HLY0", "HLY1", "L602", "L603", + "L604", "L605", "L606", "L607", + "L608", "L609", "L610", "L611", + "L612", "L613", "L614", "L615", + "L616", "L617", "L618", "L619", + "L620", "L621", "L622", "L623"; /* not wired: <24 8> */ + status = "okay"; +}; + +&clock_gpio_7 { + /* namespace and positions without LEDs or not wired bits */ + gpio-line-names = + "AUT0", "AUT1", "L702", "L703", + "L704", "L705", "L706", "L707", + "L708", "L709", "L710", "L711", + "L712", "L713", "L714", "L715", + "L716", "L717", "L718", "L719", + "L720", "L721", "L722", "L723"; /* not wired: <24 8> */ + status = "okay"; +}; + +&clock_sipo_mux { + oe-gpios = <&rpipico_header 13 GPIO_ACTIVE_LOW>; /* OE:GP13 */ + addr-gpios = <&rpipico_header 16 GPIO_ACTIVE_HIGH>, /* A0:GP16 */ + <&rpipico_header 18 GPIO_ACTIVE_HIGH>, /* A1:GP18 */ + <&rpipico_header 22 GPIO_ACTIVE_HIGH>; /* A2:GP22 */ + status = "okay"; +}; + +&clock_spi_leds { + pinctrl-0 = <&spi1_wpcg_leds>; + pinctrl-names = "default"; + cs-gpios = <&rpipico_header 12 GPIO_ACTIVE_LOW>; /* LE:GP12 */ +}; + +&clock_btn_set_function { /* GP2 */ + gpios = <&rpipico_header 2 (GPIO_PULL_UP | GPIO_ACTIVE_LOW)>; +}; + +&clock_btn_up { /* GP17 */ + gpios = <&rpipico_header 17 (GPIO_PULL_UP | GPIO_ACTIVE_LOW)>; +}; + +&clock_btn_down { /* GP15 */ + gpios = <&rpipico_header 15 (GPIO_PULL_UP | GPIO_ACTIVE_LOW)>; +}; + +&clock_gpio_keys { + /* namespace and positions for buttons */ + gpio-line-names = + "", "", "SET", "", /* 00..03 */ + "", "", "", "", /* 04..07 */ + "", "", "", "", /* 08..11 */ + "", "", "", "DWN", /* 12..15 */ + "", "UP", "", "", /* 16..19 */ + "", "", "", "", /* 20..23 */ + "", "", "", "", /* 24..27 */ + "", "", "", ""; /* 28..31 */ +}; + +&clock_pwm_buzzers { + pinctrl-0 = <&pwm_wpcg_buzzer>; + pinctrl-names = "default"; + divider-int-7 = <255>; +}; + +&clock_buzzer { /* GP14 */ + pwms = <&pwm 14 PWM_HZ(880) PWM_POLARITY_NORMAL>; +}; diff --git a/boards/shields/rpi_pico_clock/boards/waveshare_pico_clock_green/waveshare_rp2040_plus.overlay b/boards/shields/rpi_pico_clock/boards/waveshare_pico_clock_green/waveshare_rp2040_plus.overlay new file mode 100644 index 0000000000..199666c54a --- /dev/null +++ b/boards/shields/rpi_pico_clock/boards/waveshare_pico_clock_green/waveshare_rp2040_plus.overlay @@ -0,0 +1,6 @@ +/* + * Copyright (c) 2023-2024 TiaC Systems + * SPDX-License-Identifier: Apache-2.0 + */ + +#include "rpipico_r3.dtsi" diff --git a/boards/shields/rpi_pico_clock/boards/waveshare_rp2040_plus.conf b/boards/shields/rpi_pico_clock/boards/waveshare_rp2040_plus.conf new file mode 100644 index 0000000000..a5452d4cd0 --- /dev/null +++ b/boards/shields/rpi_pico_clock/boards/waveshare_rp2040_plus.conf @@ -0,0 +1,5 @@ +# Copyright (c) 2023-2024 TiaC Systems +# SPDX-License-Identifier: Apache-2.0 + +CONFIG_USB_SELF_POWERED=n +CONFIG_USB_MAX_POWER=50 diff --git a/boards/shields/rpi_pico_clock/boards/waveshare_rp2040_plus.overlay b/boards/shields/rpi_pico_clock/boards/waveshare_rp2040_plus.overlay new file mode 100644 index 0000000000..8d7f8e560e --- /dev/null +++ b/boards/shields/rpi_pico_clock/boards/waveshare_rp2040_plus.overlay @@ -0,0 +1,7 @@ +/* + * Copyright (c) 2023-2024 TiaC Systems + * SPDX-License-Identifier: Apache-2.0 + */ + +#include "rpipico_r3-pinctrl.dtsi" +#include "rpipico_r3.dtsi" diff --git a/boards/shields/rpi_pico_clock/doc/index.rst b/boards/shields/rpi_pico_clock/doc/index.rst new file mode 100644 index 0000000000..6ccdf6eca9 --- /dev/null +++ b/boards/shields/rpi_pico_clock/doc/index.rst @@ -0,0 +1,620 @@ +.. _rpi_pico_clock_shield: + +Raspberry Pi Pico Clock Shields +############################### + +This is a collection of very versatile clocks due to its different feature sets +and sizes, the RGB capabilities and additional buttons and sensors. Nearly all +displays comes with a special LED controller wired over GPIO or other standard +serial buses up to the Raspberry Pi Pico. Additional momentary push buttons or +joysticks and a small buzzer are wired up over simple GPIO lines. Some shield +provide also a simple temperature sensor or Real-Time-Clock, mostly wired over +a dedicated I2C bus. + +Supported Shields +***************** + +Hardware +======== + +.. tabs:: + + .. group-tab:: Waveshare Pico Clock Green + + .. _waveshare_pico_clock_green: + + .. include:: /boards/shields/rpi_pico_clock/doc/waveshare_pico_clock_green/hardware.rsti + +Positions +========= + +.. tabs:: + + .. group-tab:: Waveshare Pico Clock Green + + .. include:: /boards/shields/rpi_pico_clock/doc/waveshare_pico_clock_green/positions.rsti + +Pinouts +======= + +.. tabs:: + + .. group-tab:: Waveshare Pico Clock Green + + .. include:: /boards/shields/rpi_pico_clock/doc/waveshare_pico_clock_green/pinouts.rsti + +Utilization +*********** + +This shields can be used with any development board, shield, or snippet that +provides a Devicetree node with the :dtcompatible:`raspberrypi,pico-header-r3` +property for the compatibility. In particular, the I2C1 bus on pins 9 to 10 and +some GPIO signals on pins 4 to 5, 14 to 22, 24 and 29 of this edge connector +must be free for communication with the buttons, buzzer, LEDs, RTC and sensors +on the shields. The ADC channel 0 on pin 31 must also be free for communication +with the on-shield LDR (photoresistor). The shields also provide the special +Devicetree labels :devicetree:`&rpipico_i2c_rtc`, :devicetree:`&clock_rtc`, +:devicetree:`&rpipico_pwm_buzzers` and :devicetree:`&clock_buzzer` for this +purpose. + +Programming +=========== + +.. tabs:: + + .. group-tab:: Waveshare Pico Clock Green + + Set ``-DSHIELD=waveshare_pico_clock_green`` and use optional the + :ref:`snippet-usb-console` when you invoke ``west build``. + For example: + + .. tabs:: + + .. group-tab:: Raspberry Pi Pico + + .. zephyr-app-commands:: + :app: bridle/samples/helloshell + :build-dir: waveshare_pico_clock_green-helloshell + :board: rpi_pico + :shield: "waveshare_pico_clock_green" + :goals: flash + :west-args: -p -S usb-console + :flash-args: -r uf2 + :host-os: unix + :tool: all + + .. include:: /boards/shields/rpi_pico_clock/doc/waveshare_pico_clock_green/helloshell.rsti + + .. group-tab:: Raspberry Pi Pico W + + .. zephyr-app-commands:: + :app: bridle/samples/helloshell + :build-dir: waveshare_pico_clock_green-helloshell + :board: rpi_pico_w + :shield: "waveshare_pico_clock_green" + :goals: flash + :west-args: -p -S usb-console + :flash-args: -r uf2 + :host-os: unix + :tool: all + + .. include:: /boards/shields/rpi_pico_clock/doc/waveshare_pico_clock_green/helloshell.rsti + + .. group-tab:: Waveshare RP2040-Plus + + .. rubric:: on standard ``4㎆`` revision + + .. zephyr-app-commands:: + :app: bridle/samples/helloshell + :build-dir: waveshare_pico_clock_green-helloshell + :board: waveshare_rp2040_plus + :shield: "waveshare_pico_clock_green" + :goals: flash + :west-args: -p -S usb-console + :flash-args: -r uf2 + :host-os: unix + :tool: all + + .. rubric:: on extended ``16㎆`` revision + + .. zephyr-app-commands:: + :app: bridle/samples/helloshell + :build-dir: waveshare_pico_clock_green-helloshell + :board: waveshare_rp2040_plus@16mb + :shield: "waveshare_pico_clock_green" + :goals: flash + :west-args: -p -S usb-console + :flash-args: -r uf2 + :host-os: unix + :tool: all + + .. include:: /boards/shields/rpi_pico_clock/doc/waveshare_pico_clock_green/helloshell.rsti + +More Samples +************ + +LED Blinky and Button +===================== + +.. tabs:: + + .. group-tab:: Waveshare Pico Clock Green + + .. rubric:: LED Blinky + + See also Zephyr sample: :doc:`zephyr:samples/basic/blinky/README` + + .. tabs:: + + .. group-tab:: Raspberry Pi Pico + + .. zephyr-app-commands:: + :app: zephyr/samples/basic/blinky + :build-dir: waveshare_pico_clock_green-blinky + :board: rpi_pico + :shield: "waveshare_pico_clock_green" + :goals: flash + :west-args: -p -S usb-console + :flash-args: -r uf2 + :compact: + + .. group-tab:: Raspberry Pi Pico W + + .. zephyr-app-commands:: + :app: zephyr/samples/basic/blinky + :build-dir: waveshare_pico_clock_green-blinky + :board: rpi_pico_w + :shield: "waveshare_pico_clock_green" + :goals: flash + :west-args: -p -S usb-console + :flash-args: -r uf2 + :compact: + + .. group-tab:: Waveshare RP2040-Plus + + .. rubric:: on standard ``4㎆`` revision + + .. zephyr-app-commands:: + :app: zephyr/samples/basic/blinky + :build-dir: waveshare_pico_clock_green-blinky + :board: waveshare_rp2040_plus + :shield: "waveshare_pico_clock_green" + :goals: flash + :west-args: -p -S usb-console + :flash-args: -r uf2 + :compact: + + .. rubric:: on extended ``16㎆`` revision + + .. zephyr-app-commands:: + :app: zephyr/samples/basic/blinky + :build-dir: waveshare_pico_clock_green-blinky + :board: waveshare_rp2040_plus@16mb + :shield: "waveshare_pico_clock_green" + :goals: flash + :west-args: -p -S usb-console + :flash-args: -r uf2 + :compact: + + .. rubric:: LED ON/OFF by Button + + See also Zephyr sample: :doc:`zephyr:samples/basic/button/README` + + .. tabs:: + + .. group-tab:: Raspberry Pi Pico + + .. zephyr-app-commands:: + :app: zephyr/samples/basic/button + :build-dir: waveshare_pico_clock_green-button + :board: rpi_pico + :shield: "waveshare_pico_clock_green" + :goals: flash + :west-args: -p -S usb-console + :flash-args: -r uf2 + :compact: + + .. group-tab:: Raspberry Pi Pico W + + .. zephyr-app-commands:: + :app: zephyr/samples/basic/button + :build-dir: waveshare_pico_clock_green-button + :board: rpi_pico_w + :shield: "waveshare_pico_clock_green" + :goals: flash + :west-args: -p -S usb-console + :flash-args: -r uf2 + :compact: + + .. group-tab:: Waveshare RP2040-Plus + + .. rubric:: on standard ``4㎆`` revision + + .. zephyr-app-commands:: + :app: zephyr/samples/basic/button + :build-dir: waveshare_pico_clock_green-button + :board: waveshare_rp2040_plus + :shield: "waveshare_pico_clock_green" + :goals: flash + :west-args: -p -S usb-console + :flash-args: -r uf2 + :compact: + + .. rubric:: on extended ``16㎆`` revision + + .. zephyr-app-commands:: + :app: zephyr/samples/basic/button + :build-dir: waveshare_pico_clock_green-button + :board: waveshare_rp2040_plus@16mb + :shield: "waveshare_pico_clock_green" + :goals: flash + :west-args: -p -S usb-console + :flash-args: -r uf2 + :compact: + +Input dump +========== + +Prints all input events as defined by the shields Devicetree. See also Zephyr +sample: :doc:`zephyr:samples/subsys/input/input_dump/README`. + +.. tabs:: + + .. group-tab:: Waveshare Pico Clock Green + + Print the input events related to the five on-shield user input keys + and two user keys using the :ref:`Input subsystem API `. + That are: + + | :hwftlbl-btn:`SET/FUNCTION` : :devicetree:`zephyr,code = ;` + | :hwftlbl-btn:`UP` : :devicetree:`zephyr,code = ;` + | :hwftlbl-btn:`DOWN` : :devicetree:`zephyr,code = ;` + + .. tabs:: + + .. group-tab:: Raspberry Pi Pico + + .. zephyr-app-commands:: + :app: zephyr/samples/subsys/input/input_dump + :build-dir: waveshare_pico_clock_green-input_dump + :board: rpi_pico + :shield: "waveshare_pico_clock_green" + :goals: flash + :west-args: -p -S usb-console + :flash-args: -r uf2 + :compact: + + .. group-tab:: Raspberry Pi Pico W + + .. zephyr-app-commands:: + :app: zephyr/samples/subsys/input/input_dump + :build-dir: waveshare_pico_clock_green-input_dump + :board: rpi_pico_w + :shield: "waveshare_pico_clock_green" + :goals: flash + :west-args: -p -S usb-console + :flash-args: -r uf2 + :compact: + + .. group-tab:: Waveshare RP2040-Plus + + .. rubric:: on standard ``4㎆`` revision + + .. zephyr-app-commands:: + :app: zephyr/samples/subsys/input/input_dump + :build-dir: waveshare_pico_clock_green-input_dump + :board: waveshare_rp2040_plus + :shield: "waveshare_pico_clock_green" + :goals: flash + :west-args: -p -S usb-console + :flash-args: -r uf2 + :compact: + + .. rubric:: on extended ``16㎆`` revision + + .. zephyr-app-commands:: + :app: zephyr/samples/subsys/input/input_dump + :build-dir: waveshare_pico_clock_green-input_dump + :board: waveshare_rp2040_plus@16mb + :shield: "waveshare_pico_clock_green" + :goals: flash + :west-args: -p -S usb-console + :flash-args: -r uf2 + :compact: + + .. rubric:: Simple logging output on target + + .. parsed-literal:: + :class: highlight-console notranslate + + \*\*\*\*\* delaying boot 4000ms (per build configuration) \*\*\*\*\* + W: BUS RESET + W: BUS RESET + \*\*\* Booting Zephyr OS … … … (delayed boot 4000ms) \*\*\* + Input sample started + I: input event: dev=wpcg-gpio-keys SYN type= 1 code= 28 value=1 + I: input event: dev=wpcg-gpio-keys SYN type= 1 code= 28 value=0 + I: input event: dev=wpcg-gpio-keys SYN type= 1 code=103 value=1 + I: input event: dev=wpcg-gpio-keys SYN type= 1 code=103 value=0 + I: input event: dev=wpcg-gpio-keys SYN type= 1 code=108 value=1 + I: input event: dev=wpcg-gpio-keys SYN type= 1 code=108 value=0 + +Analog-to-Digital Converter (ADC) +================================= + +Read analog inputs from ADC channels as defined by the shield's Devicetree. +See also Zephyr sample: :doc:`zephyr:samples/drivers/adc/README`. + +.. tabs:: + + .. group-tab:: Waveshare Pico Clock Green + + Read and print the analog input value from the one on-shield + high-resistance LDR using the :ref:`ADC driver API + `. That are: + + | :hwftlbl:`Rₗ` : :devicetree:`zephyr,user { io-channels = <&adc 0>; };` + + .. tabs:: + + .. group-tab:: Raspberry Pi Pico + + .. zephyr-app-commands:: + :app: zephyr/samples/drivers/adc + :build-dir: waveshare_pico_clock_green-drivers_adc + :board: rpi_pico + :shield: "waveshare_pico_clock_green" + :goals: flash + :west-args: -p -S usb-console + :flash-args: -r uf2 + :compact: + + .. group-tab:: Raspberry Pi Pico W + + .. zephyr-app-commands:: + :app: zephyr/samples/drivers/adc + :build-dir: waveshare_pico_clock_green-drivers_adc + :board: rpi_pico_w + :shield: "waveshare_pico_clock_green" + :goals: flash + :west-args: -p -S usb-console + :flash-args: -r uf2 + :compact: + + .. group-tab:: Waveshare RP2040-Plus + + .. rubric:: on standard ``4㎆`` revision + + .. zephyr-app-commands:: + :app: zephyr/samples/drivers/adc + :build-dir: waveshare_pico_clock_green-drivers_adc + :board: waveshare_rp2040_plus + :shield: "waveshare_pico_clock_green" + :goals: flash + :west-args: -p -S usb-console + :flash-args: -r uf2 + :compact: + + .. rubric:: on extended ``16㎆`` revision + + .. zephyr-app-commands:: + :app: zephyr/samples/drivers/adc + :build-dir: waveshare_pico_clock_green-drivers_adc + :board: waveshare_rp2040_plus@16mb + :shield: "waveshare_pico_clock_green" + :goals: flash + :west-args: -p -S usb-console + :flash-args: -r uf2 + :compact: + + .. rubric:: Simple test execution on target + + .. parsed-literal:: + :class: highlight-console notranslate + + \*\*\*\*\* delaying boot 4000ms (per build configuration) \*\*\*\*\* + W: BUS RESET + W: BUS RESET + \*\*\* Booting Zephyr OS … … … (delayed boot 4000ms) \*\*\* + ADC reading[0]: + - adc\ @\ 4004c000, channel 0: 907 = 730 mV + ADC reading[1]: + - adc\ @\ 4004c000, channel 0: 910 = 733 mV + ADC reading[2]: + - adc\ @\ 4004c000, channel 0: 1233 = 993 mV + ADC reading[3]: + - adc\ @\ 4004c000, channel 0: 1196 = 963 mV + ADC reading[4]: + - adc\ @\ 4004c000, channel 0: 569 = 458 mV + ADC reading[5]: + - adc\ @\ 4004c000, channel 0: 336 = 270 mV + ADC reading[6]: + - adc\ @\ 4004c000, channel 0: 285 = 229 mV + ADC reading[7]: + - adc\ @\ 4004c000, channel 0: 181 = 145 mV + ADC reading[8]: + - adc\ @\ 4004c000, channel 0: 56 = 45 mV + ADC reading[9]: + - adc\ @\ 4004c000, channel 0: 59 = 47 mV + ADC reading[10]: + - adc\ @\ 4004c000, channel 0: 56 = 45 mV + ADC reading[11]: + - adc\ @\ 4004c000, channel 0: 480 = 386 mV + ADC reading[12]: + - adc\ @\ 4004c000, channel 0: 868 = 699 mV + ADC reading[13]: + - adc\ @\ 4004c000, channel 0: 1878 = 1513 mV + ADC reading[14]: + - adc\ @\ 4004c000, channel 0: 3256 = 2623 mV + ADC reading[15]: + - adc\ @\ 4004c000, channel 0: 3413 = 2749 mV + ADC reading[16]: + - adc\ @\ 4004c000, channel 0: 3446 = 2776 mV + ADC reading[17]: + - adc\ @\ 4004c000, channel 0: 3470 = 2795 mV + ADC reading[18]: + - adc\ @\ 4004c000, channel 0: 3451 = 2780 mV + ADC reading[19]: + - adc\ @\ 4004c000, channel 0: 1029 = 829 mV + ADC reading[20]: + - adc\ @\ 4004c000, channel 0: 1004 = 808 mV + ADC reading[21]: + - adc\ @\ 4004c000, channel 0: 1005 = 809 mV + ADC reading[22]: + - adc\ @\ 4004c000, channel 0: 1000 = 805 mV + … … … + +Sounds from the speaker +======================= + +.. tabs:: + + .. group-tab:: Waveshare Pico Clock Green + + The sample is prepared for the on-board :hwftlbl-spk:`PIEZO` connected to + the PWM channel at :rpi-pico-pio:`GP14` / :rpi-pico-pwm:`PWM14` (PWM7CHA). + + The PWM period is 880 ㎐, twice the concert pitch frequency of 440 ㎐. + + .. tabs:: + + .. group-tab:: Raspberry Pi Pico + + .. zephyr-app-commands:: + :app: bridle/samples/buzzer + :build-dir: waveshare_pico_clock_green-buzzer + :board: rpi_pico + :shield: "waveshare_pico_clock_green" + :goals: flash + :west-args: -p -S usb-console + :flash-args: -r uf2 + :compact: + + .. group-tab:: Raspberry Pi Pico W + + .. zephyr-app-commands:: + :app: bridle/samples/buzzer + :build-dir: waveshare_pico_clock_green-buzzer + :board: rpi_pico_w + :shield: "waveshare_pico_clock_green" + :goals: flash + :west-args: -p -S usb-console + :flash-args: -r uf2 + :compact: + + .. group-tab:: Waveshare RP2040-Plus + + .. rubric:: on standard ``4㎆`` revision + + .. zephyr-app-commands:: + :app: bridle/samples/buzzer + :build-dir: waveshare_pico_clock_green-buzzer + :board: waveshare_rp2040_plus + :shield: "waveshare_pico_clock_green" + :goals: flash + :west-args: -p -S usb-console + :flash-args: -r uf2 + :compact: + + .. rubric:: on extended ``16㎆`` revision + + .. zephyr-app-commands:: + :app: bridle/samples/buzzer + :build-dir: waveshare_pico_clock_green-buzzer + :board: waveshare_rp2040_plus@16mb + :shield: "waveshare_pico_clock_green" + :goals: flash + :west-args: -p -S usb-console + :flash-args: -r uf2 + :compact: + + .. rubric:: Simple test execution on target + + #. play a beep + #. play a folk song + #. play a chrismas song + + .. parsed-literal:: + :class: highlight-console notranslate + + :bgn:`uart:~$` **buzzer beep** + :bgn:`uart:~$` **buzzer play folksong** + :bgn:`uart:~$` **buzzer play xmastime** + +LED Panel Orientation and Bit Order Test +======================================== + +Draw some basic rectangles onto the LED panel. The rectangle positions are +chosen so that you can check the orientation of the LED panel and correct bit +order. See also Zephyr sample: :doc:`zephyr:samples/drivers/display/README`. + +.. tabs:: + + .. group-tab:: Waveshare Pico Clock Green + + .. image:: /boards/shields/rpi_pico_clock/doc/waveshare_pico_clock_green/display.gif + :scale: 75% + :align: right + :alt: Waveshare Pico Clock Green Display Test + + The following samples work with the chosen display. That is: + + | :hwftlbl-scr:`LED` : :devicetree:`chosen { zephyr,display = &clock_display; };` + | :hwftlbl-scr:`SIPOMUX-DISPLAY` : :devicetree:`clock_display: &sipo_mux_display_8 {};` + + .. tabs:: + + .. group-tab:: Raspberry Pi Pico + + .. zephyr-app-commands:: + :app: zephyr/samples/drivers/display + :build-dir: waveshare_pico_clock_green-display_test + :board: rpi_pico + :shield: "waveshare_pico_clock_green" + :goals: flash + :west-args: -p -S usb-console + :flash-args: -r uf2 + :compact: + + .. group-tab:: Raspberry Pi Pico W + + .. zephyr-app-commands:: + :app: zephyr/samples/drivers/display + :build-dir: waveshare_pico_clock_green-display_test + :board: rpi_pico_w + :shield: "waveshare_pico_clock_green" + :goals: flash + :west-args: -p -S usb-console + :flash-args: -r uf2 + :compact: + + .. group-tab:: Waveshare RP2040-Plus + + .. rubric:: on standard ``4㎆`` revision + + .. zephyr-app-commands:: + :app: zephyr/samples/drivers/display + :build-dir: waveshare_pico_clock_green-display_test + :board: waveshare_rp2040_plus + :shield: "waveshare_pico_clock_green" + :goals: flash + :west-args: -p -S usb-console + :flash-args: -r uf2 + :compact: + + .. rubric:: on extended ``16㎆`` revision + + .. zephyr-app-commands:: + :app: zephyr/samples/drivers/display + :build-dir: waveshare_pico_clock_green-display_test + :board: waveshare_rp2040_plus@16mb + :shield: "waveshare_pico_clock_green" + :goals: flash + :west-args: -p -S usb-console + :flash-args: -r uf2 + :compact: + +References +********** + +.. target-notes:: diff --git a/boards/shields/rpi_pico_clock/doc/waveshare_pico_clock_green.drawio b/boards/shields/rpi_pico_clock/doc/waveshare_pico_clock_green.drawio new file mode 100644 index 0000000000..c9b8c82748 --- /dev/null +++ b/boards/shields/rpi_pico_clock/doc/waveshare_pico_clock_green.drawio @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/boards/shields/rpi_pico_clock/doc/waveshare_pico_clock_green/display.gif b/boards/shields/rpi_pico_clock/doc/waveshare_pico_clock_green/display.gif new file mode 100644 index 0000000000000000000000000000000000000000..0a62a25bf2d20b61ea2df25ce884d749459073f2 GIT binary patch literal 32791 zcmeF2^-~;8)bDqf#bJ?PL6^lH0trr##hu{p5;V94x8M+h1W0gq*Wm8%lHl$R*_-FR z@1Jmgyr(|XbLv!2_4G`2SI@W4NXts`@tcf*K)^d7;QtyD3KAFv2?+^|gaQVmf{{_d zNa!Fi8WIQxg!iuo9sq=g3?c>tsDMbMV7&hc;r)x^{b$6)#3cWY*Tf_w|D1otYvR`= z|BQ@`jDms!00V&OQGguCcrXBf8vx`&M&d`q;|2g=cz7^805={UHy-RiABM*b`)4#X zG_4a!;63c(qMRLFhB%1UIaHFjT_{RF5Hm`alBA0)(7 zB;T-eBKl)yCe&+rk{`VdH8IwRUxNauML*u<*9Bv1B)MwC8aA z-wFWM|E~CNOaagk03aHD!# z*_v$`G5;FvY;lXokrd8i?KIiig0XZyd&4C!x~PetqQMvxhaaMnbELjn9@O%T{AAOw z0mRF>9jX^-mVT@+LGC1~G;Rjq%Da~>)mTrI5FVk5t~5Gqb%#EoimtWTUktDLEL3d# z3P4~$6g;bbcLqJvpQd|WnDoQ|;YvbiqB}#0+-B=#&D<6vS^QDA3f|ZI-9=Ozgxlfu z&?JA;kspe!4JYqEJ0H!DNn)m~OZg+z^p&n63HSJOSIn323vP}U3&|7y zs6~35e6Wr{P$~axVfI*md-c2Cm)R7%A zGCAS&^VVA-&1)po(E_*oTXA@XzY_^{oTftP6^FzuPq&?4~>QGwo%#j@zKYLcsWQME>f#c-WVU7v|KJ zFVq>IBIrx@bE4lJ?&ro!F(2e5X?{G&Pqi#LD9CU>JSfZxV?I>wc)=U=3(HFig@)1Q zOcC-ZAWZtGLP$%d3DnwnDL=O)^KMjj+%g|m{kbTitm>Tx9M@dY9Ua$Bejg~Sp3<~E zsp@)^JE>o-;5}(r3oB)*Sx`D!ulZ9zcG`F-h3U}R;(SL=?0O!V& zP)o4&Wdc~AccC$qop)pL9-sH%O0!<{5@^|7^pRMVUG$TC9A6AT!&xr}X;bWKhAxJP zZ4+)jnn+SdtM^KlX#zlK#F`4!J(#Q+$5#`gsBG7haAN!GDH(?H>uJi`bMZ1QC%i!_ z9zZu541Y{0^n*g^op_f*INR-_d5Zn*l67IZ`?9j5q9dU`qbVBvbD3QcVL(Os-Ma4` z;^b~40F|AukAvIIxs#nazeqM^h z<3UlOVf8L|bGkl`)ntwvT_aP^$^6%qu+=9Kg{(t!r;zi}IB1PP9Ed@t3q$wZk%=UZ5DTB>!s#ps zij|EftzB36WiQbEf^7~g0%?0)*CAiiaJzPc%uqsTA`#S9vT!AvA43z z!-4uIg9x&q$f=`w^ei?*NPev{A*1lg{}j37<^o}F&@BdcFi6(gwL!{XGL?eq%cwi z-KIuoP~_*pneM;c`jeUcjD8ZW_P zW~;vqxoMXY)(!#k1R}FWgN8Ni@x3QkQz+fK0VQSRNFkhvF#FDcR^~;8(W+B?`!ZI_ zbWdu_nUHKxvu%S#+{>(>;6Nyb3LgoQdR7SR&huBXLASzD$wu^rhY4~<9&YIqFR2Q3 z;b((H$3Smm{>kit#TJ$KDNs@;q3r)|z#hmhnuYjMuX4R^%$bo0oNb+ppF~`;BYFI%-GTq}qa8 zk;R4+h4DAUS@bPM2aKuRx8P!M5Ke!Ha1$^3pV$Uj7O3eN zvv=!9mrq~tb~OqEiN2;_liszgaIdb%uj|)0dc3-=e|PJ#KD%~PWxHkz)DftKJ-K$P zWQ7Q=nxKoT0Fg{TR*|oYp)&&lF_N9a_i~`9o`|B_Uh5Msk(~Sa#$BG6zFXU0D6K}A zd)n1eEMNgXAlTVhyp|=vN(k#+y+W2KWZwxD1z^wxbpla%R|V5;ilNKDO~v`s364b~ zTvI?3#aUcNf}EK&9KXAc5L`YB=8uV^Q(B7tOn(+khV@6xwNU1y$o4a;^^{nf&!y9f zk$ehPzq{|7-)HLwae?)*8=pP5nCL%|;g~?yl$;=t{z(E>W8l%trSDf^u4I3^1!WZ6 z(Gv$wg&A_kcc`MiPQNV7&ZyA_$KB@+I4!9r1JS48fhk&mYYvXj=*I;}uam1n{tN>v zj0+FIo$R;5u9-mj#o+pxQ@4Y})SKrq55zUT<9$3fNxWx@vp<9X<1gv6+*!K&wO5*d z6TT3fosYA3>nYbYvnYu2hWS&z0)8vxgjRtBv%tt{_%7GX zjYsH!_v0NW{~h<+0X^MYZUPG*{!SB@092X*AA(Jv6;xNRO;EO$JApP(pi|Ss2~~*` zRS{|;?12h3<|K&!e3}p5MNwbU3RIl?EFSDvGT=|%&2Xz4fh+CbF>w?Pe{tkajkZ>YlYNI6YN)9<`j2F$5G*bE^> znD2X=yb97uj(A-g;S-O}!p%tc);IOBZP^VITCM$wRzjcP%Y33*5&+luzr zNsW>O^X^6nLnHZ(-DE{A6`W9Mae;VMt~GCsysD6h=HmiiYu7dzH5Nn%Yo*z^2!}Rt z*WGceq9+Tea0=jp#hO3@RSrsb>D1x+Oj$@`IzYxOr1-ay`9#)&n=yt9>c%t~3(euN z4-PtW-tn^Ov@$JTE`7or^z{fxLE(=3bfDx7K(5pQ${71mOZxlrrjyI0DfGnh?&06b za)Fy1K62}H*yv#7YB0UB(9rfL4K}^Vwsk?(Bzklt(}_*}7Ph(L_b$wOBR{Hjo_jAM zfj&1|>Wk5lS2TJL;O`P=S`k=j6Rf}qb}VvL=mg7c#wcy7FZTZnDygb~v5*RGd2Imq z{;ByIR2V$u7=VDpbdf9N6m=EgHxQ;qA*y7dTV$a-sfvoI7U@mlG-FgAe^H(ekN^tA ztojt`ZI6Y(1z>I#;bj%!SA8P7@k(gb+bA99WSg8#!ElAM&MQyF3+MvFBZJ z+ENr(gOx# zNZ1M>qm@>Xq*p(>R5?Vxr!WRWSAa0V8d|*?`lo7YpBiS{8mKLh<*9~drG^u;_KjdI z3qr5V2)HG-`THb)J#D-E_RjiU06Lbi?kQH|X4 zZwP&=?}LG_;~Urnn?8;-&|o$N$v3?xYYZoAij;2>SZVrF+LXXj6YDFYV76~O zwZ)Y-`}&mYZ8tLHe*5uVJz1_ObNSb$V8@T);*iIpt5Wq_!J>Qlj+=BhZ0;7Pm0G0H zCS=x5)aPpSwoX_p5L3U&Nxlx_96+GoMdaH>hy_IF1eE9jUPX67?Yc-uyO1`!sC~O} zIJ+sHyBMRpnDx6^SG!?tT`a6U>^{HbaOLq2Z9QXDm_34uLP4;rq$ZMD?NYM-STk7{)vi4hN^i$XO z+bQ(ZJ@wm@4>)5D(CQ7iE7Z{&qxh~4_^l3@Zw`n~0#K^zkgEp#GX}pPga$*)1|l;C z16K#4?FJ*B2jhf>V(o^^afgBw29xZD{6>c?IfqQ52e@#N97g*KqlaDf2MRNWZOD-> zfFq6yBX)KpHqj$itTj^PJ~DPCv}lUp5!nNQ(TnR!pkNivWaZxyS>t%otk|s+sd0TYerZdV~uZ>jqi|8EFO>N z+fCfH^&FK=oazI>0Z2~qC^l6nwxW}0nUg5?lg3#9b<9bS;v`DuBtiS6?c^j5#Uzr! zB&y;Rn*9_B8vwU`>ea~pSO3GG~GCa%20lhyL>6=*q{Jxz?DKcDB_Hwt3h{ z7jG3xYRrPoB#KEVppFGF)V}JmwmLzvHlw&UkG)pHvNnt;UmG7=8+=&{K0)znUt3gM zPmNgz#jkXptoKu_wqS2KPz?OSUcMk-xDsA%QJj10I!BA7Enbu{W0!f)oFR|}@{wIx zMu%QgEZ-`w-j9txzN|mn|L!x`xQzMz%3++QwPi_h?RR-AwbI(cODo;4RR+kP!}33W zgaJ&kODvErHukO6m(2%?-%pvpaew{3h}j~j*dq7a_;Iq~u3AEb$s@K|$h>LcVr*5| z5RM7S;fJESK(pFVGtoY*pdoEjvTwil`)xA5#ecd*db+cz|J!W+w~gN_5Bnbv;Vmwa zC1=Ae*S~*UP8Z!Edo;0s+$;8Y*>|nj_l0A3H_CQ{5lXva4!faB`xXxS%R)82J{G=j z=|IyQG9S6vHw&eTG|gr0l?Z{1@m~Q!YO3G9Dlk@{&usrG01xiE7;lw_S#Xjd_s9O) zkN-7h{A1tFZ@+bYKl1NR^xyqP_G5B8B>x|a2GDg-z_IVIdO!hv(AA56;$O53*>ma@X%uzX$5 zdG>dBZ~XM&^yrBFm^yBr>HX=x;c3e{u+$dG3E{Brr`U}Iy@DxSVHscXDX$4kTybxp zyhXGMcdWiwz7~6b&GP<|apRP}cQ zf_njgtGBhPSiCV*6h!Lyarf4c*$LGPasCaEXs-Zp^_f(=zS*|1I%;_TRE6_U!*O}! z|8!D$c`3mvFl-7D0+~sucqk5= zK(zL`ad#*&hb7OV*me{No#GF;joS7wg!aQPp&@5lh3{PE4Q1$81tS@Z9=8e)udEf) zgu<5zbi@wS3KTO%?B#keVu%4v>hTvr$T3VG3`LR2H0_Xy*^_bxUBbZ;6rRa>MO7h6 z5EQ60SXCTV85h_2va>uZcsvmqy1T8aYBESk_bNH3DL5QFL*bfwov8;rp&%gC1Or>A z_f@i`6Kcq@>#nEf@}j=8FX`SOY!_LW+^^9-W%aK#vjwecPx1Dzz2b*3uygS_YDUH?*3r-uWq)kCCPFucvBGHy;iC7HbF@)eC5(ArvAJ zub)#fL+CD5VBs&W`z&$e%xK*;=#Skr)qSKs#}EN`6=o1hvN2X|uS$^_q)8+Szzw%-b0gljm=XW){!R zW0!eZFk!L984MAk41?M+4E4btbX*?u092vvK^NtA-~GVYW>7g&75VMGNub0PK#WWB zwJ_%R^K8tk5YdDCDhR&-CWz;i1~wrBBc77RZ`IdCM5bnRB5pcA;faKrJ8vr7w)Cv( z=LQXgiM$5lKfOd~MF!TV7MZdb>MW%ud`{a*OS9LZyR5>F3bQU94q7g60YzIq)KUD2 zrA`exh7cwV(x4F_+!y1%P@a?IR0;xSfH?FZKo@#FLDVawd{G%)1AgZ$Q6~C~`D4iV z;2Y1GbdCxg%kc8Hm7NST`Q+V>(j&b+viI|;yuE^&ZRT{!C~4+N{=q^Q@ffH=j$K>~ zzGopHq86{h#C~eKa>SfISOE&`9ru|cr9QI~YXVB`F^n54Ya6~Te`Z}xGtH`4mp^U~ zLW5}sqA6yQ3Q4u4~cvpy)Be>g7gLcqCCnAeUJ86X>CbE=BkauG38cr^(zS)?Bj6Hig9D#2`sB8bN zi%+ttv2j#;5X)6zT*r>#!q3?fLE55^gm~1_cELD-jBprfLb$4esYEiG$OS(hwN_FN ze(}B}W0-1`*(w!i&bsIAE^ata*$=WUH0hogPUey)Bp>t5mW`zZCU!J&3^2cpIMH-` zINThDx)emj=$yc&ErvH*BQ9WB5%cYsoW9tqNxo&@n_U78vd#&=cblLw<@^JH%gTji zoh23P(>dsS;i-$Le#=eDXR<+;*H2FLsjRbL{hZbpK06J_)K4YnACj_Uo=F^=-5!5V z?JChmh*_T>i?-mL&h4vL!66<~O#5ai`R<)>ODu zlHaTHeM#;^ky!Cr>R0*J5|SlTWJ$BR65wJvu3@#5A3Oy_nM|@2AJx8y@Z@m|TZ+g1 zQTAgd$d;ryR7Lex&Vz&&$rCb)rnRWsGb8Kr$N&MCivo6U%uCL6DMsR7^@Lg@%8mk44=~AB`QEm2#osD9t&QRpL>JkGsGgX#= zPK@LV_j)#yPfrUgq{&tFJLL|aSG4||x>vT}u!*%V6PAHGzn^#o)^`dR9ER=CpY=Mp zpA02pj=EGVk5wqNJQ_Ks;Y#WbQ=(Bl(oiV(Yx$tZew~5 zR|XrbyL=;V<2JW7GUHfQJ>R`Li8ZUD@W}T`q)8?*cAdf{$^S^?dQL_dR{y(8fOs6q zbaVkvo>80iE9I8y^!2LXB?Zfd_2zMl`KzKi@(JOYv{~!7H>DG#M;gJe$7_C}mtXz+ z0FYuCp0LO9oer@u^_eSwpg8poPuDVMXj}@@xUI>}JhobCSoW!R%BpX-2c1mvdJ_11nncw}vioqDopuMN=e*Ibl4TJGsBFNm;rBF+Ttt)9}C zQF!e%K5!x%$-i#tW_Rzc{}PC`nLcEl-_-ZjckP=wc?TLpg$(oGi)MG0RN>ymM%zYnBuVT&wjw-bOWRSfOQOOltPpik zJvOfQ#;>dPifsEC#dlMJ-Ln%xu^doX2coRp&3GE60yr1+iy!^T0d%*Qi+B{l0Z^nK;3MTXE#x%Tj&Tl;gaUm=s&eraPUSYe2 zzW3c{uchmi{(J6`=)2ot{4gf{_bR*cIY;5={dA+BPu0(tZ?ubGOMw4<-}}GkNZCN* zTakyk_kLHo9e@oZ|L2vCp1T2~zk7x6pHGzkJ{0;Ro(DQMM@06QMUGfH4+KT`^39=t4==6Rm=S#|R(V^M0LjZGhBD&vVB^i!CZKiU!MpI)ySB`_ zUb%MVa&~#@ioK>S0zm=f0Z6A_jMo=pNgyQT`*-BCVwCzwRB$RNK{s%ui$Woo5-v{T zTLdNVrswHqOzM7{B~H)U%^)Pss@~0fEY29+%}D^juM;DQ4nz=?{UXlmA|a1_4e#Nz z>ymR8A-V44@$C`H>p_3c!cd44+ib^L?G$Il35uluBL|0H(@NUG!KQGsFL35GI8#>_ znJ3e>b})x=0CO*VV=_VU7*78TkMk@F$CXqbg@37uP^azF081*VOVYoF>EyAImB5LH zBuSSfIS%@!Z3?UP;AF$?*Nk6{Y2Xs-QgYsK>yJ`a!+BN;aPyqRFDB=F8^( ztD*jAQnrDi7^>-hr(>!6hkknk={TsgQ=JsO%>Zhy)UUvPMehRdXWFfFDbrbc(J~AP z;{f7RU>jM31&>TY>cB)of2cyi=iUJ_P=4P-g7bDN;)|>Fmk>x~ugv!3pxbCntdMj# z<3I>GMVN1DIPK7+Y_Dlqq)j%kB)%dzNj6_b7Uhksx9ea=n=DcBV04>I+%;N!UY{#L zV!Rz%cAjLOd18WVf7t3!qU&&x(9pNzftFGXz-DCGe!D66S3LY*b~U-*L$V6hWoznW zi}eYCxDfgSkcYZ_u6abmYJdGRUNbpcO9-Tu2dxbbY4;t;u9L6MgVvJE*Qv|&cTiTDgGaT~nuWKCVhrssa(`dk%?R!c#b7B9 zC8!D0DT}d%vlDHT+KRDS z*y^9`(F}Cdob%^2*JiFmCOtIf9EC@WG*p?;HJ>tM(?&IYW;MNq)x7Fwgx+dF)8=sB z#s=Ca4(n)%#u(GAYi^^DQ>d#fK;AEReV_hXJOswkfU zpFaI1-vFb)Fj2qUK4JiyZp31B$W7l+cU9+cbr^fCpN+nSZq@K*vAte*zJ4YDWaYtC zw~c0|^QFB=pr|;Jc~zqb;r3@OZ+dO@#h_5FWQ~ydPkTbla&d}y@lR5wFkQp+OQtk$ z!ySv@*u?du?&3rH;{6k*69cBq7Q-KpMF(q!-!IoMkvB3(4YNF%x9pkk*bILQ8$Mtg z=C*8PU#>l#p!;~w7RJb~u)#M4*ni8hBZ;*Ak$VRY69!T8q5Kd=O=jtZl`opIjgzuX z)EMKXmM<(DFMTYZeKdwZeq)7|FCK1U{M}qi+-wl906Um8c>hMZW$Aegc)eaq7Pbk} z+(dFnUUZx418-Io835-6zg-E?rB|nrwFP#`dK`K3JxL#oODYXp2QGckoIec0G zY`^}nEB%2={NZXaMF4E8;UBngk9fp#IZ2}GvZFY83mS3Es^4jv@mZS5=9)>?ngQj_ zc5h4l*yflQkf(2^ zc`_<``)A`ry+JLPkPEk_S*?i6j$UcKrkMqQl!aFMj=F<|-VC??D-O-4S_PLn-d!G9 z+d7d79)+hmX%XZa`g&cN`4J}O}Z!f)e^w-~Pe6RgIU2jmZBO6w)XUVLw zZs~ezslEI50m~Fn1o|Md(;nRDna=6*fd@~b(Q9PyQ!b}p1+N!3r>_IADawApX+xl4 zqhD-eu#|N;#2OJ%!TZI*I<#W%OM|s{)PA((zPq4x3?*;mt#vG9-{q@y{CtBm*>>!@ zRic!&v&%tv>_H5qMQwi3E4HcVYYT^NOIB?@$yM_YN`V{}u55>v^r$+9H-~vhhxy~p zd71)6R|lDX0zU)~^ISfbj2~vMe=I)wSorj@Ecr0|_OSZb$DE@B$K1mbk(Nxu>T;CB z3{2a)cSrRo0;LT{&42lGb6Xi&<*1XbGAuFtWq|~Yc48o)zgS?OrCpB*?O4P(22^;? zrELmHc-T;Qtmk-Cs(l(MaG>^hw&!?qw{4<9XnOs)PvT_O@MO&4WJ;uc$ns?I*YVQ) z@vL9KLV+D(O;dQp60kaMzf5$pM&z)$donF}Iw|ik#p1Af+g4%<+&#-`_f%T?z8O1Uqs&IX;G+Jyo1t z_H^7-IKHeqKAoQ3tvdoZ&Vd7tZ|>hCAsoRtPC$?M&z6oT6OO1jP8dI(FyEh}`8#15 zIbl0GK{}jpE6*{59S;7kbP^p0z0T{G0`|FIkT@RqP=fHhF<`FZZ{XtGy%#Lto-fPY zly~B+*WFC|;?xTlRNzaR#%^lFCmP}&azytV{Y%EXPt4)Y>`BhBy$gEfOWHDLwvI~* z92W%bPvZ~^wR&G}QZq}%`W)p4~X}3B&lBR{XMpO_(wBXgv1}8P7c8I^~Z3(!OpK6{2`$orsDn6+`H-7Bdk55 zaBuKul6NT;q+Hp%j7qKoAycU=S8XI$WAvy?@l=HHt_}CDBhX+*2?_Z_eFo$yDS?C_n6^Bq?HJc95YtMr+h@STnOytv`J?EiV5<1@mk?TJ|U zu6@O)Xy2zOb)FjPTcAo>bdNZ}Y0( z+1cOLXTJ*^L_4|v6^H+>mHg?1-?^jzrN94moc~Rw{H>AyU57t#@v}>Z>xR+SP1Fbs z5GuYa3>CQxgGG~;ya|RD90o$gs+!t`{ae_sG}&B*b^(9{Y!0km)msDcG>YHh=xXMY z$#e!K(M%s`6jNy(O-Gv(t(4<9{6Ra6b-PMgBKAZE-;)Ywav0(clRolTXcVi~tI?Iz zvCLFzw~He`UGL5pSe6$MKB>W0o1AnM(!{rr1KNTN+p<*eLRUM3P!R*j3aQXw7}Iu6 zQ*B81?{GZ2Sp8f##nfyV$0=iZjUBG><)s>7rTQgn0$8aAcIy<;PXSz!Wlu&!a&^KNYEK3 zQSd98=oP*%ZbMGFrS1^YdzZs&tA$@U!X2)obG!xt!-P##@^woLdOyX$z60Yl&|0O)X3|Kc3>< zYg(nkAx7fJmG<}`tj}Fd^qKfmp4z5SeUe@HsC0Ef5bwXQ;raw?0hUq{^RA43(SP?C zL*s)O50aDo_yh7~yOV5E!eGlE>@#AU4+a8ATRqg5{QT1zz^$Urk&08!M&- z9P)m9FWcwu%0->#FVhRyHXncVc5v>(4>3jdVw-32>{+(W=?Eh9DT6bwc7hCi(?_-fbFLik~q1uerlu9PpyY7n9PVq+KJMOL70dBS;yj>q{J@( zz+J0@Yv#3+F(V_rHpFAF8jkNgnGHsBLKb6;V@UsAGeYNMXWu}tCw$YOVfMm4%jWaq zJj)`O`EkM6pRIn_;4u2Ef^buxxJw|eaNU!D;G#^Q`Cq#5EBWnso?bWsb0;=w{wGgT z2gV9Msa#cf)9(n5@q5YGaCJ|q2nG?atqS2-eyQ)u>#93Hj3^&|=XyY<_lg{U-5(NU z{%GFLNEv@T&R&2#ozzGu`5ZPhnmnAfpiVrU7ZCd=?03Jy5x8po@I&Zyq;X2Y%Z@p!%LKOubcOTxeXIxpp{{bI9}!|!Rkhw24!@teh8?jH253SoTro! z6Ee?x5h@VZ7jgZ6|2L=!)e{9{H2M6XbvUz$EWNIzx7zRKWDsM#V^AHs{gRQ?##G%|l?OV40^_pq>1K z?c;2+6k+LyIcBwNZ;iB?>_X#qCWO|2+-xN!VY&FXk2*1rGgSp{#devcdaZJrwGDG6 z?lCMHjgOj@pxZLPP!^*LZ|!dS`C?a!W5b=p#kP{SrJo6pjL7sfMq!#Y>E*UoNKcDJ zhsVf3ENf(x$DCjoK{i1Itr)HjQ0|sBFW5yC9iFwacG=KK$0&w|n}rYDY-sG?IdKdY zT>V3N*EB>}Arq0lvP*i`Jd(-omVl|h9~RQQv{vqxd$e{I32j^JWA_?kF}Mu!XkD~3tk7k2c2z%&BZrgR>>oOz>0Z$6xQbUo%*1fG?y;=hd4 z`M}FR?#(V^qvF$35XJ#`Ul#$?>;V9&V?i8DKrf8_B0@RC6sgR!k2>sAw1m(W z>HG0MzIWBJ8mnex9VGp4h%UpwJa5s=cn%8x;)+ch-NKPr8WeMIPW-9AjW546q`v;< zOKZjs2gk$k2ZvAJn(Zt(a$k?~OK~OYm2ERtdX3t%b7xeuTCr_;4cOgsWnTGOit6c1 z`YXAl9<^D$L0z73r?2~t{bCL8SehbeNC~y-9GJyd?;-zNH!iBM^{Vytpi09i0QirMLNt_O{GhEwh#LwPpSW`v$qq3soo$5muQ;Mvc0Q3H0t& zHp0i+3@b}tL~hEzo!BCDdG(ej3L2_yu^sHGT31GP-5bhZEUmRxRu(KhnhIl%J^g*w zw}~2m$m+Omm)bAf|BX&OY;_8VE|zI)-sNll`y5C11$w>0@D z12ds5j7GizLBmgB9?!ir9en-Dl$S}iU%o@Si=5 zd;R^CmZHD+miKWq@Rv&-vB80~WAm><+(JLC&bS{$eDe!Qe<)3uD1PH?~Ze2hSI%hz`)(X$Y*WG!M$bg<o}tdE=M-C5YqP)PD7B-R+> zZH(KWg#$sD;N5QG9&Tb{{KlV#;&?+}KSR;!v$1xw2pyn=4aP(w)UW2Vh{dyCd7BVF zZW1{gzh2*bon!KfG@Gb`nk>kKIMIIdmnatcQO{&rKPA3i_mbd!`{$uak6i*tmiN*ZLxmL<){$jjQqnpZ^~mx^VVUD%RBeY_brAT zGyYq|AF{Sw?tZhk6}hYpG(6KZf|j|0x@N+MTf%Z?B9B`lAoKV5xdK5jPE%8%%MEuZ z{vmQ!dszUc44j?<1({Ry-((Cz)2Ce*{lHHsU)Ckvlq2);n?forQWmYo8d$!?eCr&p zkZdX^C#e{=Ez`X%yS%MbVXl0*t#D~B|Cpz-O$%H#SB2)Qfsj8u666T&sG?Y?{WX_W zv-mJgtErnWD?_K`u%k|tuQE@d5^154XrVJ~zGI!QV@apVOb$PcvO$K4v%$r)0H8wv zy`(68egFh41}OrF6^R^aQ}A)x(qY-s4uotI zS>V`B?{wMg*kb84Pwx;(Np-3RAE)aCCK^D%$XH^OlU-9GNf_!36sv(hqC3eayC}DT z5=8(4T1$y6RPV_#(JX24sy*WX1yyVM5kRPK?3m;%L&>U@^*Dp_W}yZega3MnziwZE zoMd4Co}X^yV^VM6v{le9L%_0Ch`4p|?OyO-t5A&nQ2hNcQtNQo{twxG^TTw4)xHY8 zy*UaMR}3)HU>9XT;ZL*>i~uY0$v|UfFh#Ez`5;gtOZ1fjK>s{cG$TB|0%4Va0gocL zG43o34r2`Uv;G#uRRPkR-+iZY zX^}SRIZX0JHW@Vs-@n@=No9Un#)>SU1T_OBuzI7X#c;IuY6clSf9==6J8`x5qHg!& zP?%yeP}gXgVzR94up!B-aN;7%g5ll*5zE4w-a;v@qVK&$VesPQ-eL^V5{KTBh7zeZ z=8)k-|LGEq#S-<+kE;93D(B3~_az0+hh-SH<@iVCq_!2XqY7r*$~Q-qhL-xE0IbnY zcti3}e0a?$5Ut4?e}5?YG?4gM44)P2)ns7QbYL#1ICE7tp&_F6U;mLAi-C%8?W8{K zSr*+gWUbXBozbvgCCD8$eH|^xYG`(yr$<&KcHJ<$t~Yj?fa7j)yB@jY9(=pLW!qj| zR-NsmF16$SN815iR>YX7p>~&%kk!w>HpnUgQOrQ3>&~bK>8$QDax5stHgGh@7P+W1 zx5CzkR4S^s)DsYvIEHz{!&LNj`E^=nw#V8yS#lS9nnzSz?#PE)NN? z%0@YakYJ;OE69&Ub5HFiepuy4N>BE)B!c?AaHUp*?3cR{CoA7ic5_a4BJFpb9ag>% zeJdK-*BwgEa9A)s-D@d7jAc70s5ls}2%BXeRbM0^4_y1h1~BhhS2M5DFBN6%q8tRG zaRM-!_RWr2v)O?Z$DLX9Vm13^ao_hQa`w`(;M=5O@tUVT?iH&I4#$SWM`0CvK^#Xp z9Q%QM!c~3QoxC zj`1Z{5^#qo&&oRtl#E~hQb?SzN1PtJtJ3|dFf%sT&Jl_P;>J&n<0RLKv4HAX0RuDWL>zh|jI&+|E z0Z4zIy&mBr?zuoM{X|xKf#&0k7WL-!h7&_dHGS|UW9cPU6c?gjc5M3sr_c_WGr$c3 zl&)dCShmh;0bp=;;k6#qeBdxu`lR1hI(aBd#KFW+$inc@<8v+d6eoA5d^hU)QspYsS|_WgtgyhNJahfHSod@v z$DiwB2sr;};GC&{gn<=^i>rV^VvL&=0A!a^M<{&2=`y`9Y6&7G>q~g80U@nVAZ?%0 z+L|JrQq@_R(&3#V5KhqhiKibmrT0};Kk7z*LDgVm$^d6VJNSk?KY={I-Z;G8Xzxb% z%uR2mUVr7S*;c*Tk(=4ojTx1@IRoO>oTI^9;+;jflJVCY;|@H;Ee7&tIn``UBz_lK z0Kir-(N+-OHaGyO`W>v^9iz8_1{;6=+gIU(uR@t0-sgXC{QBYTi<;BI*H2d9fB8AW z7w*nK)%dvXJ_&lfdF$~>>(15ajtB2f1lZ^-edqH2m8aRA2d0N-?Tn{mqnpQ_aQ>a( zH(uwjysqhuzEQlNOFi6cc{$RqSbb2j$-4xOu+Rv)pg5Nx4Cg?yCMcP4AXO8TI8gJ< z-TVuYg+;Ozda_};hKT`@HP?J-oTkOvoH^Tk2pN%;7hmYtrZ8Kgu<-jZmiaF!eBl!F zk^Y{c;mKb-nxcD}Vi!Ck2b$vc5PUIuL~%IH5&p>u9rqDP{0SUhalHJAR(wf~O`!-r z>kHoXN8SLIn{v*a6#wQQP&FwG@&KmAkZ)dr{MrG<&1o)LLHQ499S?zh{J~-*={?Qq z3tldg+QCx~!6y%y6J9?M%`V6-A=r=KpS*Htywf|ha`zT;1Or1ZuQTP=#N^H4aN4Mx_dLG+y=3CveF`euLfl}%3rB`VsNGqjrk0m4Cr5ggdI|Aif z0%b?uC0CDGY2IaLkCk^V)hhxus87{6PYs#g#qWKpxm#-leSQL4i?m1^UOhF)`(&7S z8QyzD`Ux}-NYo3tL+bmYdoIYxC1v%k|n81lv~9+j7Y&i+$RweVV5P zTQ;6Lj|6{B_;j2JHqbqHUHMc$JhkHaw#xfs8Zoz!+-P0>T>MuC^)Ewt4 zj+;5iZ!le)Il)gpli4JFQ%)2)Fe(hh*cYl}f|LN|ng5nCpbBilH zySqd15D4xrO@Ls*-Q6{~OK^t(!99fF7Th7YyVJwod*)2dt~#e?s^;pft97wzt&8>7 zU+@2Y@Ap1q?a$*gKI6;J6Wh;|M;#+@zEdbKQ#dcv#GOMUKGRRnE5K;01GYcm!q!P0 zbJ_u0zPWqSYxBxR3)*W7#%n8%xs@rt`zNGJ!MVFRo%8)73nQHiGa`%2or?{=D@QLY zSH7!HFRSo=Ywo`5IIru(ejCBU?$4)l{IB94@?LGpUrpBk$;15qNxeSp81JgT?)b0o z>c8%p`aL`P?R&rO2frRfcfEY`JIs1LEPOqx?7Es=Keq8ZYA`-&csKW_M1Enn&2ivUyoqtS(M`GSOSx%35bY@ zgbdK2d~q(bcYHh%DwO>Z1V~B>EeRV^F+>=4jRNPCzvAC97iqL6n#-p#8!HH2Zb<_G z{IHIEN3-GRG_gQLJfUPu)k1L;%pN#;#Y|qC%#YGIH?RYB4rEk_Y+K{OOu1^WmZ3B6 zkyeRPK@ggLN|jczMP7xW4PK>wjpdG-x&Hju`9{xypC{3`l`B0y>yKkcX?BahJP63$ zeCBQbbtY}T^7<^=?G9KHyK8+FyxwT>oRY;yBjT`_$(*h5d(pk!o>4>zCW}tzI&N*} zj8{t1Z-y>+-K2^ty%%(VlZpPFt$RfmkS**jIp3Az?Y{rXzQc+;_x(fZ&T`d5Uyq~5 z_1RRV#o3&Q&(q~{bTbCInD5KQnLc~>%RSDd7;yavqXULXqAUSCw3(EECrF-rk4$M+ z*9)djPLM*wdYhSB@OuT+A|=IDljCptJ1NS(%C4>=GB7igYLx$32&tmoF6vl|*LsLR2MRZ@rzy!r z%V2Wp+75@f-zXs+&6*-^7Au{gYkueLCL^1aqqRg@OUkK_(wtJK&%dJcbKJU~v{~12 zj7D4ExuB_b*>tgqZ_Q~&gn!9%zPj1)e$5r;rfB5til?`8ww(1$b^1((uDfE zrf;4`G|e0O45APia?I}Fo7#(oX&ZaWl%$zPKcFqHCtitouHQYbwrr(MML!s&iu@)r z%aL}=Fw0ZSeXuA9KK0n!!?kmz!-wo{y$wuj-4BK6nmf_rLl0etBboE9wnFHQe%RE6 z{+LG0968#WY?zwy5Np~t^Ok8@O!ofJHuf>=eFvy+S+eUT71N<}kl07Bf6plEoDZ{G z|DvB<`TgktF-+KLkUspq^UzVrv(pIwAc<8#3R#O#X+eqRAw{{?C+#Zx6t1IWm*UlV zLuz!sV%qu|@#BJsCX+#j`3A20&1D8yuIZ)>O)lIv7`i68SCD2Td6*_+^st@vW?(vQ zUl;W{>E846I;*4?dpRE=&wII_Oy|mxPv-R$nSv#!0?(L{;N+E6iv}A!61M0}? ziDm!H7&f_wmC2Hlhj`36BM&~Arv6CEG@#@C_CRK?G?Ou_u*2J)G4@kLJ#(s&j=$;C zxO3)J);`G|igtMq?m`hpM4coNC4)Tg+PJpO2W;@BKs)-aoX$@k2Gs~e#pD!=tdBOO zQW;1*p4Rv+$HoWhnj{$ zv#wg2-!*0rrCKvpYCrQ<=$>pTlu{^XO%~B(eArgf->OUbqv_UFd30LyG1>o}bd~;# z^@k_qxo*A2NJKq6e>~GfPlP?OIe4TD!0#{`bxSQ zd`(DMrF6X(hUB#BDr{NJw27DJ)$r>|$1JT)g!Sj<<{Ax}SkO51;Q&SdQiNWP9Rr;P zzlR`+ylo54V@Z;q4a-|qJ=t2mKXn|e<+mxe)+}4Lte%!^wlC7+JCAIy9A#>E95kJJ zkQ{993=m&gJg z54Qb&z499nVu2n=&3O>}$_DCNzXkQQE?DesJ?44*!X&fzd|Ea_S6=9U=f@dp%VI(( zrt_Pwgfpu6NuNO#08nH))&G|Duf>|4awP}Z>u=pQZwy>FqQhnCFpfF0`a_47U4K#o zi#Z$4$Ox1!K2_xXE}cKohy}iLN-gRRzq{bL$r@MoBFmoejNpWu5_j&{dorFvoiTH} zhWtH+U7>c*iKtWVLfGh@c(cjm2J7{Atkr$qH=pTl>vbVFsg;bg&{UQvPqDnMrAYMB z-%2{3eC1UuaI7xu&)>!4nQ=lr+Ou~;zxo0_CK2$TBH+5=?_IsVyg&X-F1(^Rcp!=LzacnqMvwpqxhuFXJ^OCbJ&FKiet(Ljiokf#Ce=E zxw2!A4<U>&RYA~JLHslc62nCF<}jqd zgfOc>9M8d491vR$#K=1Mv~x(714MojBH{3M$c7Z2BYSe76sUl|C4f>eQR`Jun-Wml zCsDiW5N9UA6A5Vcn3TDb2%D2gl@2JXb*QTjXc={Ady~jllNe{1Z^n>fwkWvy8!#x2}UjEY{%(pX1ro<62DNs9s>Zzm>eF2((p^4OIxOzTvq#61Gm_Q(q9kOs2Zc zREgm0@l-JhzI~(m@tvsn0!Mx7U8EyUgDPJ91#yxiNm@OLCnq5qRyA$}B0wAqyAF%o zkxctLJj(`|Fa`OIBl$x;`3V;J3n#_X1sSV21)3T;(j^537bTt=1c8a z$>hz&T%O2W%SCmg%G^86G{8kZ^n<0Hi`<@zb@q})xQBHFn{5Z1Ws?gY7KyoZt;SBP zLU-lF4%fi0e#s7(#4f@`jKa+c!eJ-p;6$5YC!XP)kmoo`WIniLp2cQfbYkJWVg)C1 zH&1hk;jjujv&nF?$6<%WT<1k<)@_WzlpI`|D z;|TCN)ANf9L_1SStHP1x3+7x27R(4zQo!DNt?ArC^;d$WGagmk!kt%eKO2NWV_Jhd(8eZ?hhli#?T^@4gEovny8arGWc1dctWEomX89|_Ia57a`vMjhyCLZ?_ z3Kb1U@<(Hrj|Ite(7)1^F4DEQ(hZFtnsGmvihsOwlq=^Ue@pZLotbhX^3$hfitfr>&tcu}{W<0MZEH*{++l{8ljk-RbUiV+! zj3$jYKWCPvdMTcsNRt9wqm4B(zjmple-tqF>W<;F|USwaU^m%hR$hOf@T=v#y*otJSjMrPcfpsw!)) zfeiXO_*1Pf^=kvZ`An*@1+KN~tSuUzoo1>!N~$$%UCX-ow|U?Q@>_D^ms_hpn$`}f zv<4IyL0Yt00LxG&Td=FdGA*32;b%m--Tb>MVMdh zhOqgp}YtiTaZlSVt(Ejdl z5Fm$r=b#=0rvWf@4nQEJpjClF!T<eta%4bsE;ZI7?+=x3JN&| zV4OnH|84j%Z&)0NgVetJWB{yO0hWQc=xPBzWA4D@0QB_yPZ4ey9{F$o2U5cC_n;j_ zz7RxB=uDp;RZ19LsS{k=;?_VIef7~+YYlVF2NLG{#Pfm879{f10MWQ83Oz~1J+6dU~v!L4z2Mw9?^N8ajk@z78#lLi<$1N8AE^F;dDdr z%DyPtYofL$25O<7Ze&OEc`^t19OQ#D-H~p^k^T^+s7t=xB+*kq_9-x&#AzAweW=qc z4+6a1H*yWPBB^_v>KCItGYXno3pxqEpXhvl&`BfpDxhA^arac@*wWS-f zi&yDyPYXstT8EahcrOU{W9YYq^1DSzm|z7nw1R-Y0PdZYuE$&W6Z$SiiY8GN-eVQ} zQWLdM9ZFU(m^gSnvq)yCaPM7>m|PB-T=P*|Mvy+h>@6W9>!(FlocnxT>jMb09n+~I z#z`nU#|-507?P2eopBeDly4{zfV59x=#P)lGGDe0$dgzOPuSb z>Q^nktAh!pnd)^%6Su|+w+<}0dOwvLL^mVaG=mH>9`#$}vwGpOi_?hBVGFI5@PJb! z>v#HjE*ov-^A50W&G!1cuswj&C+OQ7BbJ}a(!@auJ{Vs24H<0}!op4|UXb$u^gqkA zsJMRmg55b8RcBeW~68tFmtDQdOuEhYM?zVxSp$dK8v{C zv9Clrt}V%|-*wI*B@O*BK+Xw@e*RX^?LnGz2Y-BzvD<^fMeM6=@VocPQusakKk+8b zK5^#xF6xzDSo@o{n?w=`z#(b2L>b2LX-Rpmss1+{=rdXR{?9j(>T-kXSf9Su6(InB zzxk(8*SSh}dT^p1t++TyrL#gJW7Ziu>r7#!4xN+Fky8;zzs(1Kq^NS`oAmaXdC^PfQO;pE^y}jsa#p$&MBZ4sm z^o*e+4ks-VYp~I;Y@evO8X1^F%dlEC*ty30vexXo!iw6zP`NIBye=`iZi>30tFWON zv*9_q;a@d?_%8fXSu$(h#@M~cftGRUEI2^c)^U1ud7 zA@7)O$lhuFIXc-h%Yrs%xi<54ZNf-#S}C?e)Ot^bbxsX!Mx}a+p=*&=^gw%UM_)8m z`ErG{q6p4KQI9df^DqBep0EyAtfC5b?iy;k{PO(^DnC{$zZu+zf8J<$zyIQCVG#KG?jqd3ad%aFum zd1Y_tRjYKf+{yraRSWfIBT>Z?p}$d>0ZYL9E6LwjOzfjeozeWYYn?t%Ytq&Q6q9dm zQ=^3qXZXz?RXn4XN$!KseQ}iVWba#@%mR}b=^IBIxlPBiqzU*8gs!wg!iCF7HdMp| zfr!@2d>rio0ZVnJclZ=pwsCP6Wq5{paxXZ; z*r%WvU*GNlYu>8^rKkIl(r6E1c487A}T) zTox~q>*s=c6#r#9;b-A5H=n`qlWt~qqnjl(?!%;M`fknAf@|(7d_=h}Q-(-u$%=Lv zW@$fF4~kMumAAE^}tVV2!JLbw3#!9*Eltv0j-fZOtvuQGf zyG?OOhuFdONQb&G%2^es-b$+k@MOwRf64i20oBfS6FMx(jCyCS^;>$#y0W2qh|XcG zRgSr;r&`XYx@lF&rlx9%i8-n3wauok|0nX-l5#aoriu~C*{@ntFfQ+k##yzeW7V|W z*?qnEkB>p2%W?9j#e`=0EWTsNZgy?orNdO(OR9<4+pcnvGdu43gjEo4Pe=ZWKXwr_ zweOEx=*2@$+zjo}#f~{_JNQr?2kJhtFc08M#c=iy**-fA)(08X|9O|><5&e>iC>XG zTJ?M?`S6-W)Cru)K3Cyz|9v(h@TBd~d3s4wHz74M@7x+w;X2UF9wKbjs-}FBubnsN z-ZZOgfnqxcY3*p5*K_wO0%Byxx-D53qDcUW@u0U$PNl22%Z?Kw?yF3_vHWXZX{+vQ zc4xls8!i~4x1|Q`P4}v?7&k2{-=26pC-Rt9t3zz1nY90Ez`|4dkiW+(c^#DG#d#f8 z)aLdX!;7GKAO9HXnmqnFVf1v;)}8Ql`t$Bo_yidQdpiGxk~cZSNdn`MY{`Iryq;E8 z?z|S~aag&UwO4+*StJ06+)X8^cHY?pv3K3?+T^|79u=wP*C2AnDdv`ImBNp|qZNllOm9t}Wh0SGj>CP7$L`3Uq8y;KI1K_tidU@?d!y0rs@ zqAofinIIUq!XcE!M?ymB9*93&7s~Eqh-wibMQ}LumThW+CLGX5Hti5D-cf+5UDp5Z z;ygn3*#tAAr6UM803Z+`^=`T@jMu<1+F$=j?wh7Q}PsAjC$j>|L6@cf*lNu4~_NPO2>4&l8P%{k+P(8l``KlA+{tc$IyQ zS_VjtRJ0SFVIDX8E=f8(8S*hX6Q}8mbhBWBx-|?PpsPX)PYS`;4!Txjh6EWN(og*> z#x2Ixw364gR!#ejTSAy(rAX=&?2ewCZDlD%Na#Qc_s^yD{SBjvCY44Gb`zS&i1e%nXQS~lD&Q#|GmLta`9WEYvNv-^cYOM+TzibW=l za99eNX}FE!Y>bc~l;6|y-I=s?xP&Okw|aqim<4s_s+E|FLNoK#8b8>JznTRK=#FY> zHE@QaX%q_0&in9HDB)FWMe6BIM$sIrzxGV_X=K(lV%~r1fy3L7K>w5;OyYzIppWsGilmi980Fggy6f3@b8_?LY-PicS-0;)SS;G@ zQ5av5Gc~*bpJh_#@w|X=#pD-2LuuzE7DwC;wDFi*n!)4RPia$YR>c`eG|RL{8$w-mx9~*S~Z^XSSVAzjCdJ zv*XMw=@ZGmfd9`iSTLJ&;nnj_&quDdc{JxTe$ruOd-uQ9qOSZFJZr1p zn;lO?)Y>ZY(G>s^F-ZYI5Sl=AVOd_%e?0)qDgglFBtL{I0sj4H?+IpjeGC!i0SQMw zqCGgUVg~?3WC=uPg7y?+RqG^%haPlwIqZaHxe7I}9AuTYeM?k2DI^fNeoxRg{f+I* zckIr+QgYv)((Hg?*yE*JNoTIbx>gN!UB6#f^WP70fdlL&U=d3@&lCy=+>RXJa9Tft z+PT~Do1x}ORHD=hHImDu(}P>EG)j znU_fuW!QWg+4WQ4#U+%o$<((fQp?_1F_coP1@vQ3R<(nlD-k;aEK@02= z02b;21n)YGqyZ~aKc^w$Q*eA{Ja>RQm-o1HSJ?2y0{}fS{pO_Mun<^kwktk7DJ@w2+E$e;LAnk{f?Xoe)Sws8o8WwyZ&0 zxLgM~uuGe*Cd7TtRmZo)Dir4!e$cpO`Eeq z4FDbLWCxq1P1~eCLB{ff>b`xhfvKY-R&)5l&DpkF&}|wC|nK`fgvEVt?`=_ z)JkdNGd2Rg1f~<7IFL-&M)G4qc}voS#t>p=DP!jLhm7LI%(<}4!t%@? zo=TGk{R5XQ(9!br|y9+`6sGjBE-tb3{&x})kVbhPfDASSvKOiohE>_MfC&5-2BDdx{KUBqP*>*+*HBb z9Zy)^etF)Nr_zm8E`Ukt=^+DNE~}j=e)dzcu2qWuLq4508&^I))C%M%0dI}v7NZ3> z5Rx7mnoiQ^!}d{O;JSd(D|Kc7AT$|m)|;=rm=*1r6RTUu84kZ$q+y_;{8=RzKA{kS zR_XnclIS6aL|dW$-$JpdqPp@T>ER-w!y@g*A{nM)smG#Sv!ZL$oDXF=JywNA?@EY2 zvVGRgj!!K3JXAmdl91Rau}3a-2bDU@mAdMcIz5(r$S-vlDs@5z@oC|62Pty)5C%ml zh9VOMN0pK0mjO-6rmo3(6U)L6%aV}GQ-;fut!X3&5OXr6UtN@p{+53|M>Gd$WD3G6 z@(z{0FO?U2RS2Y1*Z?YAcq(ch-(??`|7few)u=4-s^rJ4Y#6R6I;w}+r~+lv0_+DtU-Qx(>zci&nuEg z0^ILgc*?yj7jjJ3ZH%|bwfdB`hK02^OK;Alay~~KYzZ7$+B$gsI!?|yge)Ay5p2kE z9ddgek~}ubNF9}R1vgw`<9z{)?S8s( zH;_jm>z#Z%xvo5qPG#fpGUEvG92kDC0)ZM$!Z{}IWw6#*H0^E7Mmkt%V;`l zeOgEFW@lkCL=`eAYHm%G7Sz6`7`P@)VfJGkC7rfj5w!^JHrf}7@a-Z|$p>$s`cVE5bnA&vTMRz|`c0Y~4x{0xc(f6xg z-gJ;c59n(TIHm`wst3iOM0tj%+@%1Or58t`7w>B?K};`EOi$fak1Z!e2DA4aOCPmD zAMMvZ`j|fC(FEOdhR8|Q=JY;JmVR!9e%`PBjH3w#=L`TSXw|7-4E2`;%P%Q~w^8L( z^>eUrHb~Uqm*Vj+Wz+#xgI_XL{qb91&4g^Vssa7c0mI_~5Ne<>Dj;;S-{x_^BIdVM z)o+_oO2zzQ=-D3uoo`LF65DUw11C`&NEPsL({)CeB$9x89vi#O^ z0I7)&hM^99V;M?P==S~!a(LF#g@V2)4CNdT<)IFzQKkAG4}M040YV%=@+++cqr=t5 z!?i5f&R59H6MGN&8u_e?I8tIR#H~nwE7+nHr>(4?6WhAX%NtAb}X<5AmF*z`joN$If(( z0@*p>c~n5U8{ohMkW4;^U2)Vu0OY?hp1Hz6@J^V%1g5RZI;*ZYt7$u{9XqRAJ*z)9 zYj`qij5cS&I%ldlXKp)Z5j$s9J!gY9$FebJk2cTJGv};0?`k`5b23-gP~f95cKRM9 z`}Oa7)sQ~`B0u(59ndF30pf8$py()wM_c^Hx|pQ6m}0w_7Q2{Hy_hw&m~*n2hqhF} zx>TsRRBXFc`W84*y;M22RDH5k%esVeJ^vO}3r2(ZPBOgpu>!}&BOE})FW?{w2-+A( ze{yUvc4eq~Wn^q+>||vEZFP$EKjKVhZCB@GR~M^Sm&aCDPgd8_);3w!wiVZQY}fW! z*YxW^2Io_~B4csyK|wvs>^UIfr9nRcq^}yb{xr7!aO1HjrvI zP{udVPB$>nH?i0@ag;Xk>^2GFHi>FB317i}fIo2^gP-272eLwZ9Y&Fk8w3^czsSKe z+4anQonogLfl_WekaXy5SM5(e``++Kc>CP67(EZmW0B@Y!w4to@T@ z+x}!H_Jew);Z4Gj2@?+|7(Z+iNW$ypL#WwyZB-#M6c8SVT{8oSfjC501!8x)YXF59 z)a|+|?YYN63<4nf4iFbVQ0V!dh6+TT0}>(%3Qqt<n9DJKI70^C3Y2ki=K8 zZydzV4rI;-2@{3z0QO_L4zkc;dp76?E?uC|ghMZ*!$7}X3#0wen%&4;P}%5yaokb! z_`d(^o)+etZGE?+=BQQaEqvgxD{eQ0Z9k~%z(04t(r9l|X>VZd$olj^T?H~CdK5}= zkeqwyXt!sRd+@vKAmsFD!4Dy#?!d(kRJO7k^Lp|-_bBl7pf>k7r)Kx9bD}{3c|1L{ zUpsqIg1nNQKa;J4VTbGh2>Ur0Z}J>XnbMyE-eC&N4&Cw>hrg}5kd668bap|AK@fNj zG*E$~nE+uyFB#%5X^r9ZRN(Yg;B+ys*e6x>&Vl+4SAy|Zd=qbr@q*Fef}H)D(0=0WQcz50FF4+GH3ikHl|35B7n0SDL zEX%w2KSfSMUxo4}%UtBD^=cQY+(u5kx;N@P6xgyR_8Yy%?Aq7QTYQvim(T7y{3gzx zU;%+a!6Bhx;SrHh(J`@c@d@7&laf6yQ?bMp&}OUo;(YwH`ETigG3 zcK7xV4v&scPS4ISF0Za{Ztw0N9-p3HUSR-uR4mis?Ej)- zIUlYJHIz=k{u7HO*H|`HD4WD&INVtNR!=UJ%aLoUn61=luwET*s+_Nd_D7M*|EyYU zu$-wd9Qj$j-0ZMDoFm^{v)b-)b+|gxT)W;K0FOeZ&{DVAAA!ScG}`i?`3Um4Zx!pE zk#ugGwb9mwy@`COXfnnBF!GkER~n7AH66{@nf@0RYq`bwXl<;$`E0!>7=>J^qvc}z zPtseOK}YM=-ejSCo>FJq8y2guDIyeD29k?~(V@S3pan+STjS%Nga15LarTdP@;G96=aq6QVw zPKx9gB-%77FDu$~@u*hX3dEs$ zT-wbK8Mi9SiDa_gD~KI#EzA3cjJcmFs}lu)|4%Gd4xd8+AQ-!jv8>FCiK#rZ1qy$3FI2)XSk;{J=8=x`d7Yz+x!|K?rCtIVU9PU%00}7REGAf8zFanNUGt zZJN>0M!TLBwy18JFu*v!o`({M@Gi<{k&2IhNDvBySSA60NJKOnUjX)lZzW{+z1Z6| zH;gF$75^F1mgSHnG>`R2|IU^TKW00DZ7=06zGcY{BEcme>Ndf}9Gf+P{cx1?hxvjm zQK7@)yc*ZT8f~aO`px{tmBBxXQkhHP3YtYIY!4xa}pEWrHa0T z2Vmlk?PYcL$ggu_aj>)VYLfXyB>wC;VJ!Cj zzOdRKczZ;?_(~xDFohBD%)RltQ7VqW#o-U8NqKq;&&*2^M{q@ff_&Y2Q7`R-Y4-Es z&%lyc)*SwXB$SVhU-~eSJ|%sEJR~W!`&X#X2w1w>a)JUYjMAw3oI2X*{nJCy#2<;@hu9 z<-C`xOgK$?iB->W52oZC5N)qSbjGA7+uz*t(LHu6*}z;{HmKZ;I5%i=s(=;;N=a(< zNi1r*D3V7B#w^0vt%j@~Kg{!8%$qU$v)))LvSO+I)&ZZzp<2pPW9f&NgO6F^%~%4n z#zxNR>N3zE^aZqZ_0YpPM84Syqgh*BJPD1~LycOhigIPVBdwQN&B|O?pb06n{>Y(L zRf%Q|mF1E4ln}6*Ew)Odnpx+pZLVYbrUD1G2S{-q@LTA%J|PrX*J~Ud^HE%=}vypYRny|vLcVxo33zcinV1emqS@zP;zT*@MZm~e`HZEyJYh&i*zl|30R*ig4Mv23Hy!D~+@+$Fey#pcw7x zHMfgp!fNsoMpiey+%r3?lZpdq)+oN+HD5NJxgIE`G!ba8sVE3LYky`JE zXefYPr)QV8E+}ne147@@i5pgjV1Gx;gEb_pcX=L8&P&IW@#&Wp&@o)Z=QCDw`T!Ff zXU5-OCLcAUlxRx+^1yf)*R|fDL6;Y~PAvaE!g(r5lR4!jDwI*5wG6psZq!A9m zhWj${>VGJhD>=4~82|o}QrfY@X+xw_@08b?I}m6$Aa8Kxb=9#y%O=n*Kkodh)iy`6 zCo*C)?t$piX}9+y&NIfGds}A!$TyxYQf1EQty@U!*6^Y7crxW9(HN>N=LZ|TDUK_b z0vN&SfkJ%d6mX>RsjZ~FE|%3=!ntWa3{gb4S66`JsQS-_VzfR}DSf9Lcxs4y>HAIBERS_QvRvGu6G!`H_k6RQ)--n- z+lJ+D8%E8|JEZm=(aUQ^g?F9&y6tY)gMW zcRJz_His>IZOQ?h^oyt`_8=12{QxN9LjvN91e_MNU9#1iCfs$OFykWAEvf1BeBiK#h zw*J0Ov(S74+eIac)A8psp~>#t>+;f^$MI1G_xI z52Geuc*1*d=^()P`)+F2i*PZzO*rz0uS%~MF=-uJ-1ZM++OJt-+w@Wx>?%{HxcSB1 zWnx5mUJ-F*HyG7>ho8uwB9w4*n*2p1_1V3HfB2PS6EMj}>!~M+=9UPH9I7}Ta_1*% zJoIZ@U+8B3%@;Jj7j5cNjqUdN2gZ9`1ZOHmlg{@Y-c;|vjtt=2wOg>YUc$`99@jDW zdNOBgd^MS$C*u9P=loyp_;nt_wV&w&US(_mI@*!a`c1U@X`1?3uKMMmz~-N`x;4^) z7#jhoE&A9Vfw*OXZB2R<5rG{8CYw#h2>C`6ye8AG#z!DShO!`fLMWG|5#e0W%S{lA zfRSKJ5dWXxCG+5$6eBi5W9-}D$5|-o77G4if}U!kxNl6r7xFI5Kt?uH)iP8)B1pH4 zQ~OUS+kU9NB~*G}^ovKBWqO!(OW4Dh%k?ci1di4mIzBMg#V91J@`#5|3AsX|0h=XjVb(w34UV)|2H*_0K@$A zsj^exXsjIuWr#Dg%C)Sh`Fhmlz%t=tyY5kQ=5q$?$^YM2I>Y{xDEq(E&i`9WXW0Lx zom=MM;CMWG{);G!DkQrZio-_;2qTd!GYKd4gHVN0#mSmP(tT+$iNa<|?*$-elx@b~ ze})vsyoCjA#tKe*P=&m|E!z%eCc`XBkp8Ii@0;Z7Jw=j;kd;}C>|7a52-|0InrH&L zq2h4kFN7r_Mq#?UX`mR-;!Is5fC=zFiLyux(7h0s-B0wnUbh*5JilEe%Y0{aIm_%Y zvd7YpDEvog7JiW@AlvOfh_We?42;F;Zq^n+W;?yo(wv~j{Ia6dcZb2*CD!HT;QYhG z%1R}n!>YWwC8nA>Nxj~v<}I(i)FfmZ#`J-A!Ysj6OzkYNx^boei^e~Q%wL=SiXI*z z*nc4|XlhY9s%jZdw5e*H=Q^})-nMRM1stbVzMT$hmRUM4a)oOWzI63^32wdGea$4v z@NUfyYp|N+q#t$ZQc7!j>)=|scm$Bkj_5R z+MSQG_PAMVOy<2+o)q_ZoKnlieVVb(=DFY9PWJw|f5hl{*LOay`Cu3}*0G;M4(qt? z6h7K$WrGB@1;p%-F){^52+6@gc_ z1dVqn*l=qjK@`%5^L;W9|2h$&wwV?F{U5*@Hx`nu2Y}>I9D>f`8N` zDvsd;Ek2f{BF*QwZC09%6e~(8`*W3LdLt$5WkT)-e*5*;{Qx&wLW~7ZA>6FM_ehB$ z2_pmSlnR<+e!T<*@l5JOh7Xd$ZkX{HQ~_j$EhUWQ=Ta7lrd9g_l-Sm>v4|QtKWLDK zur#qh;AqUyO3@4r@FJ_mJkn%iyE3R@4<`po7UyX!(u*=~BP)wbn{Q{+r5lT%obbq%jaRTVs7w`Qt13-E^ted3}>lpVzwHB3Ro1 z)DvOLyRJW9DthmTrFN%J(EyC-?!})>d|>_xg{A5AvbhDsnjaf4BS;Y$MugI?6oQLo zivXxNEgBde!gckLT!wH|}=YnPdK l9s7#4Uh^Ysw{3Tw=draud-Cg#OLtxOW3_(H*l+;h{{u_1+WY_j literal 0 HcmV?d00001 diff --git a/boards/shields/rpi_pico_clock/doc/waveshare_pico_clock_green/hardware.jpg b/boards/shields/rpi_pico_clock/doc/waveshare_pico_clock_green/hardware.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a99725b7344aa888647f502cf4082eeecbc822c8 GIT binary patch literal 117957 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⪼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 z z%#fcvrheC=^crd@_9+u8U}?osb{(!)(dDyP;{Bko02gepYe;c&h8GYu)eZ)!1gYuw zLIK8-_G9$Ke?WkdS9Olkr7GkAY!xR))Xa5rZPz!F^bDJ1i84F?(^PI!8T*W!kU#AO z?M)m^t_o1t9f6W~^$u)gyNL4EzJa!}E9hRN_vg`i@Gg@g_LS&EZglQmn26R+gx~#k zd1}9x{&bO>QcA^KNU8EJBF7jd0!3}NH%pM-`&mkcvR%?H8iFf2+G??5>T1&WhPFU8 z7VKatzeiNkAq{lE;iku`oYP2mvDXp&V$L#$9aK^41w0;!54{a#m|C2`NwCzTx2V^! z9~n|#gkV|6&7m+T!L>V2Z46nA;vcCR2G1@u*7485biN?=^$5hV!Pl~&TLdN5VVMF` z*`&K2)M>!oZmi)-C^Pp}#s+<064{2dSxoHPd>J`KBbAtDa=YQ5It&k`i1c91q=4Jnya<)qF=D3ocP=e1{fFC>A0w5T!4 zq5iBhQLDma!?BKPsaW5OeV*lK*4*O?9M!;?Xzr7Y+@@ipMcs(Zc`c-Lbz`22YX#rrpImXdR`@K)K6pUxZo1vB_ZYPkz*wqp<^P9A2DAp%mx&kI3sR>+&-X z#J8xI+e2y(4xMPwx#rA;m%&hm$;GcB{wn$rB|vgaAP-P6Lv!2ki2bq2om5U&<~C?9 zk9CqHly9f)3(-AiFQQ8a*Xp16n4t<+7B!jbkjw*^W`Sp5eVd}2QU!=`fWuXvSzY4I z#ZJHdNvOGvE?Q&_nyGltg1i3njCD6IF6@v%wx+nzdX#GFxCt=d$pPp6&}UExN;+Pznu zpkP%8OqZ1-0uB(&D^ns@gL#~rsFEoyq5=XVv&i0F>0sCDP5-R@%RO7ZJ}g50WitC0 z=WQ&MeLR>&&}InDYLT9Eb6z4Zv@E;kqw!(mOp;PR>Sh*P4SxcGI1XJ2^2@d7Fu%Dj zFcw28m%I686m@C<+lKHTqh6f!NcHxOMgyBhv?|pq9=lbo3A2kA~M@1g&zV z>}B)wZwjONZ)b%2KhDZnu`J(L(RmQ1J$W`XSbffhJS3iNVs94lZUL~g&9~zFYRV^3 zKQOUr8OmxFVaq=#DNq8e!(DedOPvWPoz%fnLZH`x zN#UOh5AP)PpR7xGO4Sl>jLxm+WM-}0bV{=4N=}(UHb0Y?(0<88@tzIsr%^}Y^+-!g zSJh5piY>fFWUFNb+G18BEyC{4Nw~oJl@kooX6V4_901ybsuX$olx^s1n?NNj_Sr1p z3qjBeUS*&R`jGcif;$yD4JiXzZrd$Dk>$46{zI?@LX%8)HuRCY3+p# z&nRJR3@V%7-mI2=5lzuV$1P{B`hbS=m$KrQ{veX9N|a5e-h&kjmzzuqrMWO?uwheo zQ6h6QpEQ0E;dHP|c9AD2wAp+mgSROf?U~AXnSFpF zs)9kICS65_TQ%yyA}5+$W-yJC$f{pLBpBA@QWNk}xRa1&S- zrFjHe);DgsaNT};+YGkbB$Lr@q7+mi>UN6JkY0lteu}+dY5_~zSKXE@D&jY1OJdZA zZ$YyArPvPgDM)WZVXmf{;g&J9*`SWoYT{Ri)Mj0Ot{It7p8^Y|SM6;sU*;i8(aEc7 z(+Vf%@TCOr!nh{n%;lyHhoF&HJkQ#d;sIpTDjk(O1x8>Bl}7VC6niBuZHpUwJ_-aE zAzjCmb>g2y_k0Q|0Hk#B{658(pS`OnjyI|KZctnvFAY5k?PFAW=4iF7k;^z@=P^ZY zL&`k+IC4@Y9BQMWB5#5@6t3))F*9NSIYT!4+;1uW;(t4r_&2LqoUGsdyK0cQov}AS zg&vnZ!*@>{lH-{Q?lEb2A!uc-DhcauL!L0vTLtNxxfw^tQfK)N^o?mWQ zaxwdjdLnT6<|+r#s*J%nMOQ1F@M1-~m$4_0L-#(W-uw;Sgezb*!D(E<>v(;au{)1L zcdc|>9qO|jaDR^3zRqtX?j;^6=twVcZVbT_;7RXr_Wsc5C8U(a?YxB%y7eP6tU`hw zQLZ9wlSvgrrY-E5p(E6Ui}Nc)iON<*h)}tz%VR5x_-@?pX({8%&+25|e*(xJym@q9 z|45uHMGKyIwa;m|CSuMen5^OQH{4Tx{QJh-Kan4v$&N4NA`)>B2-)z1ZGS~`x~Keq z4IWJ4{G%-?CJhUV3-VW{WFP3K+*U_}q9VQ9%G#@mkh)XGga^85Z=Qe!edtku&E!FW z6@7s1;lKXAn#+F!HkC&aHg+No1U8euZRne2-W4)ZD)^roJ)nZX9Q^0D_IT~2lU(pw z)2Gn97y6t&U(TFKA5SwWW`AyA1&(U&258>*Rm;hI4!6H8S>Gms^{;3b0a&GJk!Vl| zM^3LV*NCs9__yU)_S_HW!)*l5Q~JE4+p))lGakv^x!uTmF4sF*U59@sSylH5&d6oM zjp9xpQV%@Qly|RlK98q?O)w6837abOm2b`k0xpR%KZX-LLHOc9%lX(@^LnP7{q3OH z4qSsj_XU9+Vx(rn_5xH#?@D@HiAsd(mXaM}Yb=|h|F&EDXaGxdt;#c|kS?0oV1(uK zuK4AQ%RFa833LKCj!OT4oXVME53$7jfBnFLZ^6Y%O(8!i_7gkmF&>v_Ni8o`|3$#5 zp!hnsU)I@XC^FQA!1xLb13uFRBUIHAPllGg9&a;D1ad)xk_Z;b^E-+w4lb{GEqQQE=7^>M4dNA3n?#-^!{x<_uK;w?fP zLzW(LH_ca1ru2uR;wI1QQPkXcnQnLNRYpjwjN}kCn}SouE@hPlsoSbQ?p(kF9k--x zR6glH;0#&7p1MI}0t6Q$F=oplO{1#WHolBqC~+;NmddFr#!?aH&odw`5DuhCJRF8J zIn1UMd_r1W{epgnYCNZDH15_!ORp$vu9_-e8OrFN63t1J&buNJuUBX2uI~u|^{_hm zgQwH~ydwMyd`Z7TSFdbzfiFmFk5R(LhVzzElOD+K=ZZ6@?F^h&NT?|ZN;Yoj;aIC-)%iA zUwTy587SG@`3~8+@PD}N*Km`u6*>>EA<4ug4H95>K;lAYr0Bdb8ch9-Bs+@J5 zqb_3obFLAKV{ozm0}|)8c$_qBSy{DOWVB-CYn=fXD}~mi4QoSvd#Cy zD?VF_N`L>I?YhH-h0PBXe-Avdt3w)-_^rXP``j-Ic1~xS$c}PBrK_tb!P>QQxL& zQn1+^18W{pIJHaG463&A(KE2#6aN4^>v44(D1?~#c>2E$t5RFr$y-BrU3WuwHyl5e z*U|@trk&P{){Ar2x5o8k@Ycg-rnA_7FK9HjfB7rkD^X7H#XB0)01; z0F)7P&Qcz3?(^BS^^VEm;O-CHU)|uUJw$y(rRj{mgf~Af83jYfe42*xM|Y7YhYfs? z1lx$r2QbH@51cJfJQ#i54;HS6Z#}WP_fDqWcD9yZ(izQf*|WYk^LqLPBf2HOzY%V5 zP(*VPD>-8w@6BXbPyEmscp_XG;LNc;yapxnJ5N)CYnprOl8J*s0`|!o^cpL?TcV+$ z5;|6t>V2t=#eI1#%;@qU<=YPApG_3&?g5EbTuNrim-J=7W`fsK+WW@Gs?s>^p!986Z<`5El#ShyF4Li z=_ALt8{`cjoHEx9`zc7xGD^s-;zC=7Dnq2^Z@dIMR7+gK-BN0sv1C~lf`fT%VNlg zXZ9mVYnmWgTiG>zkX(B>d{dC?bBSgP`TGdqrG6m~PoEp&~RDqQbkI<>bXq zK&(!%X4_Any8Y-wk1PQYE2n4v?{A8IJNLZP4)0En6~2tM0tfF@_4|K)zQ5Il2ms6Y z--xb!GJ!qi=;K@mP!XlB3StpCu{&A0-@HR@pLJEn@6+Das-~nhY^h4Q$OPr=?Cbze z$Be4Dm>D!sigA4Rpy{5*RHMQr|Eq)TZlw+(Xw`Zz|M2bL->zpR_V4e6Iez6kH#`K# zE&ku%)C9ORiQN6sR-9h=bNrV3iL8g8o=GkOumXLi7-OD#lHeQ^bj+#Z&{VmBp0NU&VWW6f$uy~V6~>D5ijmB@mFv($!Ph3&@XUib7`nT5MR8IMzn2fZQwEBH`5Vnz>bMns zJA{jwYCf0C<}Ur4Pjmx(rQ{E)9Jz*?mYgdzV=_ADp=R=RqV0dG?th}z)UV^T`QIrE z=p3C22<{3H?K1s}Ds?87>MqxDD;AU`O#gxk?$QqlEj|8(|Kd=GWYp5aGhah(-5KPZ ztr-Ahqk8zM(f~+N5Tm9CB4}&^)hIS-Vz_qwE%)DF(6%?1E-+K)o@>4IGwo+9@DO61 zO?R@on`$U85HVl7MU;1loNFIy+j&06Y1g$nLho3G_P8V*HbnwO3R&C(@w#f`i z>rQ0@pOogSMeftgI*5WeV3FMAyo`ERE=6;HbcU@%jtaBTT{|$fzEqmVb_xBx@r)aBga7I12XN(AZHr^M>naQXY4do4?Dp>DTlJh;Kky=Lq9hPPDxf-tcY!c@dCtKCu6!=(4l@-wV>s zA3J>NefwCxY)M}QPCvjAud1)ArCQv0|&iL|itbJ+#InloZ4xMUnspsw~QLY3?SEa#I? zMy0G6#QQ{!F=m&?)0?YMkL zu>W3`UGF*mnr4r6(?mI^Uq<8he0|sX@ENdE_FN?*Ft#CLxWE%l(qkJ{Bqx3?(p?~# zXyBya2eYCxGtI6`YhJCJ(qK+rF~;|0Ja|3#iFiA$JfZ3wL7s?)vBs`d?*3(#^uq|Ab8?s zZtXp0Kq6y#@fMfd$dyRh7^}*a+{i4We|dYCo4At(nP{lM3M)=yBGDL}f&1IC7)2|j zt4sG_A)!y8w7*vyi(M!LGU-A>0tE;M=Qu`(gVPUds)FT)LgQ*;A<>o~1`aF=!E$!I zQ(+;2M5F*o{(DLy7JgQhqPbpOwe zR(`SK#{jdbDgPm-Ja{>jjLUw#iZ!a*e*J?zQaTS)xc00s&$#mUIoodZc!HF|46mj* zUeuye_+wjaps&{usj2MQElU!r#^o4+CXW{sNvTeO*C=ta<iU zj(azhQA_%;9Zc0v)<{?XWBHqN9>;KPtwmWwa+q?0Nc>n6-~9iu3x#!>s=b-BR1EVB zGtx}^ejyW;!DmZ`ZvTZ3{0)OI=1HHvI?K;i>2o(cFh`PQIehr)CiWRf zex1K(w5VP8l4*l^TKX8tmHeBujQJtV&7xhpeBu{$)X$Yqr|o!McU>?0!?v{Tt$&Z3 zX`5L$;D}Dr81;OH=(%vVgiWVJqxbO#0oE18TLu}_+Y={tp#JB(xw$GK zbdEua9xz$;1+vrpFMNwE0E*0nlN3VRw@i(le5p^xk^thCT==#jYJCh?Ai}HUUzdsz zm|F5WKG!A`&L#sIP+2TdJr#ZVag@#zw11@@yP%+kM`>_zbo@(!(9|HID8;@yNS@Lj zq&1A*0<}lx_LJjZ_LM;wo)H{JyfxVKBABhYq?=aOM=z#?J&g11cfbcu3en~-@sW`A z5TMHCmrPn!Q(Uhi^oOoi^ON*!-VscY`Yi;;T9`pi+nwYfI_g8#bQ-1#S56S@fea1E z;SU%j8$re5m8aW*SaHtTsM%;LXdo_+Yo+M-K48_BbiA+z12{PKQtQ|`@(rk<3+3;R2X^d5 zuU=+F`8#%6J>W!OM6Z7zU{OK0I_EPzu?sXp<&OBK#~$*?AVAwhxc|KOqW?~fi|>!D zATWR9Nq}^>-h=N4Ai}GP?-GQ)`2L;KNL-r=5reP6A9NqY#n&zld~ z6vD=o3|D0B!caBSi_HYj?Y{PWGcWil*C#oj-l4gT5FPOe7`i?YB0jgD zc;wyo)}iwQvuVk8gA*k)iEQ$1@=fxsfNzuk{AUsY5K~YD<$>p!mR|A}lXnZ%pcj`O zstqf()UtTKWLAa*01A(Cp_b#--3;l888dS&OV0U8V`YL|F@c+76Uqi%ew27zzz;2$ z%80H;p%VSZBvze+=`Z5n6Qis(Bg)N?4yJP?!#9itFe2hn&#Z{lDp4o7e8OpoJ_7uVcVEi3;?pB;Uvwn4B zKgZ^S1@L!p@ZQc}?ik!f7xO>uiq*xG z`k@_)$qQfCa`nrv9ORoCQD65v&9)%mmf@MI`SzKAw{T!10BtkzmP)iIM39TX>*9O2 zyulWNuf%kaVBSVn?(^y64U^a4Y#uOP%jrcwd98=f-=$=BuyDQq^g3WaS_RiU1tQJy zCQa8o@L&W?iz~4=#|`YndeA(`p?Ou?b+iwrC399GinZ^L8ALi|`Gnk63roIn9C8{5zFjRxhI{yLX@kLI+v2fS}yuYfeu%sxLY~R9nM{bMktbbf76p< zMxQEOF|VYiBM%L5j~1e{=c-!t)4IEFV&SA*9IAO^0{4rM)BbJXgoy{XerJ^lYI?jERl=yS=usAbC-FC zz0ep~Th9+ccnZ`4`}<*RmaMMLmrScIJ}#cq&lb0I3}8>Q2U|8@37>#_`YsvX{S6kH zy3b0;b9yIqV2bSV2P@PlysB(1{h21Watko>b)g+%jpFJb5Cp@4ZV=_*57gar&f&If z=abo!bI0^oFb%1Qd$#lPCB^D|ZGlEVv)9pw7t|Q*Kke!#awM zi1%Jl3DBCKVc=naR}M&Jo;+4`w<}nspDcHK2VC_BPRj zr=wkf@GC-}zZ2RaSLHvsU2Cgo+^tUO#tHwX9mkj|cp+~0dL|UOAh+R_MUUkUPyal2 zvR~rI#7fGMNnpot>DJaqj_1C~-*~ROj`ib<46}_8<#;AbV}APqR+oJsnfRAS;>YVd z{y!k}1CC@(KZU%z*W%1?C$cBt2AG(t7=-YmEW%LI&1k zwwh_~Oj`rGnC{LRS`Wb-VoB{>*x&RJWAeCD&e#iP2V^u&WxBUZ>IIl!@&2IO5&ak<+lWpfN0suHPK-Tslv=c6} zD0l@Uc?wkX@3_p0tRfxOD#hS5l!RzuV)_RpECczCl}QSc#|it?J{L`-PL*h8$qE5xgza2ywxk8eQ6eb!6ZvsEu59D2C2y1LcbrglYH z9aRd#_m)%7t}&a0nYBXjQdo-?;)ib=q38N`z>b!6i~+CT)DXuG_3E&|p|ilv3m84= zG%1@HSgefuoy*RD%L&?oZK77Z%hFYNb(~93jMN~8UmzMInGF4w`E}D;j^xC}jb2$f z)ey^bIokKroK3AGSMZ&Ot?C0$kvo_ryhoDo+S(4TMRoS$JC%@TiQaZ%HlSEv|CwSd z_I@5&a;PyrX0S@(c1yH2!8^p6xLnQ_gD@j*T;u+@xa5H+cS$d0zNDrI z0`<<)GCLQLe>k=?5LMiIpv_7u6zPF9n`$zXlimpqkS9>&6HYcHqlVvf4Kdpp9Zn2J zBw!P2saKpb0R|7RPA7#N(FxH+8R;UnkyzP;6$?jYF>mRE>B?lma2T0u_BXnPS&=TC z?RZD^w;CG4K)&*@p!gn%(~Zp96argN^6+`hE3qzXC7hh~?gqx2;bK;Acx`j|^v$6j zvi$z8{_Am>{3`T}NWFx~rMVp)Fw$$caxc%WIYWK7xu3&a+kKe{FSf|39L}qCY6Mk- z->?C6#G|jw^uIcyN1*OpBim^98gk;e)G}K_CA#e@JN$dK?j(fX6K)C7SAiFuh zLRejX(T~$mxvi*`J&m~3@0^g;C-Mz9g*s}3)z77x#G6O{WG^d%u2hRXx^S(t3)YyN@kfiKPQ|&C0ht%r zm94(@R3WHUodVFYD0EI>O%wuIXv85d)~#1TkC0#m)z!qkXpa8PIH#W3IxVT=Pjjr} zZ$j+#_v`iH zI3GCFbrtM_#1_fSC6Ob=yJ&Y1qPGPUA`5FATx!4=eR`Gz|Kzj zDxAgbc-b`OC{Uo$6b4;0H6E5bkMN|`XdA16j?uBRAm-y_cgPtABG>yf1h>@wGFNYbC`7fc>+{Q zJ;kbP$@JQ?|0e^zey(-OuCf)jlx>Pvng!Juf5;MFhr^1qup}$%K}loAai|&r8U*NJ zlg$C{WFr5n6$3q80> zw^V%)ekzv^VsYTOtAIykSM1ov2}F{W&L7;J}vVASBd79Fd@ zP8LD<9x6S;gRyC%9`Vp%PPf8>y&{b;9x74H7ZKx-O+3RNt(x?L6Z#DX!=ZplE+K7=koZU4d*Hp$fZ@vQj(0D6S2^x7 zC;tpLyGAnQfP%E+{72e{;EEyeaKg~jm|y(H_TpjXI?QKkwZ5&+&pGB_cTs-!Id;ao zOaQVSHE2$MRT~$`f>5Wg$GO)Oq)rlMQrp!q_&hV{k=%BN+P(jw+^0u7ZJil7^~-Vd z?Qc|1>S}ncf;dtzsWT<)aQ#w=v_Nt+Rr(-@TVak6w3-QtJ+vBU)cpt6 zGa4rFr`NiNghY+5u>(vQFaYURo{7##3|;CxrC4gBC|rb9E17%#r|2uXjHj@AxQ;MG&;-{Q1ZP#I$JYtSas$(!va)y7qjD z{#90Wzj{UCJPHMxR#c~-IB0Y?ZC7sQm=>$_iZHIUT};y^zIp z{BJ+fg@n|Utj<+QG0_$3D;8<9Dhol6d;r9h%_@~aeDHRSb+#HR7ezXVIjs6=-e(#O z186H8aqFRYBJh8AY+JL+SW3(q;D{<-hAhSR6-{$&A9n^cXDsRn zu4?tlGqF|yF^9g(tj@5Bnp~1}ngi2tcGf}%M{Tt^dk)vt0>)w0rcx((u^1rD5{!_} zW0DEJd)wi60+Me6WM402yq_*lup_{LzmD6#<3OKlhXF9sY@R!F6}<+FNx-nO8^*DK zF-wDYD2$(ZnDOZ!5Jq*ITF_WXzBF!wwvxd^zOmrUF74I0kEf*>o_K1>GL>MQC)X_U z3fmf_q;0X^^=-58{%5<&!O+R*2<(50pN)LNKgB2d``hXl|3<(69nj1WW^@5R^Ux~o zUUgt-NpF^MX8B#lU7ot8yv$#$u`%nA*C4}Ev_Mj6XS38sGSp#rsHt4d4}*Tz$Mk*u z>SRbAbTyoRL>G(N3ly~LIQf^pyjHd-j?;9yfRh+#qCHk%TAY){iPY>Uyn5zTxfG5m z<(bajU(5|oJ>OYllw91VZ}3{q!Ezc&OMSsw7z`2KzX&>TFz9mE;D9loHF{Sf=2?Zd z$%*U}%)RU%todkvDcHe93POwx4@NdMQGH%|RF>ekrbqK7>*C;gF8)hjx=+F9W z7aUMR!+QGD#O9fTZ^KqYosXCFZ{bL_=B!rQajWk1#YJ~qITSqHa4PQb4uqKU@-1{m zq3nOO78&xU>3C_?hO-oNh`KHM@M(alz@Mycr!+nzn1Y-)_qQFvSuD|>QL5+6L(ue( zD>-T!!JUiQSvJ=SSysu(WzM1L;j>mmN879ggY{|YYS7VxaofjJPqkdPiH{MAo}wqZ zqoc297n(4@CX9h;+~N+`v>kSz#$xkg+9Qu_F|BgA`WkqyZPh`~c%IcJS0)!@&k0TM zRx{6VRYnz)E66%rrFS?nWRx7#eQw?)+xY0b1YGM&35Sh=d7y{Mw+K5kYfsj>h93x& zvdoa$qB3X1{8DM`i=nz0jA>70TAbb4_Py@DC1ZtCVVzhsB1Iju1R#t9T019_;$^9| z8HLtj!_%cMAsyH~NrgXcyLw$0*PyOf0`sG|P9!^1U|hM8mYe(h>^VxesUrj92~Wlxl1XS2K51NV14=N$Iv2L_ zDX`{SvKqf2P1E>!E>YbZkD%eBtAB@&fBTA$j9KqDeIfKI_N}QHh_x$?-X;a%`7~Iw z1M|qzr(0Ka5ZGwb-<+92>bjHtr|Z%&CLk^jGv(sl%`&l(Y8@6U83$dqMw`!wp|Xc% zYYj;qm*^~hBrDebzwoED?GzV#{?IrkH~C;3$P^z;pu@8tSa0D%w;G#wIy#u7TKLrC zF1O%DTb8%kmQ)^kms(GrcVg)0CE(*k3QMFwt}Q6INYf)Cn-I_A8dQuZK@2a)r&)L7 zlFGSa2=Tn&UPEFkB)YFTPdVXFMOWxGf$F8t(W5!a*+ZnxB`7Ea)CSJQ*>FV<1Zw1( z$Q$oUV7m^}a$hs~vwBno0xBA3XR-ZEnh#A3Wohx5#K3ZDFuu92=md(e3f;R;bX71f zbhgg5$YYdHm`h^2j-dCx-6X1kVF?>WyVc9!r3TtTb^?;zH4d>n1v;Qf8v1hNo)rh1 zm3}iu82qtxmgR&ivqBy3-eUE%hd5D)Z`4Ovv@T8RC_|!?pr|!j#bOXSpFCuqo2x!V z!^%yc$XY1Ev_|vei)M)bE-jF)Dsgt`lBPAnNnB0m5;fH+cWxh8T|w=I zdkEsRV*F+$v)7iMIF`YW9y3q-$DOnteg;dXn0KRK2|MO;N`Myi=tKVvnfRxWQZLa3 zXjL<8dq9#4`e0}s$=1#i98o@eo_h9aMdA&OEn|PAk@r{-J$3HPNZdt-Xj2ZlZSM9k z-zlq=mlF8moz>*GlvPuf=lBomRJ$s43nM_`r;Hgnx6*aPyC4I#`1gsT;)6fyd%hbFUL;=R|*=|YM|HZNVL zaxw_V$GyNIoU6}uDhx8M*GBuH@g;O_43!QI{6W#R7b9w1mC z!QFzpLvRa{H~GH3_uc2caqm9=-Z##o#~eMoe_g9)b#<*tOI4)SnRoR=czPO?a9Q`R zQ5iB;Y&TCnB$;7L+ue0KPp5(U*B#cD=7lNU+#f_G*GQs zl5-|ay^03Pr6rO9UZ!2xLTM(LH#M^rEc=4xZoHSz@zGk@>m(Ti7Dye)3gPsZNz+HN~o2E)c|`u zIcy!hG^40A5mjcig}UL$+{dV-EThZx8CtEWt2T3(B-;t_x8}i-bZlO}(|)Fzbn{*j z^r0y0`jF-eF}$K^UiaNgKOD!QKn=>=v_YGhw$UX^Rl$@U^)O4uwZt3BuNBm9u_#MZ z42Il;BLYlVv{oxf{B{N%lXk{Uh3TjjxFB3)sVQhws28$2 zg1GAu;iqBSxOVU0t;!DAY)b6jhvN#41ztIwFRtT^WJ|9Pd-zYT=9=$ai3VTOf6eE7 zlp&DoQmWE3EU=YXX=P2NC$!w5H=%KLn2gFejEk2m{r2%3GlB3v95V2_&&X30?z$SH z$i(DOmRY=uj`gFSzn3iX@lMmF<)uxZG$uA=$te`McGXnKq)VaNB5W=5MJ0TN@(*aF z2!X}c;r#4NGomBF!DlrZ)>e5o?$$$8wc`}M*y>$k?q@`0rm(kL^dha=UYZE?H}p*< zjU;wFSJ0h$I8#^FRP$JbZ<4v$31)xwrmIM_L+_J`k7*=av!NGSJ_Ru7;-l>NsV4J4 z=oPa4XjH?N+owntfO*G%dG&6@Eq8?ZVX4wuj5=Fh?}`Ww2L=|g=<+oDD(Xr^yHxG` znzEur_0U4}YikzZ$_yWJmwTjHS4~g({k(F1wTTwO0td~{260+l_KrLed6G}K$lidL zy4>3Iugz&WZASs8TJBjXUu#T5+^K3cbU(4SjmDbNusAz*UR3qL)6f^eIN^`$JcvwE zz8FO9IBPK^QR3#!J2{D7T^YSK?lrHevC`NxPN~b(M7WXtxqxx=y8%f_@DT=ra6Rm;xv4+;Zlc3i7c{LFJlJw^(ywM!V1~o-|z} z4JJ27c>G9Alk)--buqC%(nY!e+YmL@K|)2!j;6*`j#5j5M**WF66co^)nAc}H6uDr zc|bgYGZZKXR)co2TVNK_KMTMywk)`N|T8%uFFhB--Xn@EKw1}B{hu$G`J>v`GR&`E# zj-xx1Uis7QXEa%Cu$y%#rQALKWE`j96NM7ik`N~AX$fhSRcx0UVrA;8Mx$bm0@e&_ zMupGBjKhFSpA^;N*qH?$B84&Kp{8czLiYBywj2klAI;&77aC>_#XG~5pADdw=3pUi z*SP|?_-_m?yy1IXW*>kCWq)?S}|$vz28FxIvIp27CUC zDi(P{^1MXz?bN2~n_NGuA)B14oMx7sy+~F9zl)l&^CfUZl4ma`(G@K2+x(i5rm@-e zSlg~Hz+bXZnEPy6Y|ENzqp$spaemR~Xx`vFc5N>83?1k@4w7BV=6lCY!JsT)KJ6Zh?5o84t&8d_ISx zqpV_VgX4-glfeKe8jf%kI|JGC_1u@_%dSs92}I3_oQq2!qFj2#X`}J?Y0*f!@fVFx zzHac4Qhuq(Uo9CNlm57^LtqB2T25)r5!$k_)p9W$y_;$wj(f(ldyXMT_F7Z1Mc!!UKb?HYgq-Mr zD8f(cwf9GPF9Lnm&Un*>2HK+0LnY2yoy2T zO22G>HoRSSpMLq!>LoKuMrl{QaFA6tOLN3tONr%oR#Y){5Oqaq6s4Lxd^U1JiQtav z6-QTiaCLlH{NO|$>|s-%$OGob9&`Ncwwx)NGF9TfKX;uF?+= ziBjvdO_|`8OTc`*GNMe>C%Qa+1D=Fl9b5VXIy*#ad?|cP66)TMJH#13=y(dJq(=gw z)YSd~g(*srf+*e88dSJKWWcg-Q@dx|LT+BbHF{ydzX=FkR4G?-_TM3*oazUitAL0jh^yP?O``^xBd;S6WnCj9Qb8C;OmWx@|>EBZm zsVFPD4BxQFg}@c!|Fkk;;xgfSr01paknZO+y1rSn@t-KoT`A6XE4$ohf&aaclm|QT z2ZZWRr3I}1oV<*AJh|k$Jj;hX%Vz-dvEzP?``wFI>n9Iqx88S;d|uDFye|{Lwi2_6 zf7MLpkp~sn0o<)y>Ou!BEAJCK69}sX} z_6-zpx)uZl0)f!LlBEBW{x6pRQMgDQh6GxoBs2mH2n3(!FGz$W0qrjd0waKa3X)Gt zfIt?|@F3!X*S@Cof4#E)$47qq3i~kq-%}5`>W{4Cl@mKn95KnjoLxUxS zNJEjpz=MEDF+d;;K@dm~+8+cB1_~r&ZA7v#1V9*)q(Og!WkK#vreH}>Jctw$0R$ur zLDE1$(s%@Du*Al!`wk$VKuOXBO@L>Bct|7+DnQvEf)o-S1SvoY)Pf|T!SK-j5>-_` zSResX037g&!~#nsTI3-Bt@4>(+a9U}178|12>{T>i(CNbUQJ+GB_RO%ny|p~;EtD1 z{tzIobdbLUNcqCbA4CcQ5rIJLwaWl=pg{Q34T!&)0D)z!1!Cy}B}m=c067wUK;J|| zAbsUnk`378S_GDW2Fv=H3jT$bWCV-%KK!Zx3y>m1kYYd(nIkp=kNelRBB+t>0ANT7 zB~MAx*RBQ{%0WV-!3GMPla`Z$@zP_Gda@Ci*H7~j&LA9H_+%tVGtKcJ{{aRb5%>yd zu-L18CIZ78VMxN>Mz8?yZ0-rJMPSJVa|!4e%vXs7z0!X7mz1FcC1p<*iNMhE7zpHh z2sES^-U&`SU`b*U031&W32;3GP{jurjF&C)2Vs{VfIuQ%{t__sz@n;Y86?O65`w7( z0y3KoJ$eA1AsA@h%jWC zz!0QYL%3k1Yp^8jyajZMWbhvlgzGJ!FRy4Gu$1o!0_eZ;K^p&WUG9e0`B#_w$G<*@ z3>66i>Hi7M{TDhOBH*>pAO)(_lZV|X! z+1>x@m>YA68xlYoGo(R5IIm#A;!6v104!ig3dX7*yhUgU2V({Us%9<;{w7HJ z<|C;;eZ%Wm6vm|pl?A|h`J`Y9R}2W^$syX7b?5l;et(JVE=jTqNz#JVS4{;=pn+w) zLX0c_tMFd+BVnQlEcp-pK)w2Vynw)>t)lA$0NDHi;9La*0ah}Ch+M2GfutWSc}OYY zU?f4xky-RgSrYjDY*~^dj)xF%%!31&Dg`%u5&#jC7L-9Y{6v62CxQrI{0RDz{CAI| zfhB1144wj|&f;b)l_ZIrbCuElImqjm0Y0IFJE}?kR#RX&%bYd&wFXKvT+Wy~N)oA} z8~zL2{1-U1`&0-RTCZ%7fu$r4LsR|XKlHCnZ@`26+gk%cM35k85CoJ;H4$Jk6PCe~ z5U;lCpN8V^hX3*U-!-~Kn~ zR)yuvs73s{KtR*~0t{#USEZuiyy-rI_+MauYx2KT^tB|a9?A7z4S@`liytP`&2G^@ zDL}&We)SmoN83nmrlWrYXDG6LA+*Zwf&K>=I)(cVn9Q6a1v7#G)0}9W&L-2K;qZ53 z#*cBZTX9J)N6~+y7onaQY6i}lNWno2;743#G3UMy}THd$KS|+ z6%u9_j(^2Yn|=N5wEAjQyJ;ihdgB$HaDoA{5Ts}ecy_H1nU(m9=0#uyKe?0i@2DC< zGPHutq+s0>jdMO>7spI^GYkOi4y_QkVc#{pe9=Jy+;Td^siFgOqt|h#?h~Z({x!H| zTV)2Zm>xv{OF=iFSaNBCW}(6G*IO{0JSnPp`4XS~^Lv?O(!_(~vKU2*;;$}Lulxro zgYZH=D?NV{0gyn_L@H#-ej0uU^()Q~n>1dENt!m8z4)2=uiAJLgGAE7UA(`LK#8e` z725l+*@TR&GPMt+V5vlcrbhk3rdK*ZlDbx)-1Ut3C)h7E!iC}6=zVAdnMfxfjT~y% zC%DCb)}o;8Oey`NAbQG_xkGe&*Vk)zw)GDA?8>^o_LrZ98z>PQ~(42wfJ91AOro+R(}<$ z{UsGjz?^~+;D8bW+kYqZKl%TENdR!8MTZUnf`ov8f&bf$7Vta!mm4iXMZ<)AG$KZa zfcmL(f!>Qv1%o{Qzx-$cIDWK0pdBBpKOiUV;``c{DmD4%?>hWx_lkeVCANB>ZK81^uK8o6OQovFHXqWw z=gC{$cf8Cy(`fIcHa4D{-bU{_`cf(xYB1tB=VKUSp;odoDl+qOwR%fiM~9=h`U81q z@1R3EEU6MW8%X|^F}!qW9j$uy)9Ryj+E>{(J$y$m#I>9H!+cY|5Eb0ksIyJ^n_pqp zK7UTP5ug5`c3+(dAM^Hyj#Lb;b`jPFRS{ymgVr$y>8`Bho$Xzw%QtRo!y=xgt$M5~ zw%o^2uThB1(PCDt7=$aRay+$~111OR(OR7?n6EI#R7~x^1zq}-Wm-IYRi)On-Bieu z0)E^1p)H(;8MauP@5qL5qKn^PJbQ?|FyYKzr&@AJUE>@wz7$x;DuO=M!dTAR%5(N! z5iOyZMJ7t@bMP5&Jj7c!O7=KWz>Q|Xv0O4!NAz9+`G`rrIz_=_<)A$|)O7qjc`>YT zyJ1U(3HTP8VZ9{}DOV4vEEJ{gN%E7pq(Xtb)%7{mzlnVl-rXb&&L#CJF7a<}-Gehl zWx2yxhRt^2HJj~bIq6QXf9^8qK75G8jxtqG?kia<9NwSpW^@ybSwpO4J0+-`%hGp` zn(JHtjvo6l;*5IivDd2YHe+gTy~}}j`^VC!GvfUFL$vt>n@-LCy9kS=aHcMNd5`|P z80J&nTtbNqw|ffAH3#0U7}pP1GVTa&wA;)P<$)R>PoB-)&$BUZI@C+ z-kheE)j%&bu_^&kh6if@OXC(k2q#SNLZwH?F!zTqu^1<6zZkU3WtwYa{rWC{)qU`Q z!q2k|)Pd$Yc0IsNvE~I(7W3xqte?GZ*-}*8F(1WEE?PY}W83@31RkDYME zr=5>3_=F45?qLzNZgRJH!!j4S!bmVjsSkG5(pSJHdNTbZGy~W*KIG^gw(?t+1HVDa z^42(i9xX=CiG09w#AII}9Op0dmG1{;Y~cqmUkn*3jrHTC)4pKm4`BE)`aeNq#5e2H@1+TR zEub^I&K)JImta@(gTG+C;38M%XefLGJ>ikc)r${=>*}>)K=Ic>O8c*GDe(?#&M$w`j9Id=n^}oUiMa zET^;yF2%EGpstwfs=mZ_BnGqZ~zA6k}GE6b9VsHO+IHG zE5{#Zv?m&iyX;8$!o9(w;(*~DU_Osl{t zHh<9U{2iS(vT|cDMiLFn{TtfnH;l$Krs?PJaK##3UTZN|$M+LpeX!G?VErH>gieo~;3*z_xAq4O2 zYU(+9%Q3HKiUvWFecux^Je5TR?Z_nyhc!N{vn^`i!msuj9KI)rSY+oroK6JR+ z>KC|ai8RcmE9PeyI9q3VdM-y6HTu$rdi#zsayo`-1H>Nl{yEgoFqntEamDo`Q)*jD zc2^G6G+n6sMBPN)00`SXk~mQh`--oRuMhbJRKr{Dpmu-9fy+P%LlsN=(gz0;tZYU5 zL2KukX!A>`lz#a#kd1ou@y+8KQUmMI9E2_2T|MnnB&#%!FCVY-)uz{rzEzs(Ee|_`Xj<8{OFVi1JVZrr@-&c`@F)0^c{0OZ8u0P~&~d z%JMaOqbp3$qS#)C78>fEi z%Q4!k`%NbUPlR==ANqW?*L#>}XV1NE(VTK%yTeXSdG$8A2DRK zr&E;|i{|#?Oy?5}{MMjKSMS9ec>)|Foz2+YH@( zu68+ddtuN1X*~^#(%g-eF2xS`bBAq9w(EZd;W>>xgj%9(Flr3gdUUgd?LGD7!P-6{ zJ0J((Y4%uRMf3j+#M8)19;HsMQsUvdf>50gi-p6vtY< ztlDOIi+4FkUoHu$4CdD9FWv6@l3V(eABUcIyxTtexj)e--)4N!FVls_792Ll#lq2s zRhV(3voj;4BuJuj)8i5@usCIUFK)mkq<$Bne9eo*SlCmm+gNz(&TrWM54{O(tZ*k_ zI61xRT+av8M&9D5T-@y)*FuvQms!yN%Mjo5E63R>Jo$ftTY{4kc7lT=YvMW!sLuZ4 zIJ)PNEla3Tb^kU=d(z@@9B!^=CT)HcvE4&lrWsasJ0EswXW0Ls)Gv@>%uC$1jU{rY zw}MUHj{&0BL4q&6*MrdqE)h{j*$(p5tJ|SlJn@rN5=PTPn+uMjN#{Py&N$LgIDDA` z64R&SMC6g7(2)6VpJ5v-FFBf|jj!n@_UCvc!A#;!K>oXl}4S*s{cVS93f=^VCBLSf7X?M@#{a_lE-nQbSS zQLW(c-Eu@^Q`4V~kb<&gZ6Y(33;Eh;4LwBjpuAt|`KzSZwL|xFZTq8^@FTuCQa}v) zV^M~O;$g-8?&n`4IuW;i0p8?DVKA;Ar^Qbrcb;r1GxRNm)m-_rk)KAuBoGj`HwSu? z6Ek>6fbw(OJ_m}(CMO#C;b3wdvaQK;e^FOGUDLS}%p2~-*9H-+GfueSH~>`=`>b$W zluKXiBU_(h2aTBnN8@I7i&%Jckwui=i6T(w%+KXK-rXu=gpf z@rIrAQkEO`KV^QVrOFZBU1j;Lx?csMWjEApq6)>- z8p}9I)N?t|*oy?$-U3>fU2)+@ln>rSUsziSF+#v~_T54cy-*bk(4)w7jNU?ny5KBv!Z`yOs|?c; z0I@eq3vp#@zTaR$JIl6ab+CmRP<%Y?8Q8A-V0{(%DWuUdcQIANBPNEhp7N88rESNv z$9Wi$I>JM~#_P#~RFv z>FMMaF2!Y&%cu1ozO*a`s`E3R^N`HxxT|qC?tefnTQjcGb_i42)D`~LX2Ux^CzpipzT35H4 z?kQ<)%a$acQnIaV3}kcMM7SZDNG;%MIJ6mSaUpLt58&Hwy9bH30p@2I35ZX8&_+X% z0=N`+YhP};%tSF(TD;v|wEUt-7qw_ehh%_fP?Tw!NN!#|-G4o`j)&{Fc}%ar9b`^u zeHn?}^zP?ZEXZu7<^|4l0aY{V3C&c~!z$nvO4E9ABH1vIQ^U?^6|cSnU0Zv|V`CWz zySrd3GtA`4gHy6^PYmHu4&cBHg5gVYm(~x394Db<|Kxp0H>&ILXfC}Kr*u6{hyF)> zSBpn%f`DSjW;NjES-b3I4`oXyHLFJ)0flFy;<#k^`Xjg^^b0w1`{JAHrs^)$E;>do z0Zy^damQhybbmwWl0lA<+6N5C?)N?mn0jN}zujRM{YA$F#xd*@YN4_=Ime;0KA|`T z@5!HH^2Hjz8d^En?2^N0BPfGpw?@Oel%GX#T+PnK*Kxl^UTbA1II>i2Z8;{630WQo zMggPy)qCQQkg<}dZ_iKSA$O9`u)~R5bCJd6{;dZ=zaDk07T;v6kiHe7=KMIG^Gh$Q z{ng4tqWMca3QDg((>UjotanWQ>?X-!yQ@fHn-`kXp01C+q-FI=gPzCQF5Yfqmm)r`*F72lcWFyZBll_@3Jd^BIW2I^nqNo^-k(PGv5j^*Cn1SL^ zySw|e^|K46>n9mom-|$~uIFrpbYyd{4XICDe-)*z9ACVztzYjLR(7iG|K4DcRD;{q zurDnzB6eJ8(~v9Q4+N<8i;#WJB+NaC!D6$XQ2$B_gKDo_Cp-zU|2ur_u*l`YRT3s> zoPi95oq+n;ma^Q7+;t1KAI8v&&rMYPQv>0oDH6G@VvgKkvK9JdkRB6FrBRr@=#7?a zrW(Q0Hn-gt{jI&QBTZ!80d6b}Wbc zR6O}NXgyP_YtgX|;h@Y3-)|I&!_Ts0T-jzwwGWiD$1gItz(xp)Nx%h$TKvreiOWD$ z^-Du*J8;h?j_meZc#fkZ`?oKSLeE2Ar8v0#d{lBTU(Jphg=W9pxZY^2c^neUT8D!H zFG11c{PU|paETf!fK(X9OA`FRc0rq6HR4a~@D$-ggvS^b;jAR#lCm0)j z9NKBx*c01@#tuE%HE6vWOvM)$+*CG?+vK+k?|-Rzq)SGNWbFSv3PO=QYVY{!kh z=`)%){fG=8wG8!ymMtvi>b~7Oyj$6K_<9TnYZ(^mz>Y2=GP<9NFJ3vuLZzIG8tUIl zcI3)BGr$K|FF#zyP85?VZ>U5EVsb)SP-1_MQZm?GT!0HXYdZX`GTgq)bNL@>*3=5N}D?EHz0&+ zg+<60p;NTA?%G@SR|Sbnu>wt;6@C(3>Z8gH-UO(`Ibx=!4+ zYfyf#qyF|DL5}Ta;;=?skm^G>+@vEb+$pV7md=Jv%9WCiRNn!k)2~9%)|H1^6<1*>u5%;>eVB2TPwC$}KxH(K ze(^A2ntlf4Gk&RS7_*Dt%zakZP}LFrZANbMb*UPtjJ_y+85v3<6Pa;d5+8;uJ9By5 z#fr8jk*I;!uK6gbW&PaG(`R^r&|fh^n@oz5`~6&&P`62B>f04TM9l~7F_X2Z(xIiy zT8o@Ub>H)p1n&|PT)3ibVvS` z@Dnp^6rxG}?YrJM0;9or9kZ{Mwid-TIyBnEsygm1?Y_-ilt^8rYuiVvc;Xg`B+`>HQ(oI`jU*nWhvGl<63(TlPQnW5eOPN@v+-VxX<&M zWRj0}=4YdX^_Myg-lwcw@{!|x5btk6Y+_~qEmn;5!~Co4g8rA|yD$&R9%EB)?czYi zD!sr__l2acLN7NNqFVY%N(U+w$TUl<{I7}jQh}~aoxGMjP!B2>B>6%P+sn4n-Rf4>ou!E#i zFRY)Hy$QQFfW6u4la;S7(fm86N`>|rtuZS_=HccUQ>4o#22b3E%;u=h;aP|BrrBk- z)A(oQQ7Dj9TMb9A2Vme^@Rvx?pn&ro6p^gg&#N~U}v#~E;Q%|btdKTgmQ={79 zEc8>14D@w5kJ$lUDfsQ+4Eb|OBx0n?X({#j=oqz2dVZo6L7@I-B74nSBEi z2V}|wmw5$63nwqZ1y_EBf?p_<3a(GHAKCMZpNU#@Xjpf&xyN?EyhF#kfrDx^yTl5a z$IU3tWIz4^J4}6T;d$7-g##0e-In$<@%6^s~}j?yDJMsYGw#%mpjn~c}1i)7NJ7Y zm~EfJ6jh|eCeXB53{bso&M2HpOa0}6ZqwM)%i2zT{6PJqB)=UJH^}XaEU(*u=RQY` zeH7#Ni-^(4z*89Nnu5e{4>_9L2kaXsU?w`Qd#AhgDYawaDF&kH?lR_kx85BSre2}r zdY|sO06ucZyt|_gDP8zq>1PFUnw-1TY z_?{&u>aC%lZ&a!(>RNH1?AGx@)f;`?zC#UN?BgE;-TEQM>+u^|$?xUX!DFN;^KDm8 z<827>-l31^SZVY6Ma^>|U&ND5eg(kHw8LXMzvp%4CAV(uw(f(V^CMN3NcH*w5B-r^Qd2I=X1L5yh?e)+p2lZ)>hkRkJEKLLHFej zIi*pfJ4P~-l-r%!DTtq_(OGHv(r-%GHWIOO^mOpM2lwC|R2P1?l!4pHHK z?2PlgA$sio1WO_yZ$_Ao;ykm0Oo`)GkMta@;P#A5hZvgBT4mlgmL* zICgtGCViK3>@I)w#4dBt4dX4FNuzA0@17n`+yft`) z`qO(;eG2^gk_5Y}W4xkexD-#{&7Y|5m9OkGcMTH%4sgFp;9h4$lt6( z4`-(l=1tJ^rg4SdRP?>&B1rq#KwKc5&pVUPyI@EIty+MVT-|B35hP)OR2Y08=dqc} z4}<+p|BxU=dBx3&aST)9N05w7#4ia$Jzzvce2h@y;B6$gx|AL@kRW_-)=KF|k^o!`t4J3B_uHPi5tq=x@%2aA{e!a(5)U2=uGSW@4=DLtcj8L zqU=@By|~rO$orHYWyjZTYQDm$!q{Hxu@^k;_jHp`ilnT?#qda6pUoNP8*r3fhSW&W zHS4(}?i*f8ElSCK#lKnH`E_etpy-#r@dVcU-j$i%L4wtwIKu~R^vQ?}gI2mW2idKh zvi0oZDEDoDVx#QR21ye8#S3BL3j)rs7nFudLg?*lzuxcpY;jlqHFR;noDzxWg3^Y{L=seJc;Ze z9OYUd&aVq=dRjlo!m7t8p|?sb2y1fpmnkV;hRn1VK|dUM5L+PlV{Eozya`ZZ#A5TE zGdZ+9BQy~wxx(=eh=%rCnY)TnGkN`Jt^+GL4lih#H~g1+4rCi3YLi-Dl+QfbYXdgF z%mS_&p<1@L+~2NKjI5jx2Aup-&(-;o=wQi~7EC3p?~q~LT|s60#x(20;)%H9*K_Rg zk^RqfUgz9~(U)#s1g&j3aO0yW%W)AK+TOqTefPF=>y4#lYxOPyul=u5^fLd zKosT9V4_?;p-Y7RdXGk(C}a+AE;41pB47?DC}K~}j3O>s_z|TlOr;lw$Xs+mgf4Gq z5*K1bL2zWcxKsMl7hyEqzC}g03xh4T;Y4;Uae}bL3w@=Q2ga%4;pd3n6UxueJh_ry z%QkD`?l0_jH2VQR`Jon9YPo4T7C*0VoVDB+v|_k3c=b>YtbR{W|02bMVPQEl#1tRP ze2ayE{jhyIVZ@!h?_cAp&;8zNJt%F0Vp{KZ*)3s>Kc;i|VZ#-*H)nj;V^Q~3@% ztD+bIA1p+Sw(d1Xnt&a3B>YKcK>JF|x7v;kkEV4uc6*o{-H1MdPuu(=i@ zGI+OfzfBFDdpX6FJi!=kx`uCAX+SgUh7qlhf^V7oYM|G#9?b4k62Iy*MPAls8)OC* zzltxVvvnJlf?~jZ?Ln`zTW`#7HA?ZVxbN@_-5t?ZA3wZ*R(R2yhjHyW{t|$w_`C2z z==1K#Iuq&>-(vFO8pFSd)ie6imjgL#pE=HK-)1c*sHbI)zRQgpZezlT!Np@ktJI{q zeD9v3q2ubPU1bD_tG*9GkUBmRBRzLcwTr5B{oWR_kipFA29`qTTC^q0O_YqjNsqnZ zX}@ieAFBA)jV8ePhu-`$&)Q`^Y0OFXO*b`#b^eTTUrbFZd19|Qt71fQL>^k=#_UiA zx`_lblK*_Vm}Le=%9(?X>kKZY5EE&>I(j~{im(jb;v!9eCpLy@@Q|V^S}QJTQd+ev z{C8Fg9_)Rld{&aJavlUyu-jZ~G37!Juw9A25nDv}Il{VT>^a)N#n0I2dnK;o%BSE4 z8x;-dM{Et1lCu*X(oX$FcZ;Kbt86T{jqy+!yMFPgN`e9tqkF0n%k(3w_D0>gXl1em z{~r>cyOztTJ1TLkFTNkP85-gKs#BDc+R&D3x@3sk|8 zadtr~1ecuDv#n~TtZJOfwz*ujNvFv7{9Nf))}4$0JzJ$`q$vADOvhqqRflMQKR^RgbkEDnd77kxLS5#Tza=CY(^oNVuMs2R^-hgC|si?BT1Po)h-Py=ROyNmJ_3p`RiL1ChvUJ3R6v zD8oA+#jMhTE6yCcp??qxmFv*0?v5Jm+nu+U9 zSZUyStH)rBQeXq}Bw0xcT4uwoVZq1sb|w3^{h3AT@eR;oY-T-;3AmC5F;D_(*>fu= z?-eH}Y4O#;w;LZt>R6E>v{Ys}eIw}hrYqlC)UGVBjrs0{Prax9G!5gC#7w2T7rJQb z#OfoV+bK51sRVEJS$ zn@f`$*r@bmR7xT3E%h;nJRSte+7ilz*@Rk4?`9Wqqm(ASaG%i2al?xlWAV*MD8-6P zE=?Jj**+?jWRSd6JHTxOlIq_z_zOvC22CX0n9*sw(+HliE*YPae`9S1X}S zQ#&sMxkRv7>+R)@-go~$Ae|N&9Gs z!AQl5O_x$5p2Evf-j%zhSRtr1Od(czqs=i@5sZ_)nIYhbz>=|oNs}TBr0FT-lQp=| z&=56nYKg5AN>JQU#=bsl$c7R8sKNA2L8QF$o-MRVqDoqyf*v<6feazqbc-87_@2B_ zS;I;s=G>iW^hX+-SUi`Vo!oLE_vcIq`k`*|O z8wqR&2_>#k0JFdcU_h>ZJ&ii_Dk7)G0KzZgRx8tA)iIfzP^1D>J{Uln7 zCtbt_g=YNF;)8HU%*g_>h_-jQ(u1j{?F3N}+=cT)n==T(%@?o@%{NNVd z&ncP2A(q7%ro&eN_(2Lw(cF;Mix0Y)?FosnGh$bXAb?$&^pJgH$%dOkyS-{mo>5v6 z2(K;z-xj+)7$>(|%b;EBBJW^|keo(jF%p zE3%o-eMF*=k{rRLf}5`*`)TZxe?iiy&A?2dF?=kZragx3im~s}Rf8gBlCp7fE!l2D z1H3VsARb1pSfaT)k+woJb#ez;lz5eAC>+zD{nN7^SE_yHHd4 zd4B^&#HA_hr-c>We$M1!3iOw46h|__qjy!y=)mkMrWj*MC|{{hu&5_BJjNo-EgQ@& z??6LljB)E4CAEcM2lRF=+1vo{Uez4#uh7C2A6qM7X3+Iu$oa*RCj<+ zXqKDurPXiT7a%C(HSuxU(B7Dvm=zZb@cO?NJ?0yn!7pa@n?-plj^oq&vZGQ$!K&A65wqp3M3q38DOM7U=5TqErd2wIXkxk&56Osdin7l@sF*~>RQq2N ze-TLx{HpL-Si7|iDUusFPB5d0PZA(%p_c4et`qqcerTgch?8mL!-0pza=PD5vWEL3 zb=}3SI*A&S$N{_i{j`~O0khJDYwEBj1Bsr&Wf_ zv0AO)dL8x`FjoZJdJ$zj8Md2Ge|a2Bf{r+{I$?P_#G8E1_5sFHRUb8C4Hn2*y#=pSanI>A zjfc>k66k(TWkp4iYjlc8<9-%(DCm2O$KCJ^j8)FYgi17>M>hMJwsSTE`IM^KPmsap z9v{oATd|(@IVAJv?1_}Am!EvEpGbDuZ=dj#ngJ?nDOEhujCM9!&$NQEMNLbyM+o*T z)hd!mJ@&X0w4-r*F*fxvT|Gw3RW{$bu?;?{%juE|^+t_o+G+B-a<0a_5`8T1nR;q+ zCDNq$zCkJYQFC!r^cBR3<=}Y?shI&+b)_7mL|n9iq7jm-@EXhV>EoR=dAg;Kmt-GI z%;ExirqlavXnuA@VhC!d$zmySMNmW6zAKG<8fd31;ijPBAX`dNwCLqL(r2@ixzeC}@Nr#;oa$TZv(Xz`p?XH~ zo!DY3>x<{#MaGv@-yiS&DA&CuXSEz46G57i9FoR3b^H9x9{ za#$I z>~e{fczWHI_kE%<2E~QjVt7sjCJKI&2ZDq7gq;eEMB11p=-?fV$lfCJ+>)-wA3|^K za3o|YVtE=rxH9QhFMaj5wUSsT8M@|}oUo+3-dM!kNL|h_zaxw2!a0eok&~?+k@t5hDhE_H zsTzB=McMy{y0;FBtLYvFXOO{zySw|~Bsc^O?oROF5Zv9}A-GF$cX!v|E&+lE2#_6~ z=l#BYYwK5ATl?4Ubl=NS{8*M|^Esl8MTsklojXr)3{IztEva8(w{v zFi#{%A6u=D{l$=yzKIHZ6FAgotUeDt_-qo_?);6^&5XfhgE7C{JfYt3n08D(v-pbW zDyp15Emt{eCR80yZTYdo*yJ%k^)A~4-BLKKYOY8D`_cXA1a8O{_Z zla6W-<&>r1NE!ZEGcn67^0G2-<3iw|%WK?To$cATuY2^l*EHS8?dLZg6#)Z^5h)ai z>Amq1j>SMKw?s`dE}D`$SaTW0=(^qFOqd**Nkd*WlM+$oq7fUImgsruNDPi#OO*IO zY{yb~?pv?e!X9C2iz$1>;(NG$k37cx_F!t;Qc)XSQzR5)5huWq0J5uTDD_IB3KshF ztT$e~&a5Ec!S=Tu4CxqyLdTpx2x$p-2v}g{-Q5!dWX&Xx)jthM;l>*)DODTEq8JZ{ z?|HmlN5;3FB=Rxb{{kd4`f4{fWH^a_1r29lQ{cwBU||EMhaOHf6fDut7OwlE!c~7FQVMNLVPQYNN>7 z;84eGCZ}jFNIDg)RG569Ho5pVp6E7+!u!dfyAbEC{C1`KL)@8gh@IWTRkf>d}BjH;hH>Qm9+jo||FrmumY$ylD zkxG0GA?oIL#7YK*LQKNzM>KBseO_B*8pk6`G$Uetl)XR~UUI}vy0PSvb5`YWAjQ>)57I~=P~&V%6MpxybMj&C`$IQ5Pc2TX z%lJuotW54>{!%o&SvKAxN(y0ztasfBJi|cdJqB7h7=7txLgu|0ZT=+#RbGV~dR1+( z=+~;SFOrl&A*Qr)Rr63_s?aZTng`0+S<$1G2vo-*j^W$%D0B%0ayqgEMwj4djhyue z#~hkq2W0=^FtWV{lLVT1%>5Xve+C*Hsi%--~pmX;1 zwD;l+Bat5C&?o5#^Rl=iK|H z(A3kA!%&VVOx32V@|JRRqM53Kaw6^%p0a||*vV)H3>Q++UR*Zp;kSbQuM4LgpA40*0 zNoP|I(|jdhM^Scqgq1^QFsWGPyomzJhv5qplA&}G;?M+(d$U-h{d>%;20H0W!#pnD)o6{yFH;k7XLsb8klWn9 zfM6(>8}SAsa#>HhAsM2!kYS>xlI@%C6@=<6hnRuxD1_4}LAITic8K-9=_*`#vQpW^ z1R~8JIQXqLE<>fR3$>{_g!tiHKT9Ep6O+)|C*~R*exzA%n|W^lrVKplTMQ3Xyu{18 zJ5;zR6stH4J^F=pYd4Ia`f-obhuEzSSa^xyXVoEf2sWNVJ~Pdl-qmWoF`bJ4vqk72 zB~%O)h=cby$l3xv7JgK5o%^<0?zHfJRMK{6&n^mMOh5c(>;oRSO9cCPYg*IY_wfRD z98K|?VtfFlX9j#4{)?)SMiJR4a_!LXNBYc9~DXPwk*cIQArl0;4cmJIPkZazEqI20Il+eD^}R5 z&G`5RHgR9*hIcv1Z|M+5#R9lYbY`WxCm`DSr+`8!hDabAyPE(*pn1fD=7)ykU=N`~ zizL|Z@DbQKsgs=B-;~m=AT5g-lipEFv?b&0@FR^s_fe{P6w6dSACubs1!#nSQ5}>} zK0DUauYlMWa+NVKr5ik^gdeO=-US4z{7grB2~5Ge7?`8S0Z ze&&eCxA2?ei$(b5WZYscPa`@DC(sJnT~#~6Qmxc_SXW!PX3d;y(X`}B^KYUr6~sa7 zm&`%dpZCttM99Cr>Xg8-tiUO8H2+UBX3`|r7+1sy{QLht+avEMB7CSind5Vl{NC ze5nN_=;9Pe6iB4EH1*fo6G%j~Hq_o=YhS#YSY52Qk?e)mWodS+!IVmSZ$3N~O8&IB3eCe)le) z5?;%i-%Uy#O4ogyycT@MWC63`?ok=g^{lJRX_lEER7C zn(b;dMh@D8H$8A4$*Oexw4M`R5^OmW5Q4*hOi4^v#=7>f`;y3 zK&b!O7cLs2Lu)bh<`bA><`&^Hw8dy61nkaS*>aD(-KP(3oNK076##{i|%$@kV30r7fVJ3avkj+75#3XeCDv1;rVO z15$!@)H3JTOLP;CTA)4m!{=$<58?Z1%c2}2T1vc5^YBGvfg7CELrweORMlR$QEyYS z%iaU`@^U0aTmPBn$f_$;0HMPrZ?4_;b&X0ueB9}LLUTQUyn(u62W=@D#7Ak~%@^im zf={WM+`G(6Y$l&8!K2$29&#Fz9%pakSPHV~%wqPll4zOTL3Mf-a*ZIpNuLdpM3p2x ztwtT(R^*@F^!gw3IJo<&i{q05)++TQyvOVbI5e9A;li2Q|47+Rv(UMj^;kuPp%f+VVC$mzYpK~F_ZG{ZKd-~OHX;odm{Hn z&6#^Wf1h}Xop?r_c!8UkeDF3u_Ax*6F&wE$id`knoAG#qD6mlbNGr57$FEHIG?|Or^o*aie3)dxrz8WVu#>1Tw8__F$@~MzGNE(Xh)Pj1 zfqB1(#SJ1^2P0|kMef3tOGJMA#y|ZQ)A|cQe}II2rq9u50r_LP6#)Ez(88}Vb?{OA zyKHK``ByZ}%*M5@Azh_^0eOUy86iJ|x%ICP##@k2K7Q_3;r~U(FZxGZyRwL@NSAWK zPRX6ET%x^qNnc`xLK_bmyoF92+~_Hr{l%T4+qO`(a51im0kI?!ZFw?|Zle%OkT~)7 zS}5iir8~6uS@-ng+5PMO^ZNar+=>30voFt?QT=b;BXQ3!FShi5bj_-=ndUCNn{H9f zynF>*9uH$9?G!u}f}1xy&rdfYVS&-+El5}Po*7);*6HKK;>WLdv1yj|#o18yt7j0N zHc&_?$R%Vm5~7b=E*~x8cTVY!UfxwlGDKGo=A0U3w zJMR=_1AB3N{sImOpSnGFc`RTgS`7W?-jm`(PV`BO1Nv20J0V@^-)cP~ti$iZF5~&D zBD!SvWcP&3#8Qs>;fl!{;IBif0O)`8!6MI@%$GSO}Y*D@hZd zYYdNGf(fBlz@IC{Dl4?|0%itKm;B6_ZSwqJU3BvNUj zh~&y}mP#O<5sW+^dR7=lmeL8G%n;1!ekj_v56|h+SP>QxQM#RvriV7*V=20@=L`21 zWM(ZKQnP;D(6)H5*UCXH$7QiNzzbW2FfnDu@o^8Yf?&$bi6i5uC45CLiM(7vJ-HVJ z2$0WZnvOLaj1luVso+76E*%6xJ|Cne;Wbo9fOt?KvX;o%7$;FAJZqOsZez~Lmxeay zz?@QCpOJM7LrA@R{TJ}z_Y)7~>5xvPJZMHGo%8uc98x@} z`C!1ZS$l)R?L3c1u+ELP{JgN1x>GpGm+5rb_3PSK{gyhvCG)Dwcal|)Ech=#>9x5Z zqye?qtE8Ftg@+8Dj_kW^@&ZpgpGd!4Kn8_q9lYTHa>9zP{;p=O6#%?DKu1}bk$9n5 zH&MwMg80F9dVXYWj+F47>daL(B4h!6J?BsOmzejRPIZkkT6s?sp0TcWI{Y@7CHlXG zE!HSyd+*m~-e*UtRyC5A=^#2o$dSp2om42gHz&^6q@G=q+2qLme6>>Xzn7cU zcg30T)(@SN-GNCzqdRdoUgfsy(7YTr{{qBY+cjUaXN!O~izW1=c?=z#L?wm$#>Gd4 z2k&X=PmsVOWVZE|S}Pr*Yf?c6-uPor>`Dy;GB+g3@F@<2A7HsAh5hmc53Ebh=Simi zpaVh%kSvK1-)W6K38^IC8g{7He!`2JV{q(>I`GD$YhjP^Gns_#|8cnrZHhFK>Nmw{U0A6$5+*xY4sWaoYq z4=DIhjH;PRT8i($DFso9mZy(BaVFmy0pq0+BR{+mc8k9Z(km87s$)Z{;CspZiCj;X z-zrk*(O~3t1{oNFFv6;QixD%<9`e6)*qbMDcwgXGK*X~07 zCI1}kWWYL6_`s?&5 zYx8^QPN{n8a36cF)eT>#flB7$9UQ$rVy8C+OIs13t;neR^Y=%m_l12)c46j3WHbds zuWv&@Mk;94=!Ijlc=%_O!#i);s~R*e_dHkov?hMVb)exHB8FAwZU%IW)f@L5v{mq$}GOg8+r1B%9&^m!Y_N8=P_L~j8C z{EZT4Fw)i?9z)aJWlsFRn3s)hQy}jB2W?K{vGUgf4flM47S|E^A%UJD|R{szBG!U zkTsrh8Ut#`OR&DwQ$PUAUq`gy6HPgndAN))JX^0JSGfgRXjl(Ub>v>rN^^FZ&?m}= z3%|7oFVexO!kB5hi%*l&kmc;`1njF7>u_=Y(_FsZ`RC@bWy4Tv;CXYdr_k=A)R;4K z*Uv3G_4{nuvnc_t4(Z2Mh#r^zPsdk+ZvyDfTdY?!P3zelZ;ZxacjWro1D`_6+N}51 z(LHb8J8bJh2$Ln4kXZ&wlf|+eDeQ0jM7p}nIU2zHrPDNBJyoUD)8;(k)L)6m>9e39 ztYjf#fy|n`?cC&V9yd9qd1Ie%Qdb+m=F116$ZToiZ(Hj*ncp^B*R;-^>!3OUg0T8aC7aiRhJSh_Kl(e5{{+5r3IMN~_X zE4-<`#<#XH=j(5`pdl>{*xkY6p^E`=rEFWmg;mYB$6;op-F+Hk-S}5O`eAqB1L(&( zD5*;;_TCUhj25nbv8C3F14hM*(-~;WMp~Eo>`i2^_$lk1!HVvdz5(!qD)`zfnyqR6 zmG&z+KALh4?xRW;vG=c=yH20qves&O!;e@*+A(X8a8SzQ`eNhGGL@|O-{uvq^(7B2 zI|ET1)2gFs>Ju^+1``;>+;r(5wj8^UUZ&_DeGVL-t$!oK(s$CYlu>bo|3LTw|3wGt zA|E|MPxTz;97c^PCO6>ONyzRBlIfleWx{w5ScZZtXf0?h$ZK1STNk)xpsoZ&1Vms4 zjm`9(hTy3WAuYLn-CU=Dk9W+jV&U_QH&O8+fDu%9Y&8AWX0mg$^EIF28~T1-<}^P* za&RabRBh`XfFQ+6VMbv_jN-cdBi|CrKb_#^B57)ntmgb6y>k6z=6wrI*k$Lw27C?R zx=uZM8<$B$ViA4gbf)Dh_0=cw9wL>DyO0&C^^O^T#Ncz;f>_X>Kdn8BWO0*!#`})< zC7GaCK!oK9o(vn~hM1{n@t+afg;~3`BNBd*R{P}a!bM|S5?CDIaL*vBKkocXIkaCc zD7rrjHxYrMq4?m;03z?#ii*vVQFkC?%D3KI{#&Z|92aK4SUh{ADd&6iHFy(KW`>UaW=E=vytrDey=TdmTX^=7taXQ z4nL@#k_`20&C<$4_&W@1Uq1AVzW^}u^DFuip$BXG^J^%)pY7{y3I692d;OajJWw$-gOAR)cye|=5yXd^Xv$K2z;)EFR?AJk76<)l!?nVZrL?Tm@QYe84J^4n|Ivs5I(gmOQw!5V{LF{7)6QT0w0x*?_n7qJV{*F9 zVI{i`*0a*ekK7CtNI3Kb3W@pzy}+N%RP{!Oiy*nTj-LL>`u4qLtfG7XCJDRy!qKDa z=)h-3Fb1cBkdqQE&GUg^1-J#2{q`KP3s>?+ZsxiHpDa z-Wxb5M!JdRiAZ+8m4z68^U7`9{b!_@zHo(ZdvxPDmKNw`OHPwmsAU{{Y|{<=O*YC( zlt&wG+v*I82(2yHvCVh7*m{D3%lj)x~7O zKUKe9BKT*z8eeX89wH; zAcEA@$49BT_CKxq9G!JLtjvHki$t$qrvE8A@ixKHg)f<`(wT40SrPEGA-{!8|HQzgMnbt!Rua*nXnX++OGn=z*%WQC&VA>;%Bgz;w-c6o zG6vTBvHKs`_TTagm8bFr^7`G+6eq-p4QUaM5yo%;nV;%yW5*J9`iuAOj6J)_mvt!@3TE@;+Ha zu18@$aqM3N!^_s9AP2_%+iZ$5@&xen$1b)6AdMRZdqK%DB}UCfQ&f#(?cWB&t)Gid z^&}FeJh23HC_GRI48=8DseSMNp(Gvj$1UChYLe$apksJ&8iUoiEp;||zE>~U_m3of z=7A9Z46%=>!JeMD*^YtbFjBFF8=ysZv@yO_0&R(UIyJD5t~FUCA~zQ^udR`IUYr+O z_>~bfi}$FVDJ`AHz+PfpFNj?$pS59Cb1}l88qp&ZsEr6D6A{e*0)BcS`ozK?($DPf z7L&}hA3zJ|Z)cdiPEhHT*B2J6Na|@zz%rDNr`FXhZ9`$C(9+-_x}X)7Ew=wJ*6*1R zvM9GJ{4eg$mV~pZabf1g?EQ3mb5%C?20#0TD*#$Sf(Hi9Ln#(uLj_qR`^J?H4DUpvnFubU5SuD8gA~V(p^C5BcM!un(9F^ZgW58~&6fM< zCb9>0cPbcbJYr3(ZxLo}okg2K0Ewn?Z@xHKQnw z^A;zbi3T?+cH0NAHUN#i<;U-V=W=`iy(N{sa}IeN+rE?~oubTWV{NsKci&*h*hc_a z9v=iY83wh}#Ph4~djEJy1lHsua<5>wn} z@9i(3@&cl0cGPh@%VTSYXi|#&o1<`|kW~*$xELw~>ArY>O(@KBG&hnifiI7yv30`C z2v@I?WOl`PQ_}$0IMZqDTQzsRWmwI%r9b zDx0F>02Qm&13>U^_^@Lq@7o@6^0j2k6KUXWCxOk``N}LTd&4(EF(J?j+A?$*@B$>- zT8TSanN^^G&cI?YJUW?e*1}P)utmdRd#d^8G6BWPGkU=&M;UqiDFrLAOe6KEj%?QL zVJ=zEM0KUv`L;m5|*-BvI{O5a(`1g ze<5|cEz;%?nHT6H zyG_K+M=nt|lAZC@0xB1=+m<4ob?)B{mfX`;} z{p6&W=Wh%!Zw%1+pwgV60OA~ zM-|3?T4MuOBbHJWwIDAOm6fMqR<+9oU!0mYToN%t(f^l%rNP|y(VhRt zV&yBjkC4!j3Rcqv>dmpM0+i)*yDq+F03qT$GXXt=ZPYuaIstZL#9{L9@KNCsqdPO< z%CEh`rKbW%w0M+wBIJt6E%1i9J=4q)ZJ$zY(fk{edKDG2iPPLkZr&Ea-2>PW`jmif{q6<58Q-Gz=nP*j`@P06 zslsR4fwx>T@C^6%{Q~*%Pw~=V>G&5un)rcE6N;fDt+&Ecn4*F)`Ujx`aVsC4UEL*p zUsb^&c=cJep(`P!DO ziC2@I9X#ALKv$r1;BSs*{ziJlJ86z*rn57Yt~Tp&4x0z$mL|v~K(Y!hz!ka3E_Cxu zj<hNp*w_qp#KL~c*`_DQ3B@o>^ z!BjZEU8?se@;msf4`l?Z{M7r0~9CUxp%L>KF&Y>r2Z5{Gj_48!K*cu z(D~u=BbRa{C!CZLcNtO}L(U(p(Tn^5DIl>kt8AD>&4?W>RCNWPZHfweM8@1_`_Kgc7iTv5C+Qbqn8aYhuc(e zgZ16P^WyLQ%e6($B2Syy=dIcd;nv42r($lOZmj2OPW7pj{}%af{wI;|;=e_{c8}o+ z@anwHknev9u)!S`9%GRBfgi1jRZepjp?mRzGrQ&z##Pe4YdI7?o*QD+hje6o3)bg0 z!3RJ&X6$bRyd=K|Vv)sJ>*$vBSDW5HHoj*C{gf*c91{x#_8>(+H$ia?Zrfa_QUe{1 zd87T&hgx!)Pmp5A=dgOBEzG;+rq^yE4}j+fHh2UI=2(}qH)2yhTZJ#(AJs>6oIme} z2VqpLt&^$ilecPhoL|66cL-A~W$F@rg7oV?0qa%6$NvPN+!{di4s+;jt|9A1!-z=Z z9M5MhSPT|o)(R|}yC$l=>{E*x&8_72!)b3dy}n6c}lMKS%9vbl>?j0^f0 zvboRnMUAa;)lrRx#wqGY4axqmzX0h!KJmhkz=73;j^Ql03^^rlF!>)*ss~w~$%3k+ zJv~F>`lfLomt0&``(N02-$6A_#r_3U*z>1xSavVJKtC1ZS@|Dzj7-#IcE6|yTJHEw ze6Cg~lO6Rv9{g;Dr_N=FvKJ(zKx>@y!}lqvD;Mejo2~(8ahJfJM>PZh<;O;PB1-R8 z58KE@Ss^jG()Z{FUYmUA=@X24(sTP&smK2`$=4J z2&!u_w6Xdyq@Jsc3A%Qa8$?`o(-i}n_2^C_)8Bc$e=(MCf8>VqlflUnm zEkOjF{DAhe!$kY)-Otr1{<%3*+gkUd89yQsVTe%Fjd_t&Z_e7p%S+!C+FD1*97;n= zb9da6V)cO2xPw6fgZ6Q%S7Z-^4<}G$phbQKlvT_22_T)j2OdY z;g?)6Squ<*6^cXLrjXfZLoWnf4MHy&4N!aqXhy3^IeunC2ItmdD*XlA%POx&R|S`I zW#AC*g(sznIV)?rGY61Eh> zYh90&^KyIi2{sZ%m*7{3k}4H976Efhxl85N7%cYbkuZ`s1GJiVEs10WDkb?ma*LU% zc_PPxb_Y1##%XTkXK~1mhE=Iv7EXa?8y$575`m12NGPMdR%MS(oMYh4YI#$Wumy68 z`CmZXN@HbY-;4oWqG{Y}8}x2Vm0cvQ5e_YXvyEmCpCn5JPDOd$FOpd`?O1oyHn(l+ zS$unb^+_lmGfSL-ITKugGBq#@yL`CVe277d07 z0k~MOChD#PrT$TKrtm9`s{`T^NPhwO_XvO`M^KctA{%)D6GQGMR2jvh>JVlo{tywI z0hNYyQOH?(ad3;81d^UuIAU=5T$SyZqn;t`EfE*PhWJuQ#8;wekMxLv{bCw&2Z_q< zMSIOMX!IX2oCKOW)G*d4kS!5|dQtj*i+Tg9egOU31vh_M2oa%h>~Jdr_ya;RNa}TvVS=4Ryb*lrK#p;vq6;Ho)a0@DjU zi_DS-sFWOCRsNUcxU#?w*)YV}=yC(guPcB``Z}k&)-X0I=e2Qt!+Rdt$8K*QV4u)+UoSSTLS@Yu!z|* zVuMVxJ&|9lzOliP1uv+neS@ZAEa)^Jplf)?OWJXGf-pkjcpGd7^eNZuKyv5k*a}c? zH1L>Sud5HUp6x=v@Z!k-AhEvbNLJzAzwEgmP+G!uYzO!p7KOYLU#_LdMur)#81{J! zOLV~5_ckb9Eapxa{$2D~7st9;PYsq*D8OM09<7R&Q3R7lN)y4@LQI(~8COkRQ!tQU zg5y&lfj&0DY<`*_GaA#^L5gFXgM8&x4j08NZSe-G#k=1lQXob^K(4DJ|6u&I@A!a+sxmFaKrQ6L$YSu?^|7ut7` zZGv5Nsjtq?bH-?{SoLbi*YrqP4!Z$V%*)5}vaQ4Dbm% zYiciIx2>a1^C`B6Sq4o7v{Docg6<6GPIl z!UUb74H=TEJq>?p(3j6NISp|L{c&)w7`Vo9-wZtrXE(cR74lS z82GG8)#TSI+SAV7>n-l59ul)ijNu0(vMn;GQ;424s1?ohdKp3XBLb(A0ahJkt=2=2 zPsOl0o@A3J8jh1*nE_N0RwSsU_7+U#x^p`qw!aTRiEw4_%E!wyLv8^qewx;{+s+uKkyZ?W z!K!Ru^0v6)1tuh66+aLlL(pi#I!7P&$R%<}?skoOl>&fR zCN0I$_96{h8)_9p=hGKDq&C5ZFZd`4)!It2i>YEBJ*xqW??w`l7cZx^WvS64EYx!Q zC@6e2h1PoVDsVGb$XjF`%PS09N2Rc*oDFptor9hfEie$P7jWnCI<895bGizf%iM5+ zk0P)b$Kd&HK9r8*fZ&uNCu~DIb_uC6Om=t9Hh9hM5HxhmsGL43{bt^505}yI5NPJh z7Ov0PB{^CTVfkFdF^>P)sTaWa^U-d(!y`7TM(@?Z%EHhM7T&XHi|Oy8BS{7>>Bx5M z-HW;@G`t>gOdd+RLzhK}W`#vjd#ILYAIsWs(7`>eqpJrp^bu3%w|@*XS4@*QfI}@0 z!?}`<`D1_X{aLE`ntTl1BDe)^1N%JeJD3Z5N08c0-khXbU!MVvc)k?!a%Av+el4PXxHA}?LUGTO_-+_z?C z^a-5gB2QTbHI}#c99T@z2QF7AV;8&XTXu9|0boG@h)<@Ni76tvj_7Qbj4#&-7B(By zK@YgMa>cS@9yUnVpGZnINf^mK|1|BLPoG&xg2Yw}2-VXu$vgm~u*l-0n9_Wzw2?Yk z#M$o$LX}}&OZ1T6BA~=b0;8u^gKB0)d{!M4)T>S;SV<4N*@!XY(T|D)@eWYlCOZl`B69Vz~==?w@1(&ITJe7izf5ED(&Uox5z1ai7Ip`l6A@1nafD8cku9nWG(vEh0t6+2h1roT!wCEsKCJ!kN=?*+f1s7x6m2YOhjV+4!PnU#+m<33;a7LjcwNO2DE z?)<@#*vAdPf{#A1vm3B|gsC#@JGP}k{if!9O|aCh^F9SB$OLrMjxn??-zd>rieF}o zB~zop?bi)Rt)kA%ZIm_sm59mPa!>O|T5}GtYGEjP?Uz5i=9~*B-W*>zrdT8jh-3z| z-3ZNE5uK)iS$>L4Len@3lcs=RQB2&xDw>Uj8`!d65U4{6{EfRWk?8;ca8tBeJ}ibr zq*&h-rU*2?)BQx^rJo69A^PTB-f{joT7wDp zMh^#nYQ>1!m|6YkIWV3P1gF`U7FXDKt@oq-y#0tSc$3RZ%h*Qy8cD5ApGmJez>m-8 z7!DK#zYA8yU}LIZ6m|t8W=z%ui8Sa_V*$V5P~oQkG(zbW24LwD`pa7dvPszUjLSDT zZUIA<4bgBB!9xT!lidtK*nU=O^t!6)#|rUGurM4h1qtDJuyiZ(SCIS$kvVH?6 zm2(EKYq30|S}Ome`ffP9n4Bcg5QbrwjAQILw>2Xcg-L^%YW!LLkPz))y z9f)uQG|`;lkT*QN-hTT?n%rkZTo( zp@a8_k7ud#sPfA=-9OMXi+On7FtL;YsP!-jsa6Zl{nXoYv8{CplEz~xHY$oBGCtiF zGz7_Hkk3?+s`Q!5^~b?BDA^cXV=>ntS-*1fn2O>A!!y`0xEb$a1Pg;VCJ^%Eu&hI= zRRU`Fe#^-19rU~_7{s%lyz0nmn|?y3Feu(VymK!?ZDiK&8I%$yisCzfyMyfOiMV6> zmMpHQP8O$FimT`_WNCk3NGTH6UMQ5eMlQUoT*lPK$zZIEs3k8VJ4DbhAwlm3s!Ug%GeJdg zA#Ki@u=uj@-3^$tHYAYy^3J^_&9y5YyUnm|g5U_5$luu-D<8jV%Lx_0gwNxHcOPoF zU%9w*Fs$#={p?o{1!LXq4x7Fh)@EuXGTJ_HkzyPvLi~vBh-d^g$ff;bnM)@lOjGik zXRd7r^U=@Wx$+wnRhqJO{@CT0)7|;Hg-xa5GRhRuV@QDk!0O8?7p!C2yqqp!G!MI!`8EOwsRh+9NOPGX!k8C1{F67Gbse>w0)+0 zbeA9i6uTgTBAnY;*jA{ZdZO0B{f^10FF^Hb=ikX#;}Qf5VDvA!OL&8!Ft${{v+c_0 z#?GeMn$?~pMb*-t#A*h;6&R!j3W~O?EdpsiMF1`x-!YTwgUKQvogO6Im=UVPkF~}V z*-Eo(e#t>cB~fg{UeA711SJDe$3fpwIm~h2hf+H~4BRPU_={pI2T?{1Lp%p^OXD;c zso&@;tz>8BY}y|#lOAc1VaBcE{DK|a1XE%&z=#M=^g?lt%P^KqyJ#`HIo|J3?x@9C z>+Qmd*d;9>)u6b>JXXzHzZg{+8a*ZFU)jQHAJyIBP4VZ$k`c#?bk9OlDJGNr!f2Hm zbn})#k`q`RNc;)tv$^>ZA(gA=RiLrlrsUe7W^=GPyf#o+YGeLDSeZKjS1vOOe5WTw z#}$kM%DvbTVcW8WrDJyVd`3rU?^$DBCSE_F5@6IFx=H#Z{(H_LkB}g%Rc^pP*XDg1hNJ`alP?|H4{Q{;8*8wiW4#=oT^JJ2bk;edgfiuu?} zhV2piI#c*j{rOCjyH$FNAs-#GOzt5EgInkX=Q+t#4;6HtaE0vTHzSDkSd-(6IgODJ z56W0JTH?j=$Tq6km}UKZdvl7ZDv4;fU={({=)a4$V$T2Iic7Ej6$VcoqpL{epJ(R2 zxYY11)9=e{${8r65(+?2%dYv-$9>@S8T&(pNK>rCrDoKyJHVRW^uqKM1IuoZyGrlW z>J}^U%qtOn6(~i$Ooy}PR=XGzNEas%Lsz$yRfN)2<`^Ivs3;fwBWEB`m4=r(#!IL^ zDGBe;AFLdI1$~EumF7Ff~F#A6O8x-X0VSR3Mh8s#_Es-&x`hCjv z#sfZ*fl}yXK08HML8a@%Is*`c2dZ$uEME5YRherBPpgBZEh!Ef(1q7QaxO9A#VsCT z4cb_6hqr19Pzq(&7{x`%PNu@S)?vC>YeqVL_Lfdwf&2Fe8+BiZ0V$&B05@co25pPp z3bSP>F9}Dqw@OwVETLM<9C#|tT+;*yf&wrC{ca7xMF)~{YIUI4YqWR3HCjxHYA~Qu zj_?CYCS}T9mah9^maQL|f?BX3)!5T=^t2*FV%9Ini1HmFr^Q%1<$IOORc`2z4<9~| z146&eqCqd)e5tK1<>E?Os?O=CC=j@8Q@H~8T%rK1RS}BcB)*PNTeO<)z=F!I++i+Y zFxAmddUrM87-SEU2#7)Fk!yPxWrD;@z=>u`CD{&wHi?6QQnvYn1w>)_tI}}C3q=92 zF_t=+#sye#VL&>B7=a~h_YxSCHZVrUL!T)cfG-e0y%j%f(g=nTCxhJxlM4XmRV~as z)2i2?#KEkT5;kC0y-d=FZuV$rKLQ&hCW9MY(I!V8|MttcwM#zB~_lDKn# z2b;99S+35(Fa_ZyX@qeB5eP7Gd4l1kiX*!BgvO2TNg6B9J|o^TNLC?`Td1Xv9ADYp zEWL#`37cSy3b7r%B|+$A4UiY6uM7L(C_}~k?>aOu4CMcyI5YdZii}U z+A(wss?jXHWhdvz%|JL#H%|#~bw+aAp;_>PQE|K9KlE@i@*`k|6G9b2j#Vqu0jSE} zR1g)K&_%XlqQj7G8ct$W*=LtF*RT~s7z9nL1=2U7_x+tz?O0s#f%P% z5N54GRYZtR#0&(`N{IzX0^9f0lSU`w)JoQ@xJ3<0ZjTOWz>k$(jKFNM*eWTZHNlEi zyxY#30Cld_6hj=d6vCku0Z?5P6}6X4Hz+Ln2$Bb@B$-D`PD%h^q|nJ~ph+zXE)XOc z_})(LAQwy6XaEvd})|0kg!-5^qMhRh!#z<&KW}zpEN)Ffk6(TZJd<7 zeT!*e5I-c@($Ka)4f4peBn#ZRrc-;ongoo%01E(CN|jhjIq0mdq83~pb69;u0YDl7 z{>ft3>*7dxOdf4Gwij7xNWq;&x~idwr|N(-pgr<}D#~0?e4EgJPLlWFf#ttgmyI z4bUM`%%{`#=xl^ida^@Kw9Aukm;*wn!9RY|VAKXQBUTpgz5X*^J7f$< zGB|OWKmY{*pzwo?rcnWc%XnJV11x#*O)w$~TZN%vMOd*>yrF2Mn$^p@PC>jN~tYB?9Bnfd<8Ow4+59@rxEDDT5B;fR*`nXEViN6XpgKFrL7D?uUrYLnz3dAiY2XVRszvN zgEU=3i*6X;AScv#T~X1jsv{_)kTNA=*M01wfn+k$t))^@MNELmX7f_{E)@v_-)1?2 z^2)bvT+06d!%_{J#**|M%_Hd>_9lwen*e%RtDV6@gKF61d0H!A<;uUREZNaXtY{@N ztyq9BGPDEaEsHQ*9Rq5C6IGYtN>kutz_KpKWLsiF^35RtU2;br7$+*QEA1gX-v z3R{A#6^%ixBH(8|Z=`Bmp~Avg>A~wTApstF3eR;SzhyXFM78^<?xY1s#p7%A8$PHOLyEF_h(ya9MERB(Ss#O4>~n2BC{m>YOOi$3Pw= zTdfZ8IM9AVD@wFfOUjzKD$l6%?FUJFf~vf0@3unxHrx|IQI|Q30}Nh-TU>0U7kY^3 zAeRUN1O{vysG+j;crrAfoUj}Vj<2u&BQ$e@6GRajj`)cEdZSiCB|#*)SK@$H4)G;u zL1i!>9fC@*2};NzO<=aV#4~6WvX)@Vfskoy4A3MN%?G_7c&8*eijX10j|7;NBS=C+ z7OZ-tlM7t|x?OymW)nB!lni963r1&PH-!9^Q%!&s?gJ@HfXo5~fl&rZSL;iEl_5f^ z%Tna3N}uP>A zGVO894jFB_A8p5i=$5~R3;-AdL;nCS@C=JFkp$ULX1r>lH zptLuX;mSJ|Rh>1fE7QUnF$}Wit=u$>t}GQgIcA#}(4vTMr~`gt5fal)AnAl1&>hiR z(O}gzW}HYMtlVXuBM@YcQnRYek)7>=7kOjRlr^J4A3Yunt~y`!fK`5rZ{NO+?Nfl^SGgyy-x~&x_ zC@$M+z#Rk;p-d{8K?md>gD6(Ox^3jGO(2-4saqD&u1TiQizFH^Y}*P@vNSbXq+d`P zQBObA%EDqx^qBBTMj54LMm7U=%$FmJfqp@ToF<2zmBeDQPk1beqPEdWRjjdGWv#|X zj(%KahSVkMCLQV%l@9|qR?_O}V8Lt+C0HV^Jt_vHmpxxdh8h%#+<31Nzr3MBgqAiw zNIp|vF*<>3gz5ln^3V8+)CCv8ZwDa|qjU{7dXDBMFhC5iiYS;xprVuTrC|gbVZ0WA zAOPqH1cUfko0?0wvZ_&xVy?QN^3-B4P};eCdBMU7in>2~%d}nZV+Rm204OcG3I~!j zQLM;KwLs?ASHkJ^jt^O$no&c@))hPjE`(raazrozGe>>M4MJL2LCIm3hb>BMQ8X80C1DqI zn+=e1gp4dU3&U~|#T3^oI*g{G+&$JtzC%`Q&v>XsF`XKDohhoypjNmbHk51<#h^d3 z#=Yl9*tgrnS($X-sC#dF8Wl9A7NEGgC zuLwGl$lCH!MCgUcDT*!uhV}yk31lLs&^z}M(z7alALixrxM7>9Q1i3?SF2*_0noFxru^O}Ez&6a!i zjUfmol7zG|TM-u+EE0-kQ<6L4MS+&|wP4v2?A+4T_{0&1Rm1P3zODEg{p%Hs5HWR} zqZ-xMivoc`R;}wXW5E-0stw`+plSw`(F$;|IqWhj^cM60r4vGNW8j8HhYjzrP0`yG zgfBo3NuXyFKCk^6%|EC2!pflrr39F=fw`6n4iE@6Mg|O3f&t=0t;9ejNm6St0)PMy6#y{Mq#>ZyYnxk}@(gnJnL^66IU1`|3fK`2Bu9Fv{vI%6eR0RI5k1_Qq2Fh<;TjK#~)YTaf75ok6eq!24GYpl}i z29i+UJYKUV6dhSbkhFol655DTCk7-o0FFV~bLQi|GgeX?3RilYxJu0^(4%G6wC6j? zW*vD>h)m#XbzU*~a3n${H<3|X&zFbR4II^!=Ye*Oa#iiBy7SO>D zwKuvl@+y>4hn`(`Y3~7MiN0Z!HSl1~_6g`oRxANV4Nyt1VXA7@H*p?0jsjH&849z z0C7cTk)a*p9uRmzLZt9qV?d?OSQ{bjS6n-G4${=Gfm;n?QnN*^30P!R=RKJEdc`qc$WpP zW;JCzLXTyH@#*fGA4k-Tj#C{&K;e&hs09jKh zjo%PL!wr#5*HK9NbSo2RD7RT-XUP<$2`s}-NQfl&9nciz+T<=}if<8L4{}qzmvU z&AKwRFqNt5`2PUkQr}CapgWxfpbwiRC3YjaiYB*pVutaeA_nWSmY%PO`7;uY13g8R z{{X@LsN mg6mdTP)q^726Lh+RnRcg01E+tFaQC%IYmnO2mb)$-~ZXj(j;I2 literal 0 HcmV?d00001 diff --git a/boards/shields/rpi_pico_clock/doc/waveshare_pico_clock_green/hardware.rsti b/boards/shields/rpi_pico_clock/doc/waveshare_pico_clock_green/hardware.rsti new file mode 100644 index 0000000000..5f02eb4dbd --- /dev/null +++ b/boards/shields/rpi_pico_clock/doc/waveshare_pico_clock_green/hardware.rsti @@ -0,0 +1,58 @@ +The `Waveshare Pico Clock Green`_ is a :bbk:`special sized` LED-digit +electronic clock designed for :ref:`zephyr:rpi_pico`, a RP2040 based +development board. It contains a high-precision RTC chip DS3231_ with +an on-chip temperature sensor for ambient, auto-brightness adjustment +by an photoresistor (LDR), alarm signaling by a simple buzzer. a LED +matrix with 8 × 1-bit × 24 pixel for special signing lights and data +display and buttons for navigation and configuration. + +.. list-table:: + :align: center + :width: 100% + :widths: 66, 33 + + * - .. rubric:: Features and Resources + - .. rubric:: Appliance View + + * - :hwftlbl-vdd:`5V/100㎃` + :hwftlbl-vdd:`3.3V/150㎃` + + :hwftlbl-con:`USB-B` + :hwftlbl-bat:`CR2032` + + :hwftlbl-btn:`SET/FUNCTION` + :hwftlbl-btn:`UP` + :hwftlbl-btn:`DOWN` + :hwftlbl-scr:`LED` + + :hwftlbl-pio:`9` + :hwftlbl-adc:`1` + :hwftlbl-i2c:`1` + :hwftlbl-spi:`1` + + .. rst-class:: rst-columns + + - On-board :bbl:`USB-C connector` + - On-board :bbl:`3.3V LDO voltage regulator with 800~1000㎃` + - On-board :bbl:`CR2032 coin battery holder for RTC backup` + - :bbk:`1 serial 8×24 LED matrix` (monochrome) + - :bbk:`1 RTC with temperature sensor` + - :bbk:`1 LDR light sensor` + - :bbk:`3 User keys` + + - :bbk:`3 ADDR signals to LED matrix controller` + - :bbk:`1 LE signal to LED matrix controller` + - :bbk:`1 OE signal to LED matrix controller` + - :bbk:`1 IRQ signal from RTC` + - :bbl:`1 I2C` controller for RTC + - :bbl:`1 SPI` controller for LED matrix controller` + - :bbl:`1 ADC` analog input for LDR light sensor + + .. rubric:: Design Data + .. rst-class:: rst-columns + + - `Waveshare Pico Clock Green Schematic`_ + + - .. image:: /boards/shields/rpi_pico_clock/doc/waveshare_pico_clock_green/hardware.jpg + :align: center + :alt: Waveshare Pico Clock Green diff --git a/boards/shields/rpi_pico_clock/doc/waveshare_pico_clock_green/helloshell.rsti b/boards/shields/rpi_pico_clock/doc/waveshare_pico_clock_green/helloshell.rsti new file mode 100644 index 0000000000..93253dcee5 --- /dev/null +++ b/boards/shields/rpi_pico_clock/doc/waveshare_pico_clock_green/helloshell.rsti @@ -0,0 +1,208 @@ +.. rubric:: Simple test execution on target + +(text in bold is a command input) + +.. tabs:: + + .. group-tab:: Basics + + .. parsed-literal:: + :class: highlight-console notranslate + + :bgn:`uart:~$` **hello -h** + hello - say hello + :bgn:`uart:~$` **hello** + Hello from shell. + + :bgn:`uart:~$` **hwinfo devid** + Length: 8 + ID: 0x8c998be1de969148 + + :bgn:`uart:~$` **kernel version** + Zephyr version |zephyr_version_number_em| + + :bgn:`uart:~$` **bridle version** + Bridle version |version_number_em| + + :bgn:`uart:~$` **bridle version long** + Bridle version |longversion_number_em| + + :bgn:`uart:~$` **bridle info** + Zephyr: |zephyr_release_number_em| + Bridle: |release_number_em| + + :bgn:`uart:~$` **device list** + devices: + - clock-controller\ @\ 40008000 (READY) + - reset-controller\ @\ 4000c000 (READY) + - snippet_cdc_acm_console_uart (READY) + - uart\ @\ 40034000 (READY) + - timer\ @\ 40054000 (READY) + - gpio\ @\ 40014000 (READY) + - adc\ @\ 4004c000 (READY) + - flash-controller\ @\ 18000000 (READY) + - i2c\ @\ 40048000 (READY) + - i2c\ @\ 40044000 (READY) + - pwm\ @\ 40050000 (READY) + - vreg\ @\ 40064000 (READY) + - ds3231-mfd\ @\ 68 (READY) + - ds3231-rtc (READY) + - spi\ @\ 40040000 (READY) + - spi\ @\ 4003c000 (READY) + - sipo-mux-gp\ @\ 0 (READY) + - sipo-mux-gpio\ @\ 7 (READY) + - sipo-mux-gpio\ @\ 6 (READY) + - sipo-mux-gpio\ @\ 5 (READY) + - sipo-mux-gpio\ @\ 4 (READY) + - sipo-mux-gpio\ @\ 3 (READY) + - sipo-mux-gpio\ @\ 2 (READY) + - sipo-mux-gpio\ @\ 1 (READY) + - sipo-mux-gpio\ @\ 0 (READY) + - wpcg-gpio-leds (READY) + - ds3231-dts (READY) + + :bgn:`uart:~$` **history** + [ 0] history + [ 1] device list + [ 2] bridle info + [ 3] bridle version long + [ 4] bridle version + [ 5] kernel version + [ 6] hwinfo devid + [ 7] hello + [ 8] hello -h + + .. group-tab:: Panel LED + + Operate with the first user LED :hwftlbl-led:`SIG0` + on the left side at :rpi-pico-pio:`SIPOMUX-GPIO0:SIG0`: + + .. parsed-literal:: + :class: highlight-console notranslate + + :bgn:`uart:~$` **led on wpcg-gpio-leds 0** + wpcg-gpio-leds: turning on LED 0 + + :bgn:`uart:~$` **led set_brightness wpcg-gpio-leds 0 0** + wpcg-gpio-leds: setting LED 0 brightness to 0 + + :bgn:`uart:~$` **led set_brightness wpcg-gpio-leds 0 50** + wpcg-gpio-leds: setting LED 0 brightness to 50 + + :bgn:`uart:~$` **led off wpcg-gpio-leds 0** + wpcg-gpio-leds: turning off LED 0 + + .. group-tab:: GPIO + + Operate with the first user LED :hwftlbl-led:`SIG0` + on the left side at :rpi-pico-pio:`SIPOMUX-GPIO0:SIG0`: + + .. parsed-literal:: + :class: highlight-console notranslate + + :bgn:`uart:~$` **gpio get sipo-mux-gpio@0 SIG0** + 0 + + :bgn:`uart:~$` **gpio conf sipo-mux-gpio@0 SIG0 oh0** + + :bgn:`uart:~$` **gpio set sipo-mux-gpio@0 SIG0 1** + :bgn:`uart:~$` **gpio set sipo-mux-gpio@0 SIG0 0** + + :bgn:`uart:~$` **gpio blink sipo-mux-gpio@0 SIG0** + Hit any key to exit + + Operate with the user input button :hwftlbl-btn:`SET/FUNCTION` + at :rpi-pico-pio:`GP2`: + + .. parsed-literal:: + :class: highlight-console notranslate + + :bgn:`uart:~$` **gpio get gpio@40014000 SET** + 0 + + :bgn:`uart:~$` **gpio conf gpio@40014000 SET iul** + :bgn:`uart:~$` **gpio get gpio@40014000 SET** + 1 + :bgn:`uart:~$` **gpio get gpio@40014000 SET** + 0 + :bgn:`uart:~$` **gpio get gpio@40014000 SET** + 1 + + .. group-tab:: ADC + + Operate with the on-shield high-resistance LDR :hwftlbl:`Rₗ` + on :rpi-pico-adc:`ADC_CH0`: + + .. parsed-literal:: + :class: highlight-console notranslate + + :bgn:`uart:~$` **adc adc@4004c000 resolution 12** + :bgn:`uart:~$` **adc adc@4004c000 channel id 0** + + :bgn:`uart:~$` **adc adc@4004c000 read 0** + read: 51 + + :bgn:`uart:~$` **adc adc@4004c000 read 0** + read: 883 + + :bgn:`uart:~$` **adc adc@4004c000 read 0** + read: 3147 + + .. group-tab:: I2C + + The |Waveshare Pico Clock Green| has the on-shield RTC connected on I2C1. + + .. parsed-literal:: + :class: highlight-console notranslate + + :bgn:`uart:~$` **i2c scan i2c@40048000** + 0 1 2 3 4 5 6 7 8 9 a b c d e f + 00: -- -- -- -- -- -- -- -- -- -- -- -- + 10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- + 20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- + 30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- + 40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- + 50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- + 60: -- -- -- -- -- -- -- -- 68 -- -- -- -- -- -- -- + 70: -- -- -- -- -- -- -- -- + 1 devices found on i2c\ @\ 40048000 + + The I2C address ``0x68`` is a Maxim / Analog Devices DS3231_ RTC with + integraterd Temperature Sensor and they current temperature can read + from registers ``0x11`` (MSB) and ``0x12`` (LSB). For example, for + 26.25℃ the register content must be ``0x1a`` and ``0x40``: + + .. parsed-literal:: + :class: highlight-console notranslate + + :bgn:`uart:~$` **i2c read_byte i2c@40048000 68 11** + Output: 0x1a + :bgn:`uart:~$` **i2c read_byte i2c@40048000 68 12** + Output: 0x40 + + For example, for 25.75℃ the register content must be ``0x19`` + and ``0xc0``: + + .. parsed-literal:: + :class: highlight-console notranslate + + :bgn:`uart:~$` **i2c read_byte i2c@40048000 68 11** + Output: 0x19 + :bgn:`uart:~$` **i2c read_byte i2c@40048000 68 12** + Output: 0xc0 + + .. group-tab:: RTC + + .. parsed-literal:: + :class: highlight-console notranslate + + :bgn:`uart:~$` **rtc get ds3231-rtc** + 2024-01-04T16:49:47:000000 + + .. group-tab:: Temp + + .. parsed-literal:: + :class: highlight-console notranslate + + :bgn:`uart:~$` **sensor get ds3231-dts** + channel idx=13 ambient_temp shift=5 num_samples=1 value=6848100000ns (25.749999) diff --git a/boards/shields/rpi_pico_clock/doc/waveshare_pico_clock_green/pinouts.jpg b/boards/shields/rpi_pico_clock/doc/waveshare_pico_clock_green/pinouts.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f537699952d5d6d1a9652fefc2aef905e5c6bb23 GIT binary patch literal 183141 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 d>#shHe?{jjI)C-6>7Q1WzoP!PsEZ%5{tqVA>;` + - :devicetree:`shift-width = <32>;` + - :devicetree:`refresh-time-us = <500>;` + - :devicetree:`spi-max-frequency = ;` + + + + .. rubric:: SIPO-MUX-GPIO for row 0 over SIPO-MUX-GP + + |nbsp| + + :devicetree:`sipo_mux_gpio_0: sipo-mux-gpio@0 {};` + + .. rst-class:: rst-columns + + - :devicetree:`compatible = "sipo-mux-gpio";` + - :devicetree:`offset = <0>;` + - :devicetree:`ngpios = <24>;` + + :rpi-pico-pio:`sipo-mux-gpio@0` + + .. rst-class:: rst-columns edge-pinout + + - :hwftlbl:`MOV0` : :rpi-pico-pio:`0` :hwftlbl-led:`led16` + - :hwftlbl:`MOV1` : :rpi-pico-pio:`1` :hwftlbl-led:`led17` + - :hwftlbl:`SIG0` : :rpi-pico-pio:`2` :hwftlbl-led:`led0` + - :hwftlbl:`MON0` : :rpi-pico-pio:`3` :hwftlbl-led:`led2` + - :hwftlbl:`MON1` : :rpi-pico-pio:`4` :hwftlbl-led:`led3` + - :hwftlbl:`SIG1` : :rpi-pico-pio:`5` :hwftlbl-led:`led1` + - :hwftlbl:`TUE0` : :rpi-pico-pio:`6` :hwftlbl-led:`led4` + - :hwftlbl:`TUE1` : :rpi-pico-pio:`7` :hwftlbl-led:`led5` + - | |nbsp| + | :devicetree:`gpio-reserved-ranges = <8 1>;` + | |nbsp| + - :hwftlbl:`WED0` : :rpi-pico-pio:`9` :hwftlbl-led:`led6` + - :hwftlbl:`WED1` : :rpi-pico-pio:`10` :hwftlbl-led:`led7` + - | |nbsp| + | :devicetree:`gpio-reserved-ranges = <11 1>;` + | |nbsp| + - :hwftlbl:`THU0` : :rpi-pico-pio:`12` :hwftlbl-led:`led8` + - :hwftlbl:`THU1` : :rpi-pico-pio:`13` :hwftlbl-led:`led9` + - | |nbsp| + | :devicetree:`gpio-reserved-ranges = <14 1>;` + | |nbsp| + - :hwftlbl:`FRI0` : :rpi-pico-pio:`15` :hwftlbl-led:`led10` + - :hwftlbl:`FRI1` : :rpi-pico-pio:`16` :hwftlbl-led:`led11` + - | |nbsp| + | :devicetree:`gpio-reserved-ranges = <17 1>;` + | |nbsp| + - :hwftlbl:`SAT0` : :rpi-pico-pio:`18` :hwftlbl-led:`led12` + - :hwftlbl:`SAT1` : :rpi-pico-pio:`19` :hwftlbl-led:`led13` + - | |nbsp| + | :devicetree:`gpio-reserved-ranges = <20 1>;` + | |nbsp| + - :hwftlbl:`SUN0` : :rpi-pico-pio:`21` :hwftlbl-led:`led14` + - :hwftlbl:`SUN1` : :rpi-pico-pio:`22` :hwftlbl-led:`led15` + - | |nbsp| + | :devicetree:`gpio-reserved-ranges = <23 1>;` + | |nbsp| + + Access to the two white signaling LED :hwftlbl-led:`Sign 0` and + :hwftlbl-led:`Sign 1` (between the three buttons on left side) and + the double LED tiles :hwftlbl-led:`Move On`, :hwftlbl-led:`Mon.`, + :hwftlbl-led:`Tues.`, :hwftlbl-led:`Wed.`, :hwftlbl-led:`Thur.`, + :hwftlbl-led:`Fri.`, :hwftlbl-led:`Sat.` and :hwftlbl-led:`Sun.` + by LED alias or the following GPIO line names: + + .. container:: twocol + + .. container:: leftside + + .. rst-class:: edge-pinout + + - alias :hwftlbl-led:`led0` is :emphasis:`LED Signal 0` + with GPIO line name :hwftlbl:`SIG0` + - alias :hwftlbl-led:`led1` is :emphasis:`LED Signal 1` + with GPIO line name :hwftlbl:`SIG1` + - alias :hwftlbl-led:`led2` is :emphasis:`LED Monday 0` + with GPIO line name :hwftlbl:`MON0` + - alias :hwftlbl-led:`led3` is :emphasis:`LED Monday 1` + with GPIO line name :hwftlbl:`MON1` + - alias :hwftlbl-led:`led4` is :emphasis:`LED Tuesday 0` + with GPIO line name :hwftlbl:`TUE0` + - alias :hwftlbl-led:`led5` is :emphasis:`LED Tuesday 1` + with GPIO line name :hwftlbl:`TUE1` + - alias :hwftlbl-led:`led6` is :emphasis:`LED Wednesday 0` + with GPIO line name :hwftlbl:`WED0` + - alias :hwftlbl-led:`led7` is :emphasis:`LED Wednesday 1` + with GPIO line name :hwftlbl:`WED1` + - alias :hwftlbl-led:`led8` is :emphasis:`LED Thursday 0` + with GPIO line name :hwftlbl:`THU0` + + .. container:: rightside + + .. rst-class:: edge-pinout + + - alias :hwftlbl-led:`led9` is :emphasis:`LED Thursday 1` + with GPIO line name :hwftlbl:`THU1` + - alias :hwftlbl-led:`led10` is :emphasis:`LED Friday 0` + with GPIO line name :hwftlbl:`FRI0` + - alias :hwftlbl-led:`led11` is :emphasis:`LED Friday 1` + with GPIO line name :hwftlbl:`FRI1` + - alias :hwftlbl-led:`led12` is :emphasis:`LED Saturday 0` + with GPIO line name :hwftlbl:`SAT0` + - alias :hwftlbl-led:`led13` is :emphasis:`LED Saturday 1` + with GPIO line name :hwftlbl:`SAT1` + - alias :hwftlbl-led:`led14` is :emphasis:`LED Sunday 0` + with GPIO line name :hwftlbl:`SUN0` + - alias :hwftlbl-led:`led15` is :emphasis:`LED Sunday 1` + with GPIO line name :hwftlbl:`SUN1` + - alias :hwftlbl-led:`led16` is :emphasis:`LED Move On 0` + with GPIO line name :hwftlbl:`MOV0` + - alias :hwftlbl-led:`led17` is :emphasis:`LED Move On 1` + with GPIO line name :hwftlbl:`MOV1` + + + + + .. rubric:: SIPO-MUX-GPIO for row 1 over SIPO-MUX-GP + + |nbsp| + + :devicetree:`sipo_mux_gpio_1: sipo-mux-gpio@1 {};` + + .. rst-class:: rst-columns + + - :devicetree:`compatible = "sipo-mux-gpio";` + - :devicetree:`offset = <24>;` + - :devicetree:`ngpios = <24>;` + + :rpi-pico-pio:`sipo-mux-gpio@1` + + .. rst-class:: rst-columns edge-pinout + + - :hwftlbl:`ALM0` : :rpi-pico-pio:`0` :hwftlbl-led:`led18` + - :hwftlbl:`ALM1` : :rpi-pico-pio:`1` :hwftlbl-led:`led19` + - :hwftlbl:`L102` : :rpi-pico-pio:`2` + :hwftlbl-scr:`LED` : (0,0) + - :hwftlbl:`L103` : :rpi-pico-pio:`3` + :hwftlbl-scr:`LED` : (1,0) + - :hwftlbl:`L104` : :rpi-pico-pio:`4` + :hwftlbl-scr:`LED` : (2,0) + - :hwftlbl:`L105` : :rpi-pico-pio:`5` + :hwftlbl-scr:`LED` : (3,0) + - :hwftlbl:`L106` : :rpi-pico-pio:`6` + :hwftlbl-scr:`LED` : (4,0) + - :hwftlbl:`L107` : :rpi-pico-pio:`7` + :hwftlbl-scr:`LED` : (5,0) + - :hwftlbl:`L108` : :rpi-pico-pio:`8` + :hwftlbl-scr:`LED` : (6,0) + - :hwftlbl:`L109` : :rpi-pico-pio:`9` + :hwftlbl-scr:`LED` : (7,0) + - :hwftlbl:`L110` : :rpi-pico-pio:`10` + :hwftlbl-scr:`LED` : (8,0) + - :hwftlbl:`L111` : :rpi-pico-pio:`11` + :hwftlbl-scr:`LED` : (9,0) + - :hwftlbl:`L112` : :rpi-pico-pio:`12` + :hwftlbl-scr:`LED` : (10,0) + - :hwftlbl:`L113` : :rpi-pico-pio:`13` + :hwftlbl-scr:`LED` : (11,0) + - :hwftlbl:`L114` : :rpi-pico-pio:`14` + :hwftlbl-scr:`LED` : (12,0) + - :hwftlbl:`L115` : :rpi-pico-pio:`15` + :hwftlbl-scr:`LED` : (13,0) + - :hwftlbl:`L116` : :rpi-pico-pio:`16` + :hwftlbl-scr:`LED` : (14,0) + - :hwftlbl:`L117` : :rpi-pico-pio:`17` + :hwftlbl-scr:`LED` : (15,0) + - :hwftlbl:`L118` : :rpi-pico-pio:`18` + :hwftlbl-scr:`LED` : (16,0) + - :hwftlbl:`L119` : :rpi-pico-pio:`19` + :hwftlbl-scr:`LED` : (17,0) + - :hwftlbl:`L120` : :rpi-pico-pio:`20` + :hwftlbl-scr:`LED` : (18,0) + - :hwftlbl:`L121` : :rpi-pico-pio:`21` + :hwftlbl-scr:`LED` : (19,0) + - :hwftlbl:`L222` : :rpi-pico-pio:`22` + :hwftlbl-scr:`LED` : (20,0) + - :hwftlbl:`L123` : :rpi-pico-pio:`23` + :hwftlbl-scr:`LED` : (21,0) + + Access to the double LED tile :hwftlbl-led:`Alarm On` by LED alias + or the following GPIO line names: + + .. rst-class:: edge-pinout + + - alias :hwftlbl-led:`led18` is :emphasis:`LED Alarm On 0` with + GPIO line name :hwftlbl:`ALM0` + - alias :hwftlbl-led:`led19` is :emphasis:`LED Alarm On 1` with + GPIO line name :hwftlbl:`ALM1` + + .. rubric:: SIPO-MUX-GPIO for row 2 over SIPO-MUX-GP + + |nbsp| + + :devicetree:`sipo_mux_gpio_2: sipo-mux-gpio@2 {};` + + .. rst-class:: rst-columns + + - :devicetree:`compatible = "sipo-mux-gpio";` + - :devicetree:`offset = <48>;` + - :devicetree:`ngpios = <24>;` + + :rpi-pico-pio:`sipo-mux-gpio@2` + + .. rst-class:: rst-columns edge-pinout + + - :hwftlbl:`CDN0` : :rpi-pico-pio:`0` :hwftlbl-led:`led20` + - :hwftlbl:`CDN1` : :rpi-pico-pio:`1` :hwftlbl-led:`led21` + - :hwftlbl:`L202` : :rpi-pico-pio:`2` + :hwftlbl-scr:`LED` : (0,1) + - :hwftlbl:`L203` : :rpi-pico-pio:`3` + :hwftlbl-scr:`LED` : (1,1) + - :hwftlbl:`L204` : :rpi-pico-pio:`4` + :hwftlbl-scr:`LED` : (2,1) + - :hwftlbl:`L205` : :rpi-pico-pio:`5` + :hwftlbl-scr:`LED` : (3,1) + - :hwftlbl:`L206` : :rpi-pico-pio:`6` + :hwftlbl-scr:`LED` : (4,1) + - :hwftlbl:`L207` : :rpi-pico-pio:`7` + :hwftlbl-scr:`LED` : (5,1) + - :hwftlbl:`L208` : :rpi-pico-pio:`8` + :hwftlbl-scr:`LED` : (6,1) + - :hwftlbl:`L209` : :rpi-pico-pio:`9` + :hwftlbl-scr:`LED` : (7,1) + - :hwftlbl:`L210` : :rpi-pico-pio:`10` + :hwftlbl-scr:`LED` : (8,1) + - :hwftlbl:`L211` : :rpi-pico-pio:`11` + :hwftlbl-scr:`LED` : (9,1) + - :hwftlbl:`L212` : :rpi-pico-pio:`12` + :hwftlbl-scr:`LED` : (10,1) + - :hwftlbl:`L213` : :rpi-pico-pio:`13` + :hwftlbl-scr:`LED` : (11,1) + - :hwftlbl:`L214` : :rpi-pico-pio:`14` + :hwftlbl-scr:`LED` : (12,1) + - :hwftlbl:`L215` : :rpi-pico-pio:`15` + :hwftlbl-scr:`LED` : (13,1) + - :hwftlbl:`L216` : :rpi-pico-pio:`16` + :hwftlbl-scr:`LED` : (14,1) + - :hwftlbl:`L217` : :rpi-pico-pio:`17` + :hwftlbl-scr:`LED` : (15,1) + - :hwftlbl:`L218` : :rpi-pico-pio:`18` + :hwftlbl-scr:`LED` : (16,1) + - :hwftlbl:`L219` : :rpi-pico-pio:`19` + :hwftlbl-scr:`LED` : (17,1) + - :hwftlbl:`L220` : :rpi-pico-pio:`20` + :hwftlbl-scr:`LED` : (18,1) + - :hwftlbl:`L221` : :rpi-pico-pio:`21` + :hwftlbl-scr:`LED` : (19,1) + - :hwftlbl:`L222` : :rpi-pico-pio:`22` + :hwftlbl-scr:`LED` : (20,1) + - :hwftlbl:`L223` : :rpi-pico-pio:`23` + :hwftlbl-scr:`LED` : (21,1) + + Access to the double LED tile :hwftlbl-led:`CountDown` by LED alias + or the following GPIO line names: + + .. rst-class:: edge-pinout + + - alias :hwftlbl-led:`led20` is :emphasis:`LED Count Down 0` with + GPIO line name :hwftlbl:`CDN0` + - alias :hwftlbl-led:`led21` is :emphasis:`LED Count Down 1` with + GPIO line name :hwftlbl:`CDN1` + + .. rubric:: SIPO-MUX-GPIO for row 3 over SIPO-MUX-GP + + |nbsp| + + :devicetree:`sipo_mux_gpio_3: sipo-mux-gpio@3 {};` + + .. rst-class:: rst-columns + + - :devicetree:`compatible = "sipo-mux-gpio";` + - :devicetree:`offset = <72>;` + - :devicetree:`ngpios = <24>;` + + :rpi-pico-pio:`sipo-mux-gpio@3` + + .. rst-class:: rst-columns edge-pinout + + - :hwftlbl:`DEGF` : :rpi-pico-pio:`0` :hwftlbl-led:`led22` + - :hwftlbl:`DEGC` : :rpi-pico-pio:`1` :hwftlbl-led:`led23` + - :hwftlbl:`L302` : :rpi-pico-pio:`2` + :hwftlbl-scr:`LED` : (0,2) + - :hwftlbl:`L303` : :rpi-pico-pio:`3` + :hwftlbl-scr:`LED` : (1,2) + - :hwftlbl:`L304` : :rpi-pico-pio:`4` + :hwftlbl-scr:`LED` : (2,2) + - :hwftlbl:`L305` : :rpi-pico-pio:`5` + :hwftlbl-scr:`LED` : (3,2) + - :hwftlbl:`L306` : :rpi-pico-pio:`6` + :hwftlbl-scr:`LED` : (4,2) + - :hwftlbl:`L307` : :rpi-pico-pio:`7` + :hwftlbl-scr:`LED` : (5,2) + - :hwftlbl:`L308` : :rpi-pico-pio:`8` + :hwftlbl-scr:`LED` : (6,2) + - :hwftlbl:`L309` : :rpi-pico-pio:`9` + :hwftlbl-scr:`LED` : (7,2) + - :hwftlbl:`L310` : :rpi-pico-pio:`10` + :hwftlbl-scr:`LED` : (8,2) + - :hwftlbl:`L311` : :rpi-pico-pio:`11` + :hwftlbl-scr:`LED` : (9,2) + - :hwftlbl:`L312` : :rpi-pico-pio:`12` + :hwftlbl-scr:`LED` : (10,2) + - :hwftlbl:`L313` : :rpi-pico-pio:`13` + :hwftlbl-scr:`LED` : (11,2) + - :hwftlbl:`L314` : :rpi-pico-pio:`14` + :hwftlbl-scr:`LED` : (12,2) + - :hwftlbl:`L315` : :rpi-pico-pio:`15` + :hwftlbl-scr:`LED` : (13,2) + - :hwftlbl:`L316` : :rpi-pico-pio:`16` + :hwftlbl-scr:`LED` : (14,2) + - :hwftlbl:`L317` : :rpi-pico-pio:`17` + :hwftlbl-scr:`LED` : (15,2) + - :hwftlbl:`L318` : :rpi-pico-pio:`18` + :hwftlbl-scr:`LED` : (16,2) + - :hwftlbl:`L319` : :rpi-pico-pio:`19` + :hwftlbl-scr:`LED` : (17,2) + - :hwftlbl:`L320` : :rpi-pico-pio:`20` + :hwftlbl-scr:`LED` : (18,2) + - :hwftlbl:`L321` : :rpi-pico-pio:`21` + :hwftlbl-scr:`LED` : (19,2) + - :hwftlbl:`L322` : :rpi-pico-pio:`22` + :hwftlbl-scr:`LED` : (20,2) + - :hwftlbl:`L323` : :rpi-pico-pio:`23` + :hwftlbl-scr:`LED` : (21,2) + + Access to the single LED tiles :hwftlbl-led:`℉` and :hwftlbl-led:`℃` + by LED alias or the following GPIO line names: + + .. rst-class:: edge-pinout + + - alias :hwftlbl-led:`led22` is :emphasis:`LED Degrees Fahrenheit` + with GPIO line name :hwftlbl:`DEGF` + - alias :hwftlbl-led:`led23` is :emphasis:`LED Degrees Celsius` + with GPIO line name :hwftlbl:`DEGC` + + .. rubric:: SIPO-MUX-GPIO for row 4 over SIPO-MUX-GP + + |nbsp| + + :devicetree:`sipo_mux_gpio_4: sipo-mux-gpio@4 {};` + + .. rst-class:: rst-columns + + - :devicetree:`compatible = "sipo-mux-gpio";` + - :devicetree:`offset = <96>;` + - :devicetree:`ngpios = <24>;` + + :rpi-pico-pio:`sipo-mux-gpio@4` + + .. rst-class:: rst-columns edge-pinout + + - :hwftlbl:`TMAM` : :rpi-pico-pio:`0` :hwftlbl-led:`led24` + - :hwftlbl:`TMPM` : :rpi-pico-pio:`1` :hwftlbl-led:`led25` + - :hwftlbl:`L402` : :rpi-pico-pio:`2` + :hwftlbl-scr:`LED` : (0,3) + - :hwftlbl:`L403` : :rpi-pico-pio:`3` + :hwftlbl-scr:`LED` : (1,3) + - :hwftlbl:`L404` : :rpi-pico-pio:`4` + :hwftlbl-scr:`LED` : (2,3) + - :hwftlbl:`L405` : :rpi-pico-pio:`5` + :hwftlbl-scr:`LED` : (3,3) + - :hwftlbl:`L406` : :rpi-pico-pio:`6` + :hwftlbl-scr:`LED` : (4,3) + - :hwftlbl:`L407` : :rpi-pico-pio:`7` + :hwftlbl-scr:`LED` : (5,3) + - :hwftlbl:`L408` : :rpi-pico-pio:`8` + :hwftlbl-scr:`LED` : (6,3) + - :hwftlbl:`L409` : :rpi-pico-pio:`9` + :hwftlbl-scr:`LED` : (7,3) + - :hwftlbl:`L410` : :rpi-pico-pio:`10` + :hwftlbl-scr:`LED` : (8,3) + - :hwftlbl:`L411` : :rpi-pico-pio:`11` + :hwftlbl-scr:`LED` : (9,3) + - :hwftlbl:`L412` : :rpi-pico-pio:`12` + :hwftlbl-scr:`LED` : (10,3) + - :hwftlbl:`L413` : :rpi-pico-pio:`13` + :hwftlbl-scr:`LED` : (11,3) + - :hwftlbl:`L414` : :rpi-pico-pio:`14` + :hwftlbl-scr:`LED` : (12,3) + - :hwftlbl:`L415` : :rpi-pico-pio:`15` + :hwftlbl-scr:`LED` : (13,3) + - :hwftlbl:`L416` : :rpi-pico-pio:`16` + :hwftlbl-scr:`LED` : (14,3) + - :hwftlbl:`L417` : :rpi-pico-pio:`17` + :hwftlbl-scr:`LED` : (15,3) + - :hwftlbl:`L418` : :rpi-pico-pio:`18` + :hwftlbl-scr:`LED` : (16,3) + - :hwftlbl:`L419` : :rpi-pico-pio:`19` + :hwftlbl-scr:`LED` : (17,3) + - :hwftlbl:`L420` : :rpi-pico-pio:`20` + :hwftlbl-scr:`LED` : (18,3) + - :hwftlbl:`L421` : :rpi-pico-pio:`21` + :hwftlbl-scr:`LED` : (19,3) + - :hwftlbl:`L422` : :rpi-pico-pio:`22` + :hwftlbl-scr:`LED` : (20,3) + - :hwftlbl:`L423` : :rpi-pico-pio:`23` + :hwftlbl-scr:`LED` : (21,3) + + Access to the single LED tiles :hwftlbl-led:`㏂` and :hwftlbl-led:`㏘` + by LED alias or the following GPIO line names: + + .. rst-class:: edge-pinout + + - alias :hwftlbl-led:`led24` is :emphasis:`LED Time AM` with + GPIO line name :hwftlbl:`TMAM` + - alias :hwftlbl-led:`led25` is :emphasis:`LED Time PM` with + GPIO line name :hwftlbl:`TMPM` + + .. rubric:: SIPO-MUX-GPIO for row 5 over SIPO-MUX-GP + + |nbsp| + + :devicetree:`sipo_mux_gpio_5: sipo-mux-gpio@5 {};` + + .. rst-class:: rst-columns + + - :devicetree:`compatible = "sipo-mux-gpio";` + - :devicetree:`offset = <120>;` + - :devicetree:`ngpios = <24>;` + + :rpi-pico-pio:`sipo-mux-gpio@5` + + .. rst-class:: rst-columns edge-pinout + + - :hwftlbl:`CUP0` : :rpi-pico-pio:`0` :hwftlbl-led:`led26` + - :hwftlbl:`CUP1` : :rpi-pico-pio:`1` :hwftlbl-led:`led27` + - :hwftlbl:`L502` : :rpi-pico-pio:`2` + :hwftlbl-scr:`LED` : (0,4) + - :hwftlbl:`L503` : :rpi-pico-pio:`3` + :hwftlbl-scr:`LED` : (1,4) + - :hwftlbl:`L504` : :rpi-pico-pio:`4` + :hwftlbl-scr:`LED` : (2,4) + - :hwftlbl:`L505` : :rpi-pico-pio:`5` + :hwftlbl-scr:`LED` : (3,4) + - :hwftlbl:`L506` : :rpi-pico-pio:`6` + :hwftlbl-scr:`LED` : (4,4) + - :hwftlbl:`L507` : :rpi-pico-pio:`7` + :hwftlbl-scr:`LED` : (5,4) + - :hwftlbl:`L508` : :rpi-pico-pio:`8` + :hwftlbl-scr:`LED` : (6,4) + - :hwftlbl:`L509` : :rpi-pico-pio:`9` + :hwftlbl-scr:`LED` : (7,4) + - :hwftlbl:`L510` : :rpi-pico-pio:`10` + :hwftlbl-scr:`LED` : (8,4) + - :hwftlbl:`L511` : :rpi-pico-pio:`11` + :hwftlbl-scr:`LED` : (9,4) + - :hwftlbl:`L512` : :rpi-pico-pio:`12` + :hwftlbl-scr:`LED` : (10,4) + - :hwftlbl:`L513` : :rpi-pico-pio:`13` + :hwftlbl-scr:`LED` : (11,4) + - :hwftlbl:`L514` : :rpi-pico-pio:`14` + :hwftlbl-scr:`LED` : (12,4) + - :hwftlbl:`L515` : :rpi-pico-pio:`15` + :hwftlbl-scr:`LED` : (13,4) + - :hwftlbl:`L516` : :rpi-pico-pio:`16` + :hwftlbl-scr:`LED` : (14,4) + - :hwftlbl:`L517` : :rpi-pico-pio:`17` + :hwftlbl-scr:`LED` : (15,4) + - :hwftlbl:`L518` : :rpi-pico-pio:`18` + :hwftlbl-scr:`LED` : (16,4) + - :hwftlbl:`L519` : :rpi-pico-pio:`19` + :hwftlbl-scr:`LED` : (17,4) + - :hwftlbl:`L520` : :rpi-pico-pio:`20` + :hwftlbl-scr:`LED` : (18,4) + - :hwftlbl:`L521` : :rpi-pico-pio:`21` + :hwftlbl-scr:`LED` : (19,4) + - :hwftlbl:`L522` : :rpi-pico-pio:`22` + :hwftlbl-scr:`LED` : (20,4) + - :hwftlbl:`L523` : :rpi-pico-pio:`23` + :hwftlbl-scr:`LED` : (21,4) + + Access to the double LED tile :hwftlbl-led:`CountUp` by LED alias + or the following GPIO line names: + + .. rst-class:: edge-pinout + + - alias :hwftlbl-led:`led26` is :emphasis:`LED Count Up 0` with + GPIO line name :hwftlbl:`CUP0` + - alias :hwftlbl-led:`led27` is :emphasis:`LED Count Up 1` with + GPIO line name :hwftlbl:`CUP1` + + .. rubric:: SIPO-MUX-GPIO for row 6 over SIPO-MUX-GP + + |nbsp| + + :devicetree:`sipo_mux_gpio_6: sipo-mux-gpio@6 {};` + + .. rst-class:: rst-columns + + - :devicetree:`compatible = "sipo-mux-gpio";` + - :devicetree:`offset = <144>;` + - :devicetree:`ngpios = <24>;` + + :rpi-pico-pio:`sipo-mux-gpio@6` + + .. rst-class:: rst-columns edge-pinout + + - :hwftlbl:`HLY0` : :rpi-pico-pio:`0` :hwftlbl-led:`led28` + - :hwftlbl:`HLY1` : :rpi-pico-pio:`1` :hwftlbl-led:`led29` + - :hwftlbl:`L602` : :rpi-pico-pio:`2` + :hwftlbl-scr:`LED` : (0,5) + - :hwftlbl:`L603` : :rpi-pico-pio:`3` + :hwftlbl-scr:`LED` : (1,5) + - :hwftlbl:`L604` : :rpi-pico-pio:`4` + :hwftlbl-scr:`LED` : (2,5) + - :hwftlbl:`L605` : :rpi-pico-pio:`5` + :hwftlbl-scr:`LED` : (3,5) + - :hwftlbl:`L606` : :rpi-pico-pio:`6` + :hwftlbl-scr:`LED` : (4,5) + - :hwftlbl:`L607` : :rpi-pico-pio:`7` + :hwftlbl-scr:`LED` : (5,5) + - :hwftlbl:`L608` : :rpi-pico-pio:`8` + :hwftlbl-scr:`LED` : (6,5) + - :hwftlbl:`L609` : :rpi-pico-pio:`9` + :hwftlbl-scr:`LED` : (6,5) + - :hwftlbl:`L610` : :rpi-pico-pio:`10` + :hwftlbl-scr:`LED` : (8,5) + - :hwftlbl:`L611` : :rpi-pico-pio:`11` + :hwftlbl-scr:`LED` : (9,5) + - :hwftlbl:`L612` : :rpi-pico-pio:`12` + :hwftlbl-scr:`LED` : (10,5) + - :hwftlbl:`L613` : :rpi-pico-pio:`13` + :hwftlbl-scr:`LED` : (11,5) + - :hwftlbl:`L614` : :rpi-pico-pio:`14` + :hwftlbl-scr:`LED` : (12,5) + - :hwftlbl:`L615` : :rpi-pico-pio:`15` + :hwftlbl-scr:`LED` : (13,5) + - :hwftlbl:`L616` : :rpi-pico-pio:`16` + :hwftlbl-scr:`LED` : (14,5) + - :hwftlbl:`L616` : :rpi-pico-pio:`16` + :hwftlbl-scr:`LED` : (15,5) + - :hwftlbl:`L618` : :rpi-pico-pio:`18` + :hwftlbl-scr:`LED` : (16,5) + - :hwftlbl:`L619` : :rpi-pico-pio:`19` + :hwftlbl-scr:`LED` : (16,5) + - :hwftlbl:`L620` : :rpi-pico-pio:`20` + :hwftlbl-scr:`LED` : (18,5) + - :hwftlbl:`L621` : :rpi-pico-pio:`21` + :hwftlbl-scr:`LED` : (19,5) + - :hwftlbl:`L622` : :rpi-pico-pio:`22` + :hwftlbl-scr:`LED` : (20,5) + - :hwftlbl:`L623` : :rpi-pico-pio:`23` + :hwftlbl-scr:`LED` : (21,5) + + Access to the double LED tile :hwftlbl-led:`Hourly` by LED alias + or the following GPIO line names: + + .. rst-class:: edge-pinout + + - alias :hwftlbl-led:`led28` is :emphasis:`LED Hourly 0` with + GPIO line name :hwftlbl:`HLY0` + - alias :hwftlbl-led:`led29` is :emphasis:`LED Hourly 1` with + GPIO line name :hwftlbl:`HLY1` + + .. rubric:: SIPO-MUX-GPIO for row 7 over SIPO-MUX-GP + + |nbsp| + + :devicetree:`sipo_mux_gpio_7: sipo-mux-gpio@7 {};` + + .. rst-class:: rst-columns + + - :devicetree:`compatible = "sipo-mux-gpio";` + - :devicetree:`offset = <168>;` + - :devicetree:`ngpios = <24>;` + + :rpi-pico-pio:`sipo-mux-gpio@7` + + .. rst-class:: rst-columns edge-pinout + + - :hwftlbl:`AUT0` : :rpi-pico-pio:`0` :hwftlbl-led:`led30` + - :hwftlbl:`AUT1` : :rpi-pico-pio:`1` :hwftlbl-led:`led31` + - :hwftlbl:`L702` : :rpi-pico-pio:`2` + :hwftlbl-scr:`LED` : (0,6) + - :hwftlbl:`L703` : :rpi-pico-pio:`3` + :hwftlbl-scr:`LED` : (1,6) + - :hwftlbl:`L704` : :rpi-pico-pio:`4` + :hwftlbl-scr:`LED` : (2,6) + - :hwftlbl:`L705` : :rpi-pico-pio:`5` + :hwftlbl-scr:`LED` : (3,6) + - :hwftlbl:`L706` : :rpi-pico-pio:`6` + :hwftlbl-scr:`LED` : (4,6) + - :hwftlbl:`L707` : :rpi-pico-pio:`7` + :hwftlbl-scr:`LED` : (5,6) + - :hwftlbl:`L708` : :rpi-pico-pio:`8` + :hwftlbl-scr:`LED` : (6,6) + - :hwftlbl:`L709` : :rpi-pico-pio:`9` + :hwftlbl-scr:`LED` : (7,6) + - :hwftlbl:`L710` : :rpi-pico-pio:`10` + :hwftlbl-scr:`LED` : (8,6) + - :hwftlbl:`L711` : :rpi-pico-pio:`11` + :hwftlbl-scr:`LED` : (9,6) + - :hwftlbl:`L712` : :rpi-pico-pio:`12` + :hwftlbl-scr:`LED` : (10,6) + - :hwftlbl:`L713` : :rpi-pico-pio:`13` + :hwftlbl-scr:`LED` : (11,6) + - :hwftlbl:`L714` : :rpi-pico-pio:`14` + :hwftlbl-scr:`LED` : (12,6) + - :hwftlbl:`L715` : :rpi-pico-pio:`15` + :hwftlbl-scr:`LED` : (13,6) + - :hwftlbl:`L716` : :rpi-pico-pio:`16` + :hwftlbl-scr:`LED` : (14,6) + - :hwftlbl:`L717` : :rpi-pico-pio:`17` + :hwftlbl-scr:`LED` : (15,6) + - :hwftlbl:`L718` : :rpi-pico-pio:`18` + :hwftlbl-scr:`LED` : (16,6) + - :hwftlbl:`L719` : :rpi-pico-pio:`19` + :hwftlbl-scr:`LED` : (17,6) + - :hwftlbl:`L720` : :rpi-pico-pio:`20` + :hwftlbl-scr:`LED` : (18,6) + - :hwftlbl:`L721` : :rpi-pico-pio:`21` + :hwftlbl-scr:`LED` : (19,6) + - :hwftlbl:`L722` : :rpi-pico-pio:`22` + :hwftlbl-scr:`LED` : (20,6) + - :hwftlbl:`L723` : :rpi-pico-pio:`23` + :hwftlbl-scr:`LED` : (21,6) + + Access to the double LED tile :hwftlbl-led:`AutoLight` by LED alias + or the following GPIO line names: + + .. rst-class:: edge-pinout + + - alias :hwftlbl-led:`led30` is :emphasis:`LED Auto Light 0` with + GPIO line name :hwftlbl:`AUT0` + - alias :hwftlbl-led:`led31` is :emphasis:`LED Auto Light 1` with + GPIO line name :hwftlbl:`AUT1` + + .. rubric:: SIPO-MUX-DISPLAY over SIPO-MUX-GP + + |nbsp| + + With an x,y-offset of 2,1 the display provides 7 pixel in height (Y) + and 22 pixel in width (X). + + |nbsp| + + :devicetree:`sipo_mux_display_8: sipo-mux-display@8 {};` + + .. rst-class:: rst-columns + + - :devicetree:`compatible = "sipo-mux-display";` + - :devicetree:`offset = <2 1>;` + - :devicetree:`height = <7>;` + - :devicetree:`width = <22>;` + + .. rubric:: Devicetree compatible + + - :dtcompatible:`sipo-mux-gp-spi` + (:dtcompatible:`sipo-mux-gpio`, :dtcompatible:`sipo-mux-display`) + - :dtcompatible:`gpio-leds` diff --git a/boards/shields/rpi_pico_clock/doc/waveshare_pico_clock_green/positions.jpg b/boards/shields/rpi_pico_clock/doc/waveshare_pico_clock_green/positions.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b294a25bdfdc26e8cb3eea33b2e65cf0ef53e874 GIT binary patch literal 89217 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 K>n7g#b>N>6i$|US literal 0 HcmV?d00001 diff --git a/boards/shields/rpi_pico_clock/doc/waveshare_pico_clock_green/positions.rsti b/boards/shields/rpi_pico_clock/doc/waveshare_pico_clock_green/positions.rsti new file mode 100644 index 0000000000..9357473ff7 --- /dev/null +++ b/boards/shields/rpi_pico_clock/doc/waveshare_pico_clock_green/positions.rsti @@ -0,0 +1,78 @@ +.. list-table:: + :align: center + :width: 66% + :header-rows: 1 + + * - .. image:: /boards/shields/rpi_pico_clock/doc/waveshare_pico_clock_green/positions.jpg + :align: center + :width: 500 + :alt: Waveshare Pico Clock Green details + + * - .. container:: twocol + + .. container:: leftside + + 1. | :strong:`User buttons` + | momentary push buttons + | SET/FUNCTION (ENTER), UP, DOWN + #. | :strong:`LED matrix` + | 8×24 1-bit monochrome pixel driven by discrete logic with: + | 2×16-bit serial-in-parallel-out (SIPO) shift register + | 1×3-to-8 address decoder (MUX) + #. | :strong:`LDR (CdS)` + | Cadmium Sulfide (CdS) photoresistor (LDR) with: + | about 2~20㏀ on light and ≫1㏁ on darkness + #. | :strong:`USB Type-B connector` + | Supports USB1.1 hosts and slave devices + #. | :strong:`XC6206P332MR` + | 200㎃ low dropout, low quiescent current + | 3.3V power supply for RTC + #. | :strong:`AMS1117-3.3` + | 1A low dropout, high efficiency linear regulators LDO + | 3.3V power supply for LED matrix + + .. container:: rightside + + 7. | :strong:`Piezo Buzzer` + | 5.0Vo-p (3.0~8.0V) @ 2.400㎑±300㎐ with ≥85㏈ + #. | :strong:`SM16106SC/SM5166P` + | SIPO-MUX-GP (General Purpose) matrix controller (discrete logic) + | 2×16-bit SIPO 16-channel LED constant current driver + | 1×3-to-8 MUX 8-channel LED output current drive + #. | :strong:`CR2032` + | 3.0V @ 235㎃h coin battery holder, backup power supply for RTC + #. | :strong:`DS3231` + | Real-Time-Clock (RTC), extremely high accuracy, with: + | temperature-compensated crystal oscillator (TCXO) and crystal, + | battery input for backup on power lost, accurate timekeeping, + | ±3.5㏙ accuracy from -40℃ to +85℃, ±2㏙ from 0℃ to +40℃ + | 2× time-of-day alarms, valid up to 2100, square-wave output, + | 1× digital temp. sensor with ¼℃ resolution and ±3℃ accuracy + +.. rubric:: Data Sheets +.. rst-class:: rst-columns + +- .. rubric:: `SM16106SC `_/`TLC5925`_ +- `SM16106 Datasheet (CN) V1.1`_ +- `TLC5925 Datasheet`_ +- .. rubric:: `SM5166P `_ +- `SM5166 Datasheet (CN) V1.2`_ +- `SM5166 Datasheet (CN) V1.1`_ +- .. rubric:: DS3231_ +- `DS3231 Datasheet`_ +- .. rubric:: `XC6206P332MR `_ +- `XC6206 Datasheet`_ +- .. rubric:: `AMS1117-3.3 `_ +- `AMS1117 Datasheet`_ +- .. rubric:: `TMB12A05`_ +- `TMB12Axx Datasheet`_ +- `TMB12A05 Specification (2021)`_ +- .. rubric:: `YX-YT12095/TMB12A`_ +- `YX-YT12095/TMB12A Specification (2020)`_ +- `YX-YT12095/TMB12A Specification (2016)`_ +- .. rubric:: `PGM5`_ +- `PGM5 Datasheet`_ +- .. rubric:: `GL55/GL56 (φ5)`_ +- `GL55/GL56 (φ5) Datasheet`_ +- `GL55/GL56 (φ5) Datasheet (CN)`_ +- `Senba Optoelectronic – LDR Sensors`_ diff --git a/boards/shields/rpi_pico_clock/doc/waveshare_pico_clock_green/sipomuxgp-spi.svg b/boards/shields/rpi_pico_clock/doc/waveshare_pico_clock_green/sipomuxgp-spi.svg new file mode 100644 index 0000000000..9e363831e1 --- /dev/null +++ b/boards/shields/rpi_pico_clock/doc/waveshare_pico_clock_green/sipomuxgp-spi.svg @@ -0,0 +1 @@ + diff --git a/boards/shields/rpi_pico_clock/waveshare_pico_clock_green.overlay b/boards/shields/rpi_pico_clock/waveshare_pico_clock_green.overlay new file mode 100644 index 0000000000..6644dcc605 --- /dev/null +++ b/boards/shields/rpi_pico_clock/waveshare_pico_clock_green.overlay @@ -0,0 +1,215 @@ +/* + * Copyright (c) 2023-2024 TiaC Systems + * SPDX-License-Identifier: Apache-2.0 + */ + +#include +#include + +/ { + chosen { + zephyr,display = &clock_display; + }; + + wpcg_lvgl_keypad: wpcg-lvgl-keypad { + compatible = "zephyr,lvgl-keypad-input"; + status = "okay"; + + input = <&wpcg_gpio_keys>; + input-codes = ; + lvgl-codes = ; + }; + + /delete-node/ keys; + /delete-node/ gpio_keys; + wpcg_gpio_keys: wpcg-gpio-keys { + compatible = "gpio-keys"; + status = "okay"; + + clock_btn_set_function: clock-btn-set-function { + label = "Button SET/FUNCTION"; + zephyr,code = ; + }; + clock_btn_up: clock-btn-up { + label = "Button UP"; + zephyr,code = ; + }; + clock_btn_down: clock-btn-down { + label = "Button DOWN"; + zephyr,code = ; + }; + }; + + /delete-node/ leds; + /delete-node/ gpio_leds; + wpcg_gpio_leds: wpcg-gpio-leds { + compatible = "gpio-leds"; + status = "okay"; + + clock_led_signal_0: clock-led-signal-0 { + label = "LED Signal 0"; + }; + clock_led_signal_1: clock-led-signal-1 { + label = "LED Signal 1"; + }; + + clock_led_monday_0: clock-led-monday-0 { + label = "LED Monday 0"; + }; + clock_led_monday_1: clock-led-monday-1 { + label = "LED Monday 1"; + }; + + clock_led_tuesday_0: clock-led-tuesday-0 { + label = "LED Tuesday 0"; + }; + clock_led_tuesday_1: clock-led-tuesday-1 { + label = "LED Tuesday 1"; + }; + + clock_led_wednesday_0: clock-led-wednesday-0 { + label = "LED Wednesday 0"; + }; + clock_led_wednesday_1: clock-led-wednesday-1 { + label = "LED Wednesday 1"; + }; + + clock_led_thursday_0: clock-led-thursday-0 { + label = "LED Thursday 0"; + }; + clock_led_thursday_1: clock-led-thursday-1 { + label = "LED Thursday 1"; + }; + + clock_led_friday_0: clock-led-friday-0 { + label = "LED Friday 0"; + }; + clock_led_friday_1: clock-led-friday-1 { + label = "LED Friday 1"; + }; + + clock_led_saturday_0: clock-led-saturday-0 { + label = "LED Saturday 0"; + }; + clock_led_saturday_1: clock-led-saturday-1 { + label = "LED Saturday 1"; + }; + + clock_led_sunday_0: clock-led-sunday-0 { + label = "LED Sunday 0"; + }; + clock_led_sunday_1: clock-led-sunday-1 { + label = "LED Sunday 1"; + }; + + clock_led_move_on_0: clock-led-move-on-0 { + label = "LED Move On 0"; + }; + clock_led_move_on_1: clock-led-move-on-1 { + label = "LED Move On 1"; + }; + + clock_led_alarm_on_0: clock-led-alarm-on-0 { + label = "LED Alarm On 0"; + }; + clock_led_alarm_on_1: clock-led-alarm-on-1 { + label = "LED Alarm On 1"; + }; + + clock_led_count_down_0: clock-led-count-down-0 { + label = "LED Count Down 0"; + }; + clock_led_count_down_1: clock-led-count-down-1 { + label = "LED Count Down 1"; + }; + + clock_led_degrees_fahrenheit: clock-led-degrees-fahrenheit { + label = "LED Degrees Fahrenheit"; + }; + clock_led_degrees_celsius: clock-led-degrees-celsius { + label = "LED Degrees Celsius"; + }; + + clock_led_time_am: clock-led-time-am { + label = "LED Time AM"; + }; + clock_led_time_pm: clock-led-time-pm { + label = "LED Time PM"; + }; + + clock_led_count_up_0: clock-led-count-up-0 { + label = "LED Count Up 0"; + }; + clock_led_count_up_1: clock-led-count-up-1 { + label = "LED Count Up 1"; + }; + + clock_led_hourly_0: clock-led-hourly-0 { + label = "LED Hourly 0"; + }; + clock_led_hourly_1: clock-led-hourly-1 { + label = "LED Hourly 1"; + }; + + clock_led_auto_light_0: clock-led-auto-light-0 { + label = "LED Auto Light 0"; + }; + clock_led_auto_light_1: clock-led-auto-light-1 { + label = "LED Auto Light 1"; + }; + }; + + wpcg_pwm_buzzers: wpcg-pwm-buzzers { + compatible = "pwm-buzzers"; + status = "okay"; + + clock_buzzer: clock-buzzer { + label = "BUZZER"; + }; + }; + + /delete-node/ pwm_leds; + aliases { + /delete-property/ sw0; + sw0 = &clock_btn_set_function; + sw1 = &clock_btn_up; + sw2 = &clock_btn_down; + /delete-property/ led0; + led0 = &clock_led_signal_0; + led1 = &clock_led_signal_1; + led2 = &clock_led_monday_0; + led3 = &clock_led_monday_1; + led4 = &clock_led_tuesday_0; + led5 = &clock_led_tuesday_1; + led6 = &clock_led_wednesday_0; + led7 = &clock_led_wednesday_1; + led8 = &clock_led_thursday_0; + led9 = &clock_led_thursday_1; + led10 = &clock_led_friday_0; + led11 = &clock_led_friday_1; + led12 = &clock_led_saturday_0; + led13 = &clock_led_saturday_1; + led14 = &clock_led_sunday_0; + led15 = &clock_led_sunday_1; + led16 = &clock_led_move_on_0; + led17 = &clock_led_move_on_1; + led18 = &clock_led_alarm_on_0; + led19 = &clock_led_alarm_on_1; + led20 = &clock_led_count_down_0; + led21 = &clock_led_count_down_1; + led22 = &clock_led_degrees_fahrenheit; + led23 = &clock_led_degrees_celsius; + led24 = &clock_led_time_am; + led25 = &clock_led_time_pm; + led26 = &clock_led_count_up_0; + led27 = &clock_led_count_up_1; + led28 = &clock_led_hourly_0; + led29 = &clock_led_hourly_1; + led30 = &clock_led_auto_light_0; + led31 = &clock_led_auto_light_1; + /delete-property/ pwm-led0; + pwm-buzzer0 = &clock_buzzer; + }; +}; diff --git a/doc/bridle/links.txt b/doc/bridle/links.txt index d8b7535211..bac6099544 100644 --- a/doc/bridle/links.txt +++ b/doc/bridle/links.txt @@ -837,6 +837,15 @@ .. _`Waveshare Pico RGB LED Schematic`: https://www.waveshare.com/wiki/Pico-RGB-LED#Document +.. #### Links to the Waveshare Pico Clock Green + +.. _`Waveshare Pico Clock Green`: + https://www.waveshare.com/wiki/Pico-Clock-Green + +.. _`Waveshare Pico Clock Green Schematic`: + https://www.waveshare.com/wiki/Pico-Clock-Green#Document + + .. ### Links to hardware specifications, application notes and similar documents @@ -889,6 +898,25 @@ .. _`KLJ-4020 Datasheet`: https://datasheet.lcsc.com/lcsc/2005191833_KELIKING-KLJ-4020_C556936.pdf +.. _`TMB12A05`: + https://www.jshnbuzzer.com/Product/5VDC-85dB-Mini-Pin-Buzzer.html +.. https://www.jshnbuzzer.com/Product/5VDC-85dB-Mini-Active-Buzzer.html + +.. _`TMB12Axx Datasheet`: + https://www.estudioelectronica.com/wp-content/uploads/2018/09/SHT-TMB12A05.pdf + +.. _`TMB12A05 Specification (2021)`: + https://datasheet.lcsc.com/lcsc/2304261046_Jiangsu-Huaneng-Elec-TMB12A05_C96093.pdf + +.. _`YX-YT12095/TMB12A`: + http://www.xhyxdz.com/product/18_159 + +.. _`YX-YT12095/TMB12A Specification (2020)`: + https://aitendo3.sakura.ne.jp/aitendo_data/product_img/parts/buzzer/TMB12A/TMB12A12.pdf + +.. _`YX-YT12095/TMB12A Specification (2016)`: + https://cdn.ozdisan.com/ETicaret_Dosya/481354_7974359.pdf + .. #### Links to LED or Lamps, either simple or complex with control logic on-chip .. _`WS2812B`: @@ -945,6 +973,12 @@ .. _`Voltage Regulator Handbook (National Semiconductor, 1980)`: https://media.searchelec.com/specshee/NATIONAL/NationalSemiconductorVoltageRegulatorHandbook1980_text.pdf +.. _`AMS1117`: + http://www.advanced-monolithic.com/products/voltreg.html#1117 + +.. _`AMS1117 Datasheet`: + http://www.advanced-monolithic.com/pdf/ds1117.pdf + .. _`BL9366`: https://www-belling-com-cn.translate.goog/product_info.html?id=274&_x_tr_sl=auto&_x_tr_tl=de&_x_tr_hl=de&_x_tr_pto=wapp .. https://www.belling.com.cn/product_info.html?id=274 @@ -1072,6 +1106,80 @@ .. _`TPS63000 Datasheet`: https://www.ti.com/lit/gpn/tps63000 +.. _`XC6206`: + https://product.torexsemi.com/en/series/xc6206 + +.. _`XC6206 Datasheet`: + https://product.torexsemi.com/system/files/series/xc6206.pdf + +.. #### Links to Standard Logic Gates or similar to drive digital logic + +.. _`74HC(T)04`: + https://www.nexperia.com/group/14835 + +.. _`74HC(T)04 Datasheet`: + https://assets.nexperia.com/documents/data-sheet/74HC_HCT04.pdf + +.. _`74HC(T)4040`: + https://www.nexperia.com/group/16078 + +.. _`74HC(T)4040 Datasheet`: + https://assets.nexperia.com/documents/data-sheet/74HC_HCT4040.pdf + +.. _`74HC(T)4094`: + https://www.nexperia.com/group/15196 + +.. _`74HC(T)4094 Datasheet`: + https://assets.nexperia.com/documents/data-sheet/74HC_HCT4094.pdf + +.. _`SM5166`: + http://www.chinaasic.com/chipDetails/detail_450.html + +.. _`SM5166 Datasheet (CN) V1.2`: + http://www.chinaasic.com/websiteManage/product/20230530163724363.pdf + +.. _`SM5166 Datasheet (CN) V1.1`: + https://www.waveshare.com/w/upload/8/8b/Sm5166p.pdf + +.. _`SM16106`: + http://www.chinaasic.com/productItem/product_item_6.html + +.. _`SM16106 Datasheet (CN) V1.1`: + https://www.waveshare.com/w/upload/3/30/SM16106SC.pdf + +.. _`SM16208`: + http://www.chinaasic.com/chipDetails/detail_156.html + +.. _`SM16208 Datasheet (CN) V1.2`: + http://www.chinaasic.com/websiteManage/product/20221130200606318.pdf + +.. _`SM16306`: + http://www.chinaasic.com/chipDetails/detail_153.html + +.. _`SM16306 Datasheet (CN) V1.3`: + http://www.chinaasic.com/websiteManage/product/20230608171556363.pdf + +.. _`TLC5920`: + https://www.ti.com/product/TLC5920 + +.. _`TLC5920 Datasheet`: + https://www.ti.com/lit/ds/symlink/tlc5920.pdf + +.. _`TLC5925`: + https://www.ti.com/product/TLC5925 + +.. _`TLC5925 Datasheet`: + https://www.ti.com/lit/ds/symlink/tlc5925.pdf + +.. _`TLC5928`: + https://www.ti.com/product/TLC5928 + +.. _`TLC5928 Datasheet`: + https://www.ti.com/lit/ds/symlink/tlc5928.pdf + +.. _`Common LED Functions and LED Driver Design Considerations (TI)`: + https://www.ti.com/lit/wp/sliy007/sliy007.pdf + .. #### Links to Motion Controllers or similar to drive any type of motors .. _`MX1208`: @@ -1098,8 +1206,19 @@ .. https://datasheetspdf.com/pdf-file/909509/SinotechMixicElectronics/MX1515/1 .. https://cdck-file-uploads-europe1.s3.dualstack.eu-west-1.amazonaws.com/arduino/original/4X/b/3/b/b3bc4d09220c9a729f4e723224cde4177450f53b.pdf +.. #### Links to Real-Time-Clocks or similar to count time and date + +.. _`DS3231`: + https://www.analog.com/en/products/ds3231.html + +.. _`DS3231 Datasheet`: + https://www.analog.com/media/en/technical-documentation/data-sheets/DS3231.pdf + .. #### Links to Sensors or similar to acquire environmental data +.. _`Senba Optoelectronic – LDR Sensors`: + https://radiolux.com.ua/files/pdf/LDR.pdf + .. _`AK09916`: https://www.akm.com/eu/en/products/electronic-compass/lineup-electronic-compass @@ -1133,6 +1252,84 @@ https://www.bosch-sensortec.com/media/boschsensortec/downloads/datasheets/bst-bmp280-ds001.pd .. https://files.waveshare.com/upload/a/af/BST-BMP280-DS001-09-371189.pdf +.. _`GL35 (φ3)`: + https://www.nysenba.com/cds/3mm.html +.. https://www.senbasensor.com/visible-light-sensor/54.html +.. http://www.szjchl.com/en/productShow.asp?id=2 + +.. _`GL35 (φ3) Datasheet`: + https://www.pollin.de/productdownloads/D120797D.PDF + +.. _`GL35 (φ3) Datasheet (CN)`: + https://www.nysenba.com/data/upload/20221208/63918e64a70bc.pdf + +.. _`GL45 (φ4)`: + https://www.nysenba.com/cds/4mm.html +.. https://www.senbasensor.com/visible-light-sensor/55.html +.. http://www.szjchl.com/en/productShow.asp?id=3 + +.. _`GL45 (φ4) Datasheet`: + https://evelta.com/content/datasheets/361-4mm-LDR-Senba.pdf + +.. _`GL45 (φ4) Datasheet (CN)`: + https://www.nysenba.com/data/upload/20221208/63918e7c3047c.pdf + +.. _`GL55/GL56 (φ5)`: + https://www.nysenba.com/cds/5mm.html +.. https://www.senbasensor.com/visible-light-sensor/56.html +.. http://www.szjchl.com/en/productShow.asp?id=4 + +.. _`GL55/GL56 (φ5) Datasheet`: + https://akizukidenshi.com/download/ds/senba/GL55%20Series%20Photoresistor.pdf +.. https://evelta.com/content/datasheets/361-LDR-Senba.pdf +.. https://www.pollin.de/productdownloads/D120781D.PDF + +.. _`GL55/GL56 (φ5) Datasheet (CN)`: + https://www.nysenba.com/data/upload/20221208/63918e90633ef.pdf + +.. _`GL55 User Guide`: + https://www.handsontec.com/dataspecs/sensor/GL55-LDR.pdf + +.. _`GL75 (φ7)`: + https://www.nysenba.com/cds/7mm.html +.. https://www.senbasensor.com/visible-light-sensor/57.html +.. http://www.szjchl.com/en/productShow.asp?id=5 + +.. _`GL75 (φ7) Datasheet (CN)`: + https://www.nysenba.com/data/upload/20221208/63918eaa62ba0.pdf + +.. _`GL105 (φ10)`: + https://www.nysenba.com/cds/10mm.html +.. https://www.senbasensor.com/visible-light-sensor/58.html + +.. _`GL105 (φ10) Datasheet`: + https://www.pollin.de/productdownloads/D120796D.PDF + +.. _`GL105 (φ10) Datasheet (CN)`: + https://www.nysenba.com/data/upload/20221208/63918ec120262.pdf + +.. _`GL125 (φ12)`: + https://www.nysenba.com/cds/12mm.html +.. https://www.senbasensor.com/visible-light-sensor/59.html +.. http://www.szjchl.com/en/productShow.asp?id=6 + +.. _`GL125 (φ12) Datasheet`: + https://www.pollin.de/productdownloads/D120795D.PDF + +.. _`GL125 (φ12) Datasheet (CN)`: + https://www.nysenba.com/data/upload/20221208/63918ed6a05a0.pdf + +.. _`GL205 (φ20)`: + https://www.nysenba.com/cds/20mm.html +.. https://www.senbasensor.com/visible-light-sensor/60.html +.. http://www.szjchl.com/en/productShow.asp?id=7 + +.. _`GL205 (φ20) Datasheet`: + https://www.pollin.de/productdownloads/D120794D.PDF + +.. _`GL205 (φ20) Datasheet (CN)`: + https://www.nysenba.com/data/upload/20221208/63918eeda3bd2.pdf + .. _`ICM-20948`: https://invensense.tdk.com/products/motion-tracking/9-axis/icm-20948 @@ -1169,6 +1366,24 @@ .. _`MPU-9250 Migrating to ICM-20948`: https://invensense.tdk.com/wp-content/uploads/2018/10/AN-000146-v2.0-TDK_Migration_MPU_9250toICM-20948.pdf +.. _`PGM5`: + http://token.com.tw/resistor/photo-cds.htm + +.. _`PGM5 Datasheet`: + http://token.com.tw/pdf/resistor/cds-resistor-pgm.pdf + +.. _`PGM12`: + http://token.com.tw/resistor/photo-cds.htm + +.. _`PGM12 Datasheet`: + http://token.com.tw/pdf/resistor/cds-resistor-pgm.pdf + +.. _`PGM20`: + http://token.com.tw/resistor/photo-cds.htm + +.. _`PGM20 Datasheet`: + http://token.com.tw/pdf/resistor/cds-resistor-pgm.pdf + .. _`SGP40`: https://sensirion.com/search/products?q=SGP40 diff --git a/doc/bridle/shortcuts.txt b/doc/bridle/shortcuts.txt index fa9ba44d22..587099f3da 100644 --- a/doc/bridle/shortcuts.txt +++ b/doc/bridle/shortcuts.txt @@ -125,6 +125,9 @@ .. |Waveshare Pico RGB LED| replace:: :ref:`Waveshare Pico RGB LED ` +.. |Waveshare Pico Clock Green| replace:: + :ref:`Waveshare Pico Clock Green ` + .. |XIAO SAMD21 (CDC ACM)| replace:: :ref:`XIAO SAMD21 (CDC ACM) ` From 93d14ab23b3cc37528d9338995a000ab1785319d Mon Sep 17 00:00:00 2001 From: Stephan Linz Date: Sat, 16 Mar 2024 17:39:55 +0100 Subject: [PATCH 12/13] doc: add Waveshare Pico Clock Green as supported board Signed-off-by: Stephan Linz --- doc/bridle/app_boards.rst | 2 ++ 1 file changed, 2 insertions(+) diff --git a/doc/bridle/app_boards.rst b/doc/bridle/app_boards.rst index 62c946b1a5..644677e8db 100644 --- a/doc/bridle/app_boards.rst +++ b/doc/bridle/app_boards.rst @@ -104,6 +104,8 @@ The following shields are defined in the :file:`bridle/boards/shields/` folder. | +------------------------------------------+----------------------------------------+ | | :ref:`x_grove_testbed_shield` | ``x_grove_testbed`` | +------------------------------------------+------------------------------------------+----------------------------------------+ +| :ref:`rpi_pico_clock_shield` | |Waveshare Pico Clock Green| | ``waveshare_pico_clock_green`` | ++------------------------------------------+------------------------------------------+----------------------------------------+ | :ref:`rpi_pico_lcd_shield` | |Waveshare Pico LCD 1.14| | ``waveshare_pico_lcd_1_14`` | | +------------------------------------------+----------------------------------------+ | | |Waveshare Pico LCD 2| | ``waveshare_pico_lcd_2`` | From eb80e56f0b2aa4f487272ade9a176c416905743d Mon Sep 17 00:00:00 2001 From: Stephan Linz Date: Sat, 16 Mar 2024 17:40:18 +0100 Subject: [PATCH 13/13] release: add draft notes for upcoming 3.6.0 Signed-off-by: Stephan Linz --- doc/bridle/releases/release-notes-3.6.0.rst | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-) diff --git a/doc/bridle/releases/release-notes-3.6.0.rst b/doc/bridle/releases/release-notes-3.6.0.rst index ac9e717eea..c1e505207a 100644 --- a/doc/bridle/releases/release-notes-3.6.0.rst +++ b/doc/bridle/releases/release-notes-3.6.0.rst @@ -12,6 +12,7 @@ Highlights ********** * Add the u-blox library (**ubxlib**) and provide a simple GNSS example. +* Add *Raspberry Pi Pico* **Clock** *Shields*. * Add *Raspberry Pi Pico* **LCD** *Shields*. * Add *Raspberry Pi Pico* **LED** *Shields*. * Add *Raspberry Pi Pico* **TEST** *Shields*. @@ -120,6 +121,7 @@ Supported shields * Seeed Studio Grove Interconnect Shields * Grove Button Shields * Grove LED Shields +* Raspberry Pi Pico Clock Shields * Raspberry Pi Pico LCD Shields * Raspberry Pi Pico LED Shields * Raspberry Pi Pico TEST Shields @@ -179,13 +181,9 @@ Change log * Add more shields: - * *Raspberry Pi Pico TEST Shields*: - - * **Pico ALL GPIO TEST** shield by Spotpear + * *Raspberry Pi Pico Clock Shields*: - * *Raspberry Pi Pico LED Shields*: - - * **Pico RGB LED** shield by Waveshare + * **Pico Clock Green** shield by Waveshare * *Raspberry Pi Pico LCD Shields*: @@ -193,6 +191,14 @@ Change log * **Pico LCD 2** shield by Waveshare * **Pico ResTouch LCD 3.5** shield by Waveshare + * *Raspberry Pi Pico LED Shields*: + + * **Pico RGB LED** shield by Waveshare + + * *Raspberry Pi Pico TEST Shields*: + + * **Pico ALL GPIO TEST** shield by Spotpear + * *Waveshare LCD Modules*: * **2.4inch LCD Module** as shield by Waveshare @@ -276,6 +282,7 @@ These GitHub issues were addressed since project bootstrapping: * :github:`185` - [HW] Waveshare Pico 10-DOF IMU Sensor * :github:`183` - [HW] Waveshare Pico RGB LED * :github:`177` - [HW] Waveshare Pico Environment Sensor +* :github:`176` - [HW] Waveshare Pico Clock Green * :github:`170` - [FCR] Upgrade to Zephyr SDK 0.16.4 * :github:`169` - [HW] The PicoBoy * :github:`168` - [HW] Waveshare Pico ResTouch LCD 3.5