from machine import Pin, I2C
import utime as time
from ds1307 import DS1307
from l2c_lcd import I2cLcd

i2c = I2C(id=0,scl=Pin(1),sda=Pin(0),freq=100000)
lcd = I2cLcd(i2c, 0x27, 2, 16)

i2c_rtc = I2C(0, scl = Pin(1), sda = Pin(0),freq = 400000)
rtc = DS1307(i2c_rtc,0x68)

while True:
    (Y,M,D,day,hr,m,s,p1) = rtc.datetime()
    if s < 10:
        s = "0" + str(s)
    if m < 10:
        m = "0" + str(m)
    if hr < 10:
        hr = "0" + str(hr)
    if D < 10:
        D = "0" + str(D)
    if D < 10:
        M = "0" + str(M)
    tim = str(hr) + ":" + str(m) + ":" + str(s)
    print(tim)
    lcd.move_to(0,1)
    lcd.putstr(tim)
    time.sleep(1)

# from machine import Pin, I2C
# import utime as time
# from ds1307 import DS1307
# from l2c_lcd import I2cLcd

# i2c = I2C(id=0, scl=Pin(1), sda=Pin(0), freq=100000)
# lcd = I2cLcd(i2c, 0x27, 2, 16)

# i2c_rtc = I2C(0, scl=Pin(1), sda=Pin(0), freq=400000)
# rtc = DS1307(i2c_rtc, 0x68)

# display_string = ""
# max_length = 16

# while True:
#     if len(display_string) < max_length:
#         display_string += hex(len(display_string))[2:].upper()
#         lcd.move_to(0, 0)
#         lcd.putstr(display_string)
#         time.sleep(0.2)  # wait 1 second before adding the next symbol
    
#     if len(display_string) == max_length:
#         for i in range(max_length):
#             lcd.move_to(0, 0)
#             lcd.putstr(" " * (i + 1) + display_string[i:])  # clear one symbol at a time
#             time.sleep(1)  # wait 1 second before clearing the next symbol
#         display_string = ""

# from machine import Pin, I2C
# import utime as time
# from ds1307 import DS1307
# from l2c_lcd import I2cLcd

# i2c = I2C(id=0, scl=Pin(1), sda=Pin(0), freq=100000)
# lcd = I2cLcd(i2c, 0x27, 2, 16)

# i2c_rtc = I2C(0, scl=Pin(1), sda=Pin(0), freq=400000)
# rtc = DS1307(i2c_rtc, 0x68)

# name = "Korzhova Dasha"
# max_length = 16

# lcd.move_to(0, 0)
# lcd.putstr(name)

# time.sleep(3)

# for i in range(max_length - len(name) + 1):
#     lcd.move_to(0, 0)
#     lcd.putstr(" " * max_length)
#     lcd.move_to(i, 0)  
#     lcd.putstr(name)  
#     time.sleep(0.5)  

# lcd.clear()


main.py

diagram.json

from micropython import const

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, i2c, addr=0x68):
        self.i2c = i2c
        self.addr = addr
        self.weekday_start = 1
        self._halt = False

    def _dec2bcd(self, value):
        """Convert decimal to binary coded decimal (BCD) format"""
        return (value // 10) << 4 | (value % 10)

    def _bcd2dec(self, value):
        """Convert binary coded decimal (BCD) format to decimal"""
        return ((value >> 4) * 10) + (value & 0x0F)

    def datetime(self, datetime=None):
        """Get or set datetime"""
        if datetime is None:
            buf = self.i2c.readfrom_mem(self.addr, DATETIME_REG, 7)
            return (
                self._bcd2dec(buf[6]) + 2000, # year
                self._bcd2dec(buf[5]), # month
                self._bcd2dec(buf[4]), # day
                self._bcd2dec(buf[3] - self.weekday_start), # weekday
                self._bcd2dec(buf[2]), # hour
                self._bcd2dec(buf[1]), # minute
                self._bcd2dec(buf[0] & 0x7F), # second
                0 # subseconds
            )
        buf = bytearray(7)
        buf[0] = self._dec2bcd(datetime[6]) & 0x7F # second, msb = CH, 1=halt, 0=go
        buf[1] = self._dec2bcd(datetime[5]) # minute
        buf[2] = self._dec2bcd(datetime[4]) # hour
        buf[3] = self._dec2bcd(datetime[3] + self.weekday_start) # weekday
        buf[4] = self._dec2bcd(datetime[2]) # day
        buf[5] = self._dec2bcd(datetime[1]) # month
        buf[6] = self._dec2bcd(datetime[0] - 2000) # year
        if (self._halt):
            buf[0] |= (1 << 7)
        self.i2c.writeto_mem(self.addr, DATETIME_REG, buf)

def halt(self, val=None):
    """Power up, power down or check status"""
    if val is None:
        return self._halt
    reg = self.i2c.readfrom_mem(self.addr, DATETIME_REG, 1)[0]
    if val:
        reg |= CHIP_HALT
    else:
        reg &= ~CHIP_HALT
    self._halt = bool(val)
    self.i2c.writeto_mem(self.addr, DATETIME_REG, bytearray([reg]))

def square_wave(self, sqw=0, out=0):
    """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."""
    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]))

ds1307.py

import time
class LcdApi:
    LCD_CLR = 0x01 # DB0: clear display
    LCD_HOME = 0x02 # DB1: return to home position
    LCD_HOME = 0x02 # DB1: return to home position
    LCD_ENTRY_MODE = 0x04 # DB2: set entry mode
    LCD_ENTRY_INC = 0x02 # --DB1: increment
    LCD_ENTRY_SHIFT = 0x01 # --DB0: shift
    LCD_ON_CTRL = 0x08 # DB3: turn lcd/cursor on
    LCD_ON_DISPLAY = 0x04 # --DB2: turn display on
    LCD_ON_CURSOR = 0x02 # --DB1: turn cursor on
    LCD_ON_BLINK = 0x01 # --DB0: blinking cursor
    LCD_MOVE = 0x10 # DB4: move cursor/display
    LCD_MOVE_DISP = 0x08 # --DB3: move display (0-> move cursor)
    LCD_MOVE_RIGHT = 0x04 # --DB2: move right (0-> left)
    LCD_FUNCTION = 0x20 # DB5: function set
    LCD_FUNCTION_8BIT = 0x10 # --DB4: set 8BIT mode (0->4BIT mode)
    LCD_FUNCTION_2LINES = 0x08 # --DB3: two lines (0->one line)
    LCD_FUNCTION_10DOTS = 0x04 # --DB2: 5x10 font (0->5x7 font)
    LCD_FUNCTION_RESET = 0x30 # See "Initializing by Instruction" section
    LCD_CGRAM = 0x40 # DB6: set CG RAM address
    LCD_DDRAM = 0x80 # DB7: set DD RAM address
    LCD_RS_CMD = 0
    LCD_RS_DATA = 1
    LCD_RW_WRITE = 0
    LCD_RW_READ = 1

    def __init__(self, num_lines, num_columns):
        self.num_lines = num_lines
        if self.num_lines > 4:
            self.num_lines = 4
        self.num_columns = num_columns
        if self.num_columns > 40:
            self.num_columns = 40
        self.cursor_x = 0
        self.cursor_y = 0
        self.implied_newline = False
        self.backlight = True
        self.display_off()
        self.backlight_on()
        self.clear()
        self.hal_write_command(self.LCD_ENTRY_MODE | self.LCD_ENTRY_INC)
        self.hide_cursor()
        self.display_on()

    def clear(self):
        """Clears the LCD display and moves the cursor to the top left
        corner.
        """
        self.hal_write_command(self.LCD_CLR)
        self.hal_write_command(self.LCD_HOME)
        self.cursor_x = 0
        self.cursor_y = 0

    def show_cursor(self):
        """Causes the cursor to be made visible."""
        self.hal_write_command(self.LCD_ON_CTRL | self.LCD_ON_DISPLAY |
        self.LCD_ON_CURSOR)

    def hide_cursor(self):
        """Causes the cursor to be hidden."""
        self.hal_write_command(self.LCD_ON_CTRL | self.LCD_ON_DISPLAY)

    def blink_cursor_on(self):
        """Turns on the cursor, and makes it blink."""
        self.hal_write_command(self.LCD_ON_CTRL | self.LCD_ON_DISPLAY |
        self.LCD_ON_CURSOR | self.LCD_ON_BLINK)

    def blink_cursor_off(self):
        """Turns on the cursor, and makes it no blink (i.e. be solid)."""
        self.hal_write_command(self.LCD_ON_CTRL | self.LCD_ON_DISPLAY |
        self.LCD_ON_CURSOR)

    def display_on(self):
        """Turns on (i.e. unblanks) the LCD."""
        self.hal_write_command(self.LCD_ON_CTRL | self.LCD_ON_DISPLAY)

    def display_off(self):
        """Turns off (i.e. blanks) the LCD."""
        self.hal_write_command(self.LCD_ON_CTRL)

    def backlight_on(self):
        """Turns the backlight on.
        This isn't really an LCD command, but some modules have backlight
        controls, so this allows the hal to pass through the command.
        """
        self.backlight = True
        self.hal_backlight_on()

    def backlight_off(self):
        """Turns the backlight off.
        This isn't really an LCD command, but some modules have backlight
        controls, so this allows the hal to pass through the command.
        """
        self.backlight = False
        self.hal_backlight_off()

    def move_to(self, cursor_x, cursor_y):
        """Moves the cursor position to the indicated position. The cursor
        position is zero based (i.e. cursor_x == 0 indicates first column).
        """
        self.cursor_x = cursor_x
        self.cursor_y = cursor_y
        addr = cursor_x & 0x3f
        if cursor_y & 1:
            addr += 0x40 # Lines 1 & 3 add 0x40
        if cursor_y & 2: # Lines 2 & 3 add number of columns
            addr += self.num_columns
        self.hal_write_command(self.LCD_DDRAM | addr)

    def putchar(self, char):
        """Writes the indicated character to the LCD at the current cursor
        position, and advances the cursor by one position.
        """
        if char == '\n':
            if self.implied_newline:
                # self.implied_newline means we advanced due to a wraparound,
                # so if we get a newline right after that we ignore it.
                pass
            else:
                self.cursor_x = self.num_columns
        else:
            self.hal_write_data(ord(char))
            self.cursor_x += 1
        if self.cursor_x >= self.num_columns:
            self.cursor_x = 0
            self.cursor_y += 1
            self.implied_newline = (char != '\n')
        if self.cursor_y >= self.num_lines:
            self.cursor_y = 0
        self.move_to(self.cursor_x, self.cursor_y)

    def putstr(self, string):
        """Write the indicated string to the LCD at the current cursor
        position and advances the cursor position appropriately.
        """
        for char in string:
            self.putchar(char)

    def custom_char(self, location, charmap):
        """Write a character to one of the 8 CGRAM locations, available
        as chr(0) through chr(7).
        """
        location &= 0x7
        self.hal_write_command(self.LCD_CGRAM | (location << 3))
        self.hal_sleep_us(40)
        for i in range(8):
            self.hal_write_data(charmap[i])
            self.hal_sleep_us(40)
        self.move_to(self.cursor_x, self.cursor_y)

    def hal_backlight_on(self):
        """Allows the hal layer to turn the backlight on.
        If desired, a derived HAL class will implement this function.
        """
    pass
    def hal_backlight_off(self):
        """Allows the hal layer to turn the backlight off.
        If desired, a derived HAL class will implement this function.
        """
    pass

    def hal_write_command(self, cmd):
        """Write a command to the LCD.
        It is expected that a derived HAL class will implement this
        function.
        """
        raise NotImplementedError

    def hal_write_data(self, data):
        """Write data to the LCD.
        It is expected that a derived HAL class will implement this
        function.
        """
        raise NotImplementedError

    def hal_sleep_us(self, usecs):
        """Sleep for some time (given in microseconds)."""
        time.sleep_us(usecs)

lcd_api.py

from lcd_api import LcdApi
from machine import I2C
from time import sleep_ms
DEFAULT_I2C_ADDR = 0x27
# Defines shifts or masks for the various LCD line attached to the PCF8574
MASK_RS = 0x01
MASK_RW = 0x02
MASK_E = 0x04
SHIFT_BACKLIGHT = 3
SHIFT_DATA = 4
class I2cLcd(LcdApi):
    """Implements a character based lcd connected via PCF8574 on i2c."""
    def __init__(self, i2c, i2c_addr, num_lines, num_columns):
        self.i2c = i2c
        self.i2c_addr = i2c_addr
        self.i2c.writeto(self.i2c_addr, bytearray([0]))
        sleep_ms(20) # Allow LCD time to powerup
        # Send reset 3 times
        self.hal_write_init_nibble(self.LCD_FUNCTION_RESET)
        sleep_ms(5) # need to delay at least 4.1 msec
        self.hal_write_init_nibble(self.LCD_FUNCTION_RESET)
        sleep_ms(1)
        self.hal_write_init_nibble(self.LCD_FUNCTION_RESET)
        sleep_ms(1)
        # Put LCD into 4 bit mode
        self.hal_write_init_nibble(self.LCD_FUNCTION)
        sleep_ms(1)
        LcdApi.__init__(self, num_lines, num_columns)
        cmd = self.LCD_FUNCTION
        if num_lines > 1:
            cmd |= self.LCD_FUNCTION_2LINES
        self.hal_write_command(cmd)

    def hal_write_init_nibble(self, nibble):
        """Writes an initialization nibble to the LCD.
        This particular function is only used during intiialization.
        """
        byte = ((nibble >> 4) & 0x0f) << SHIFT_DATA
        self.i2c.writeto(self.i2c_addr, bytearray([byte | MASK_E]))
        self.i2c.writeto(self.i2c_addr, bytearray([byte]))

    def hal_backlight_on(self):
        """Allows the hal layer to turn the backlight on."""
        self.i2c.writeto(self.i2c_addr, bytearray([1 << SHIFT_BACKLIGHT]))

    def hal_backlight_off(self):
        """Allows the hal layer to turn the backlight off."""
        self.i2c.writeto(self.i2c_addr, bytearray([0]))

    def hal_write_command(self, cmd):
        """Writes a command to the LCD.
        Data is latched on the falling edge of E.
        """
        byte = ((self.backlight << SHIFT_BACKLIGHT) | (((cmd >> 4) & 0x0f) <<
        SHIFT_DATA))
        self.i2c.writeto(self.i2c_addr, bytearray([byte | MASK_E]))
        self.i2c.writeto(self.i2c_addr, bytearray([byte]))
        byte = ((self.backlight << SHIFT_BACKLIGHT) | ((cmd & 0x0f) << SHIFT_DATA))
        self.i2c.writeto(self.i2c_addr, bytearray([byte | MASK_E]))
        self.i2c.writeto(self.i2c_addr, bytearray([byte]))
        if cmd <= 3:
            # The home and clear commands require a worst case delay of 4.1 msec
            sleep_ms(5)

    def hal_write_data(self, data):
        """Write data to the LCD."""
        byte = (MASK_RS | (self.backlight << SHIFT_BACKLIGHT) | (((data >> 4) &
        0x0f) << SHIFT_DATA))
        self.i2c.writeto(self.i2c_addr, bytearray([byte | MASK_E]))
        self.i2c.writeto(self.i2c_addr, bytearray([byte]))
        byte = (MASK_RS | (self.backlight << SHIFT_BACKLIGHT) | ((data & 0x0f) <<
        SHIFT_DATA))
        self.i2c.writeto(self.i2c_addr, bytearray([byte | MASK_E]))
        self.i2c.writeto(self.i2c_addr, bytearray([byte]))