# Зорина Екатерина K0709-22.3
import time

print("Hello, Pi Pico!")


from machine import I2C, Pin
from ds1307 import DS1307
from lcd_i2c import LCD
import machine
import utime


buzzer_pin = machine.Pin(0, machine.Pin.OUT)
pwm = machine.PWM(buzzer_pin)


I2C_ADDR = 0x68
i2c = I2C(1, scl=Pin(19), sda = Pin(18), freq = 400_000)
rtc = DS1307(addr=I2C_ADDR, i2c=i2c)

relay = Pin(16, Pin.OUT)

I2C_ADDR = 0x27
NUM_ROWS = 2
NUM_COLS = 16


lcd = LCD(addr=I2C_ADDR, cols=NUM_COLS, rows=NUM_ROWS, i2c=i2c)
lcd.begin()

def get_relay_state():
    if relay.value() == 1:
        return 'On'
    else: 
        return 'Off'

print(rtc.datetime)


def beep(duration, volume):
    pwm.freq(1000)
    pwm.duty_u16(int(65535 * volume))
    utime.sleep_ms(duration)
    pwm.duty_u16(0)




while True:
    current_time = rtc.datetime
    if int(current_time[6]) in (2, 4, 5, 6, 7):
        if int(current_time[3]) > 8 and int(current_time[3]) < 23:
            if int(current_time[5]) <= 10:
                relay.value(1)
            else: 
                relay.value(0)
            lcd.print("{} {}:{}:{}".format(get_relay_state(), current_time[3], current_time[4], current_time[5]))

    if int(current_time[5]) % 15 == 0:
        beep(100, 0.5)
    
    if int(current_time[5]) == 0:
        beep(300, 0.7)


    time.sleep(0.5)
    lcd.clear()
    time.sleep(0.5)


main.py

diagram.json

#!/usr/bin/env python3
# -*- coding: UTF-8 -*-

"""
I2C RTC driver for DS1307

https://github.com/mcauser/micropython-tinyrtc-i2c

MIT License
Copyright (c) 2018 Mike Causer
Extended 2023 by brainelectronics

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

BCD Format:
https://en.wikipedia.org/wiki/Binary-coded_decimal
"""

# system packages
from machine import I2C
try:
    from micropython import const
except ImportError:
    def const(x):
        return x


class _Subscriptable():
    def __getitem__(self, item):
        return None


_subscriptable = _Subscriptable()

Optional = _subscriptable
Tuple = _subscriptable

DATETIME_REG = const(0)     # 0x00-0x06
CHIP_HALT = const(128)
CONTROL_REG = const(7)      # 0x07
RAM_REG = const(8)          # 0x08-0x3F


class DS1307(object):
    """Driver for the DS1307 RTC."""

    def __init__(self, addr=0x68, i2c: Optional[I2C] = None) -> None:
        """
        Constructs a new instance

        :param      addr:   The I2C bus address of the EEPROM
        :type       addr:   int
        :param      i2c:    I2C object
        :type       i2c:    I2C
        """
        self._addr = addr

        if i2c is None:
            # default assignment, check the docs
            self._i2c = I2C(0)
        else:
            self._i2c = i2c

        self._weekday_start = 0
        self._halt = False

    @property
    def addr(self) -> int:
        """
        Get the DS1307 I2C bus address

        :returns:   DS1307 I2C bus address
        :rtype:     int
        """
        return self._addr

    @property
    def weekday_start(self) -> int:
        """
        Get the start of the weekday

        :returns:   Weekday start
        :rtype:     int
        """
        return self._weekday_start

    @weekday_start.setter
    def weekday_start(self, value: int) -> None:
        """Set the start of the weekday"""
        if 0 <= value <= 6:
            self._weekday_start = value
        else:
            raise ValueError("Weekday can only be in range 0-6")

    @property
    def datetime(self) -> Tuple[int, int, int, int, int, int, int, int]:
        """
        Get the current datetime

        (2023, 4, 18, 0, 10, 34, 4, 108)
        y,     m,  d, h, m,  s, wd, yd

        :returns:   (year, month, day, hour, minute, second, weekday, yearday)
        :rtype:     Tuple[int, int, int, int, int, int, int, int]
        """
        buf = bytearray(7)

        buf = self._i2c.readfrom_mem(self._addr, DATETIME_REG, 7)

        year = self._bcd_to_dec(buf[6]) + 2000
        month = self._bcd_to_dec(buf[5])
        day = self._bcd_to_dec(buf[4])
        yearday = self.day_of_year(year=year, month=month, day=day)
        return (
            year,
            month,
            day,
            self._bcd_to_dec(buf[2]),           # hour
            self._bcd_to_dec(buf[1]),           # minute
            self._bcd_to_dec(buf[0] & 0x7F),    # second
            self._bcd_to_dec(buf[3] - self._weekday_start),     # weekday
            yearday,
        )

    @datetime.setter
    def datetime(self, datetime: Tuple[int, int, int, int, int, int, int, int]) -> None:    # noqa: E501
        """
        Set datetime

        (2023, 4, 18, 20, 23, 38, 1, 108) by time.gmtime(time.time())
        y,     m,  d,  h, min,sec,wday, yday
        0,     1,  2,  3,  4,   5,   6, 7

        :param      datetime:  The datetime
        :type       datetime:  Tuple[int, int, int, int, int, int, int, int]
        """
        buf = bytearray(7)

        # msb = CH, 1 = halt, 0 = go
        buf[0] = self._dec_to_bcd(datetime[5]) & 0x7F   # second
        buf[1] = self._dec_to_bcd(datetime[4])  # minute
        buf[2] = self._dec_to_bcd(datetime[3])  # hour
        buf[3] = self._dec_to_bcd(datetime[6] + self._weekday_start)
        buf[4] = self._dec_to_bcd(datetime[2])  # day
        buf[5] = self._dec_to_bcd(datetime[1])  # month
        buf[6] = self._dec_to_bcd(datetime[0] - 2000)   # year

        if (self._halt):
            buf[0] |= (1 << 7)

        self._i2c.writeto_mem(self._addr, DATETIME_REG, buf)

    @property
    def year(self) -> int:
        """
        Get the year from the RTC

        :returns:   Year of RTC
        :rtype:     int
        """
        return self.datetime[0]

    @property
    def month(self) -> int:
        """
        Get the month from the RTC

        :returns:   Month of RTC
        :rtype:     int
        """
        return self.datetime[1]

    @property
    def day(self) -> int:
        """
        Get the day from the RTC

        :returns:   Day of RTC
        :rtype:     int
        """
        return self.datetime[2]

    @property
    def hour(self) -> int:
        """
        Get the hour from the RTC

        :returns:   Hour of RTC
        :rtype:     int
        """
        return self.datetime[3]

    @property
    def minute(self) -> int:
        """
        Get the minute from the RTC

        :returns:   Minute of RTC
        :rtype:     int
        """
        return self.datetime[4]

    @property
    def second(self) -> int:
        """
        Get the second from the RTC

        :returns:   Second of RTC
        :rtype:     int
        """
        return self.datetime[5]

    @property
    def weekday(self) -> int:
        """
        Get the weekday from the RTC

        :returns:   Weekday of RTC
        :rtype:     int
        """
        return self.datetime[5]

    @property
    def yearday(self) -> int:
        """
        Get the yearday from the RTC

        :returns:   Yearday of RTC
        :rtype:     int
        """
        return self.datetime[7]

    def is_leap_year(self, year: int) -> bool:
        """
        Determines whether the specified year is a leap year.

        :param      year:  The year
        :type       year:  int

        :returns:   True if the specified year is leap year, False otherwise.
        :rtype:     bool
        """
        return (year % 4 == 0)

    def day_of_year(self, year: int, month: int, day: int) -> int:
        """
        Get the day of the year

        :param      year:   The year
        :type       year:   int
        :param      month:  The month
        :type       month:  int
        :param      day:    The day
        :type       day:    int

        :returns:   Day of the year, January 1 is day 1
        :rtype:     int
        """
        month_days = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
        year -= 2000
        days16 = day

        for x in range(1, month):
            days16 += month_days[x - 1]

        if month >= 2 and self.is_leap_year(year=year):
            days16 += 1

        return days16

    @property
    def halt(self) -> bool:
        """
        Get status of DS1307

        :returns:   Status of DS1307
        :rtype:     bool
        """
        return self._halt

    @halt.setter
    def halt(self, value: bool = False) -> None:
        """
        Power up or power down the RTC oscillator

        :param      value:  The value
        :type       value:  bool
        """
        reg = self._i2c.readfrom_mem(self._addr, DATETIME_REG, 1)[0]

        if value:
            reg |= CHIP_HALT
        else:
            reg &= ~CHIP_HALT

        self._halt = bool(value)
        self._i2c.writeto_mem(self._addr, DATETIME_REG, bytearray([reg]))

    def square_wave(self, sqw: int = 0, out: int = 0) -> None:
        """
        Output square wave on pin SQ

        at 1Hz, 4.096kHz, 8.192kHz or 32.768kHz, or disable the oscillator
        and output logic level high/low.
        """
        if sqw not in (0, 1, 4, 8, 32):
            raise ValueError(
                "Squarewave can be set to 0Hz, 1Hz, {}Hz, {}Hz or {}Hz".format(
                    2 ** 12, 2 ** 13, 2 ** 15)
            )

        rs0 = 1 if sqw == 4 or sqw == 32 else 0
        rs1 = 1 if sqw == 8 or sqw == 32 else 0
        out = 1 if out > 0 else 0
        sqw = 1 if sqw > 0 else 0

        reg = rs0 | rs1 << 1 | sqw << 4 | out << 7

        self._i2c.writeto_mem(self._addr, CONTROL_REG, bytearray([reg]))

    def _dec_to_bcd(self, value: int) -> int:
        """
        Convert decimal to binary coded decimal (BCD) format

        :param      value:  The value
        :type       value:  int

        :returns:   Binary coded decimal (BCD) format
        :rtype:     int
        """
        return (value // 10) << 4 | (value % 10)

    def _bcd_to_dec(self, value: int) -> int:
        """
        Convert binary coded decimal (BCD) format to decimal

        :param      value:  The value
        :type       value:  int

        :returns:   Decimal value
        :rtype:     int
        """
        return ((value >> 4) * 10) + (value & 0x0F)

ds1307.py

#!/usr/bin/env python3
# -*- coding: UTF-8 -*-

"""
I2C LCD Display driver for 1602 and 2004 displays controlled via I2C

LCD data sheet: https://www.sparkfun.com/datasheets/LCD/HD44780.pdf

Ported to MicroPython from
https://github.com/fdebrabander/Arduino-LiquidCrystal-I2C-library
"""

# system packages
from machine import I2C
from time import sleep, sleep_ms, sleep_us

# custom packages
import const as Const

# typing not natively supported on MicroPython
from typing import List, Optional, Tuple, Union


class LCD:
    """Driver for the Liquid Crystal LCD displays that use the I2C bus"""

    def __init__(self,
                 addr: int,
                 cols: int,
                 rows: int,
                 charsize: int = 0x00,
                 i2c: Optional[I2C] = None) -> None:
        """
        Constructs a new instance.

        :param      addr:      The LCD I2C bus address
        :type       addr:      int
        :param      cols:      Number of columns of the LCD
        :type       cols:      int
        :param      rows:      Number of rows of the LCD
        :type       rows:      int
        :param      charsize:  The size in dots of the LCD
        :type       charsize:  int
        :param      i2c:       I2C object
        :type       i2c:       I2C
        """
        self._addr: int = addr
        self._cols: int = cols
        self._rows: int = rows
        self._charsize: int = charsize
        self._backlightval: int = Const.LCD_BACKLIGHT
        if i2c is None:
            # default assignment, check the docs
            self._i2c = I2C(0)
        else:
            self._i2c = i2c

        self._display_control: int = 0
        self._display_mode: int = 0
        self._display_function: int = 0
        self._cursor_position: Tuple[int, int] = (0, 0)  # (x, y)

    @property
    def addr(self) -> int:
        """
        Get the LCD I2C bus address

        :returns:   LCD I2C bus address
        :rtype:     int
        """
        return self._addr

    @property
    def cols(self) -> int:
        """
        Get the number of columns of the LCD

        :returns:   Number of columns of the LCD
        :rtype:     int
        """
        return self._cols

    @property
    def rows(self) -> int:
        """
        Get the number of rows of the LCD

        :returns:   Number of rows of the LCD
        :rtype:     int
        """
        return self._rows

    @property
    def charsize(self) -> int:
        """
        Get the size in dots of the LCD

        :returns:   Dot size of the LCD
        :rtype:     int
        """
        return self._charsize

    @property
    def backlightval(self) -> int:
        """
        Get the backlight value

        :returns:   Backlight value of the LCD
        :rtype:     int
        """
        return self._backlightval

    @property
    def cursor_position(self) -> Tuple[int, int]:
        """
        Get the current cursor position

        :returns:   Cursor position as tuple(column, row) as (x, y)
        :rtype:     Tuple[int, int]
        """
        return self._cursor_position

    @cursor_position.setter
    def cursor_position(self, position: Tuple[int, int]) -> None:
        """
        Set the cursor position

        :param      position:  The cursor position
        :type       position:  Tuple[int, int]
        """
        self.set_cursor(col=position[0], row=position[1])   # (x, y)

    def begin(self) -> None:
        """
        Set the LCD display in the correct begin state

        Must be called before anything else is done
        """
        self._display_function = \
            Const.LCD_4BITMODE | Const.LCD_1LINE | Const.LCD_5x8DOTS

        if self.rows > 1:
            self._display_function |= Const.LCD_2LINE

        # for some 1 line displays you can select a 10 pixel high font
        if (self.charsize != 0) and (self.rows == 1):
            self._display_function |= Const.LCD_5x10DOTS

        # SEE PAGE 45/46 FOR INITIALIZATION SPECIFICATION!
        # according to datasheet, we need at least 40ms after power rises
        # above 2.7V before sending commands. Controller can turn on way before
        # 4.5V so we'll wait 50ms
        sleep_ms(50)

        # Now we pull both RS and R/W low to begin commands
        # reset expanderand turn backlight off (Bit 8 =1)
        self._expander_write(value=self.backlightval)
        sleep(1)

        # put the LCD into 4 bit mode
        # this is according to the Hitachi HD44780 datasheet
        # figure 24, page 46

        # we start in 8 bit mode, try to set 4 bit mode
        for _ in range(0, 3):
            self._write_4_bits(value=(0x03 << 4))
            sleep_us(4500)  # wait minimum 4.1ms

        # finally, set to 4 bit interface
        self._write_4_bits(value=(0x02 << 4))

        # set number of lines, font size, etc
        self._command(value=(Const.LCD_FUNCTIONSET | self._display_function))

        # turn the display on with no cursor or blinking default
        self._display_control = \
            Const.LCD_DISPLAYON | Const.LCD_CURSOROFF | Const.LCD_BLINKOFF
        self.display()

        # clear it off
        self.clear()

        # Initialize to default text direction (for roman languages)
        self._display_mode = \
            Const.LCD_ENTRYLEFT | Const.LCD_ENTRYSHIFTDECREMENT

        # set the entry mode
        self._command(value=(Const.LCD_ENTRYMODESET | self._display_mode))

        self.home()

    def clear(self) -> None:
        """
        Remove all the characters currently shown

        Next print/write operation will start from the first position on LCD
        display.
        """
        # clear display and set cursor position to zero
        self._command(value=Const.LCD_CLEARDISPLAY)
        sleep_ms(2)     # this command takes a long time!
        self._cursor_position = (0, 0)   # (x, y)

    def home(self) -> None:
        """
        Set cursor to home position (0, 0)

        Next print/write operation will start from the first position on the
        LCD display.
        """
        # set cursor position to zero
        self._command(value=Const.LCD_RETURNHOME)
        sleep_ms(2)     # this command takes a long time!
        self._cursor_position = (0, 0)   # (x, y)

    def no_display(self) -> None:
        """
        Turn the display off

        Do not show any characters on the LCD display. Backlight state will
        remain unchanged. Also all characters written on the display will
        return, when the display in enabled again.

        @see display
        """
        self._display_control &= ~Const.LCD_DISPLAYON
        self._command(value=(Const.LCD_DISPLAYCONTROL | self._display_control))

    def display(self) -> None:
        """
        Turn the display on

        Show the characters on the LCD display, this is the normal behaviour.
        This method should only be used after no_display() has been used.

        @see no_display
        """
        self._display_control |= Const.LCD_DISPLAYON
        self._command(value=(Const.LCD_DISPLAYCONTROL | self._display_control))

    def no_blink(self) -> None:
        """Turn the blinking cursor off"""
        self._display_control &= ~Const.LCD_BLINKON
        self._command(value=(Const.LCD_DISPLAYCONTROL | self._display_control))

    def blink(self) -> None:
        """Turn the blinking cursor on"""
        self._display_control |= Const.LCD_BLINKON
        self._command(value=(Const.LCD_DISPLAYCONTROL | self._display_control))

    def blink_on(self) -> None:
        """
        Turn on blinking cursor

        @see blink
        """
        self.blink()

    def blink_off(self) -> None:
        """
        Turn off blinking cursor

        @see no_blink
        """
        self.no_blink()

    def no_cursor(self) -> None:
        """Turn the underline cursor off"""
        self._display_control &= ~Const.LCD_CURSORON
        self._command(value=(Const.LCD_DISPLAYCONTROL | self._display_control))

    def cursor(self) -> None:
        """
        Turn the underline cursor on

        Cursor can blink or not blink. Use the methods @see blink and
        @see no_blink for changing the cursor blink status.
        """
        self._display_control |= Const.LCD_CURSORON
        self._command(value=(Const.LCD_DISPLAYCONTROL | self._display_control))

    def cursor_on(self) -> None:
        """
        Show cursor

        @see cursor
        """
        self.cursor()

    def cursor_off(self) -> None:
        """
        Hide cursor

        @see no_cursor
        """
        self.no_cursor()

    def set_cursor(self, col: int, row: int) -> None:
        """
        Set the cursor

        :param      col:  The new column of the cursor
        :type       col:  int
        :param      row:  The new row of the cursor
        :type       row:  int
        """
        row_offsets: List[int] = [0x00, 0x40, 0x14, 0x54]

        # we count rows starting w/0
        if row > (self.rows - 1):
            row = self.rows - 1

        self._command(
            value=(Const.LCD_SETDDRAMADDR | (col + row_offsets[row]))
        )

        self._cursor_position = (col, row)   # (x, y)

    def scroll_display_left(self) -> None:
        """Scroll the display to the left by one"""
        self._command(value=(Const.LCD_CURSORSHIFT | Const.LCD_DISPLAYMOVE | Const.LCD_MOVELEFT))   # noqa: E501

    def scroll_display_right(self) -> None:
        """Scroll the display to the right by one"""
        self._command(value=(Const.LCD_CURSORSHIFT | Const.LCD_DISPLAYMOVE | Const.LCD_MOVERIGHT))  # noqa: E501

    def left_to_right(self) -> None:
        """Set text flow left to right"""
        self._display_mode |= Const.LCD_ENTRYLEFT
        self._command(value=(Const.LCD_ENTRYMODESET | self._display_mode))

    def right_to_left(self) -> None:
        """Set text flow right to left"""
        self._display_mode &= ~Const.LCD_ENTRYLEFT
        self._command(value=(Const.LCD_ENTRYMODESET | self._display_mode))

    def no_backlight(self) -> None:
        """Turn backlight off"""
        self._backlightval = Const.LCD_NOBACKLIGHT
        self._expander_write(value=0)

    def backlight(self) -> None:
        """Turn backlight on"""
        self._backlightval = Const.LCD_BACKLIGHT
        self._expander_write(value=0)

    def set_backlight(self, new_val: Union[int, bool]) -> None:
        """
        Compatibility API functions for backlight

        :param      new_val:  The new backlight value
        :type       new_val:  Union[int, bool]
        """
        if new_val:
            self.backlight()        # turn backlight on
        else:
            self.no_backlight()     # turn backlight off

    def get_backlight(self) -> bool:
        """
        Get the backlight status

        :returns:   The backlight status
        :rtype:     bool
        """
        return self._backlightval == Const.LCD_BACKLIGHT

    def autoscroll(self) -> None:
        """Set text 'right justified' from the cursor"""
        self._display_mode |= Const.LCD_ENTRYSHIFTINCREMENT
        self._command(value=(Const.LCD_ENTRYMODESET | self._display_mode))

    def no_autoscroll(self) -> None:
        """Set text 'left justified' from the cursor"""
        self._display_mode &= ~Const.LCD_ENTRYSHIFTINCREMENT
        self._command(value=(Const.LCD_ENTRYMODESET | self._display_mode))

    def create_char(self, location: int, charmap: List[int]) -> None:
        """
        Fill the first 8 CGRAM locations with custom characters

        :param      location:  The location to store the custom character
        :type       location:  int
        :param      charmap:   The charmap aka custom character
        :type       charmap:   List[int]
        """
        location &= 0x7     # we only have 8, locations 0-7

        self._command(value=(Const.LCD_SETCGRAMADDR | location << 3))
        sleep_us(40)

        for x in range(0, 8):
            self._command(value=charmap[x], mode=Const.RS)
            sleep_us(40)

    def print(self, text: str) -> None:
        """
        Print text on LCD

        :param      test: Text to show on the LCD
        :type       text: str
        """
        _cursor_x, _cursor_y = self.cursor_position

        for char in text:
            self._command(value=ord(char), mode=Const.RS)

        self.cursor_position = (_cursor_x + len(text), _cursor_y)

    def _command(self, value: int, mode: int = 0) -> None:
        """
        Send 8 bits command to I2C device

        :param      value:  The value
        :type       value:  int
        """
        high_nib = value & 0xF0
        low_nib = (value << 4) & 0xF0
        self._write_4_bits(value=(high_nib | mode))
        self._write_4_bits(value=(low_nib | mode))

    def _write_4_bits(self, value: int) -> None:
        """
        Write 4 bits to I2C device

        :param      value:  The value to send
        :type       value:  int
        """
        self._expander_write(value=value)
        self._pulse_enable(value=value)

    def _pulse_enable(self, value: int) -> None:
        """
        Pulse Enable (EN) pin

        :param      value:  The value to send
        :type       value:  int
        """
        # Set Enable (EN) pin HIGH, pulse must be >450ns
        self._expander_write(value=(value | Const.EN))
        sleep_us(1)

        # Set Enable (EN) pin LOW, needs >37us to settle
        self._expander_write(value=(value & ~Const.EN))
        sleep_us(50)

    def _expander_write(self, value: int) -> None:
        """
        Write data to I2C device (port expander)

        :param      value:  The value to send
        :type       value:  int
        """
        self._i2c.writeto(self.addr, bytes([value | self._backlightval]))

lcd_i2c.py

#!/usr/bin/env python3
# -*- coding: UTF-8 -*-

"""
Fake classes of typing module.

https://github.com/micropython/micropython-lib/issues/190

https://github.com/micropython/micropython-lib/blob/3d779b8ceab5b65b9f70accbcbb15ab3509eceb7/typing/typing.py
"""


class _Subscriptable():
    def __getitem__(self, item):
        return None


_subscriptable = _Subscriptable()


class Any:
    pass


class NoReturn:
    pass


class ClassVar:
    pass


Union = _subscriptable


Optional = _subscriptable


class Generic:
    pass


class NamedTuple:
    pass


class Hashable:
    pass


class Awaitable:
    pass


class Coroutine:
    pass


class AsyncIterable:
    pass


class AsyncIterator:
    pass


class Iterable:
    pass


class Iterator:
    pass


class Reversible:
    pass


class Sized:
    pass


class Container:
    pass


class Collection:
    pass


# class Callable:
#     pass
Callable = _subscriptable


class AbstractSet:
    pass


class MutableSet:
    pass


class Mapping:
    pass


class MutableMapping:
    pass


class Sequence:
    pass


class MutableSequence:
    pass


class ByteString:
    pass


Tuple = _subscriptable


List = _subscriptable


class Deque:
    pass


class Set:
    pass


class dict_keys:
    pass


class FrozenSet:
    pass


class MappingView:
    pass


class KeysView:
    pass


class ItemsView:
    pass


class ValuesView:
    pass


class ContextManager:
    pass


class AsyncContextManager:
    pass


Dict = _subscriptable


class DefaultDict:
    pass


class Counter:
    pass


class ChainMap:
    pass


class Generator:
    pass


class AsyncGenerator:
    pass


class Type:
    pass


def cast(typ, val):
    return val


def _overload_dummy(*args, **kwds):
    """Helper for @overload to raise when called."""
    raise NotImplementedError(
        "You should not call an overloaded function. "
        "A series of @overload-decorated functions "
        "outside a stub module should always be followed "
        "by an implementation that is not @overload-ed."
    )


def overload():
    return _overload_dummy

typing.py

#!/usr/bin/env python3
# -*- coding: UTF-8 -*-

__version_info__ = ("0", "0", "0")
__version__ = '.'.join(__version_info__)

version.py

#!/usr/bin/env python3
# -*- coding: UTF-8 -*-

try:
    from micropython import const
except ImportError:
    def const(x):
        return x

# commands
#: Clear display command
LCD_CLEARDISPLAY = const(0x01)
#: Return to home position command
LCD_RETURNHOME = const(0x02)
#: Set entry mode command
LCD_ENTRYMODESET = const(0x04)
#: Control display command
LCD_DISPLAYCONTROL = const(0x08)
#: Shift cursor command
LCD_CURSORSHIFT = const(0x10)
#: Set function command
LCD_FUNCTIONSET = const(0x20)
#: Set CGRAM address command
LCD_SETCGRAMADDR = const(0x40)
#: Set DDRAM address command
LCD_SETDDRAMADDR = const(0x80)

# flags for display entry mode
#: Set display entry mode as right command
LCD_ENTRYRIGHT = const(0x00)
#: Set display entry mode as left command
LCD_ENTRYLEFT = const(0x02)
#: Set display entry mode as shift increment command
LCD_ENTRYSHIFTINCREMENT = const(0x01)
#: Set display entry mode as shift decrement command
LCD_ENTRYSHIFTDECREMENT = const(0x00)

# flags for display on/off control
#: Turn display on command
LCD_DISPLAYON = const(0x04)
#: Turn display off command
LCD_DISPLAYOFF = const(0x00)
#: Turn cursor on command
LCD_CURSORON = const(0x02)
#: Turn cursor off command
LCD_CURSOROFF = const(0x00)
#: Set curor blink command
LCD_BLINKON = const(0x01)
#: Set curor no blink command
LCD_BLINKOFF = const(0x00)

# flags for display/cursor shift
#: Display move command
LCD_DISPLAYMOVE = const(0x08)
#: Move cursor command
LCD_CURSORMOVE = const(0x00)
#: Move display shift right command
LCD_MOVERIGHT = const(0x04)
#: Move display shift left command
LCD_MOVELEFT = const(0x00)

# flags for function set
#: 8 bit mode command
LCD_8BITMODE = const(0x10)
#: 4 bit mode command
LCD_4BITMODE = const(0x00)
#: 2 line command
LCD_2LINE = const(0x08)
#: 1 line command
LCD_1LINE = const(0x00)
#: 5x10 dots display command
LCD_5x10DOTS = const(0x04)
#: 5x8 dots display command
LCD_5x8DOTS = const(0x00)

# flags for backlight control
#: Activate backlight command
LCD_BACKLIGHT = const(0x08)
#: Deactivate backlight command
LCD_NOBACKLIGHT = const(0x00)

# other
#: Enable bit
EN = const(0b00000100)
#: Read/Write bit
RW = const(0b00000010)
#: Register select bit
RS = const(0b00000001)