# Librerias

from machine import I2C, Pin
import pico_i2c_lcd  
import lcd_api
import utime
import urandom 

# Configura el bus I2C
# Reemplaza 2 y 3 con los pines de SDA y SCL
i2c = I2C(0, scl=Pin(22), sda=Pin(21))

# Definir Pines (Pulsadores de los comandos)
tiro = Pin(27,Pin.OUT)
der = Pin(12,Pin.OUT)
izq = Pin(14,Pin.OUT)
nume = 0

# La dirección I2C del LCD puede variar, este es un valor común.
lcd_address = 0x27


pac_abierto = [
0b01110,
0b10001,
0b10000,
0b10001,
0b01110,
0b00000,
0b00000,
0b00000]

pac_cerrado = [
0b01110,
0b10001,
0b10001,
0b10001,
0b10001,
0b01110,
0b00000,
0b00000]



lcd = pico_i2c_lcd.I2cLcd(i2c, lcd_address, 2, 16)  # Asume un LCD de 2x16


lcd.custom_char(0, pac_abierto)
lcd.custom_char(1, pac_cerrado)
# Limpia el LCD
#lcd.clear()

# Muestrar la galleta y el numeral (#)

Mover = 5
lcd.move_to(Mover, 0) 
lcd.putstr("O")
lcd.clear()

nume = 6
lcd.move_to(nume, 1)
lcd.putstr("#")

# Tiempo en el que inicia el juego 

tiempo_inicial=utime.ticks_ms()

# Ciclo para jugar
while True:
  # Tiempo que va contando mientras juega
  tiempo_actual=utime.ticks_ms()
  
  # Imprimir en la pantalla el numero
  lcd.move_to(nume, 1)
  lcd.putstr("#")
  Cambio = urandom.randint(-1,1)
  utime.sleep(0.2)  # Espera 2 segundos

  if Mover == 0:
    Cambio = 1

  if Mover == 15:
    Cambio = -1

  Mover = Mover + Cambio
  lcd.move_to(Mover,0)
  lcd.putstr("O")
  utime.sleep(0.2)  # Espera 2 segundos
  lcd.clear()

  if der.value() == 0:
    nume = nume + 1
    

  if izq.value() == 0:
    nume = nume - 1

  lcd.move_to(nume, 1)
  utime.sleep(0.1)
        
  
  if tiro.value() == 1:
    if Mover == nume:
       lcd.clear()
       lcd.putstr("¡¡¡GANASTE!!!")

    else:
       lcd.clear()
       lcd.putstr("¡¡¡PERDISTE!!!")
  
  if tiempo_actual - tiempo_inicial >= 15000:
    lcd.clear()
    lcd.putstr("¡¡¡TIEMPO!!!")
    break
  
  continue






main.py

diagram.json

import time

class LcdApi:
    
    # Implements the API for talking with HD44780 compatible character LCDs.
    # This class only knows what commands to send to the LCD, and not how to get
    # them to the LCD.
    #
    # It is expected that a derived class will implement the hal_xxx functions.
    #
    # The following constant names were lifted from the avrlib lcd.h header file,
    # with bit numbers changed to bit masks.
    
    # HD44780 LCD controller command set
    LCD_CLR             = 0x01  # DB0: clear display
    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

import utime
import gc

from lcd_api import LcdApi
from machine import I2C

# PCF8574 pin definitions
MASK_RS = 0x01       # P0
MASK_RW = 0x02       # P1
MASK_E  = 0x04       # P2

SHIFT_BACKLIGHT = 3  # P3
SHIFT_DATA      = 4  # P4-P7

class I2cLcd(LcdApi):
    
    #Implements a HD44780 character 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, bytes([0]))
        utime.sleep_ms(20)   # Allow LCD time to powerup
        # Send reset 3 times
        self.hal_write_init_nibble(self.LCD_FUNCTION_RESET)
        utime.sleep_ms(5)    # Need to delay at least 4.1 msec
        self.hal_write_init_nibble(self.LCD_FUNCTION_RESET)
        utime.sleep_ms(1)
        self.hal_write_init_nibble(self.LCD_FUNCTION_RESET)
        utime.sleep_ms(1)
        # Put LCD into 4-bit mode
        self.hal_write_init_nibble(self.LCD_FUNCTION)
        utime.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)
        gc.collect()

    def hal_write_init_nibble(self, nibble):
        # Writes an initialization nibble to the LCD.
        # This particular function is only used during initialization.
        byte = ((nibble >> 4) & 0x0f) << SHIFT_DATA
        self.i2c.writeto(self.i2c_addr, bytes([byte | MASK_E]))
        self.i2c.writeto(self.i2c_addr, bytes([byte]))
        gc.collect()
        
    def hal_backlight_on(self):
        # Allows the hal layer to turn the backlight on
        self.i2c.writeto(self.i2c_addr, bytes([1 << SHIFT_BACKLIGHT]))
        gc.collect()
        
    def hal_backlight_off(self):
        #Allows the hal layer to turn the backlight off
        self.i2c.writeto(self.i2c_addr, bytes([0]))
        gc.collect()
        
    def hal_write_command(self, cmd):
        # Write 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, bytes([byte | MASK_E]))
        self.i2c.writeto(self.i2c_addr, bytes([byte]))
        byte = ((self.backlight << SHIFT_BACKLIGHT) |
                ((cmd & 0x0f) << SHIFT_DATA))
        self.i2c.writeto(self.i2c_addr, bytes([byte | MASK_E]))
        self.i2c.writeto(self.i2c_addr, bytes([byte]))
        if cmd <= 3:
            # The home and clear commands require a worst case delay of 4.1 msec
            utime.sleep_ms(5)
        gc.collect()

    def hal_write_data(self, data):
        # Write data to the LCD. Data is latched on the falling edge of E.
        byte = (MASK_RS |
                (self.backlight << SHIFT_BACKLIGHT) |
                (((data >> 4) & 0x0f) << SHIFT_DATA))
        self.i2c.writeto(self.i2c_addr, bytes([byte | MASK_E]))
        self.i2c.writeto(self.i2c_addr, bytes([byte]))
        byte = (MASK_RS |
                (self.backlight << SHIFT_BACKLIGHT) |
                ((data & 0x0f) << SHIFT_DATA))      
        self.i2c.writeto(self.i2c_addr, bytes([byte | MASK_E]))
        self.i2c.writeto(self.i2c_addr, bytes([byte]))
        gc.collect()

pico_i2c_lcd.py

from machine import Pin
import utime

def LiquidCrystal(RSL, EL, d4L, d5L, d6L, d7L):
    global D4, D5, D6, D7, RS, E, T

    # Configura los pines como salidas y almacénalos en la lista LedsLCD
    RS = Pin(RSL, Pin.OUT)  # 0 Comando/ 1 Escritura
    E = Pin(EL, Pin.OUT)
    D4 = Pin(d4L, Pin.OUT)
    D5 = Pin(d5L, Pin.OUT)
    D6 = Pin(d6L, Pin.OUT)
    D7 = Pin(d7L, Pin.OUT)
    T = 5


def Enviar_pulso():
    E.value(0)
    utime.sleep_us(T)  # Espera para estabilizar el estado
    E.value(1)
    utime.sleep_us(T)  # Tiempo para detectar el pulso
    E.value(0)
    utime.sleep_us(T)  # Espera para que el LCD procese el comando

def Enviar_Nibble(data):
    D4.value((data >> 0) & 1)
    D5.value((data >> 1) & 1)
    D6.value((data >> 2) & 1)
    D7.value((data >> 3) & 1)
    Enviar_pulso()

def Enviar_Byte(cmd, data):
    RS.value(cmd)
    Enviar_Nibble(data >> 4)  # Envía los 4 bits más significativos primero
    Enviar_Nibble(data & 0x0F)  # Envía los 4 bits menos significativos

def lcd_write_char(char):
    Enviar_Byte(1, ord(char))  # Envia el carácter al LCD


def begin():
    utime.sleep_ms(20)  # Espera inicial después de alimentar el LCD
    RS.value(0)
    # Secuencia de inicialización para modo de 4 bits
    for _ in range(3):
        Enviar_Nibble(0x03)  # Modo de 8 bits
        utime.sleep_ms(T)
    Enviar_Nibble(0x02)  # Cambia a modo de 4 bits
    # Configuración de la función del LCD
    Enviar_Byte(0, 0x28)  # Modo de 4 bits, 2 líneas, fuente de 5x8
    Enviar_Byte(0, 0x0C)  # Enciende el display sin cursor
    Enviar_Byte(0, 0x06)  # Incrementa automáticamente el cursor
    Enviar_Byte(0, 0x01)  # Limpia el display
    utime.sleep_ms(T)

def setCursor(col, row):
    if row == 0:
        address = 0x80 + col
    elif row == 1:
        address = 0xC0 + col
    else:
        # Manejo de error o ignorar si la fila es inválida
        return
    Enviar_Byte(0, address)  # Envía el comando para mover el cursor

def print(value):
 #   Escribe un valor en el LCD comenzando en la posición actual del cursor.
 #   Si el valor no es una cadena, se convertirá a cadena antes de imprimir.
 #  :param value: Puede ser un número, una cadena o cualquier objeto que se pueda convertir a cadena.
    # Convertir el valor a una cadena si no lo es
    text = str(value)
    # Escribe cada carácter en el LCD
    for char in text:
        lcd_write_char(char)


def clear():
    Enviar_Byte(0, 0x01)  # Limpia el display
    utime.sleep_ms(T)

def scrollDisplayRight():
    # HD44780 comando para desplazar la pantalla a la derecha es 0x1C
    Enviar_Byte(0, 0x1C)  # Enviamos el comando con el RS (Register Select) en 0 (comando)
    utime.sleep_ms(2)     # Esperamos un poco para que el LCD procese el comando

def scrollDisplayLeft():
    # HD44780 comando para desplazar la pantalla a la izquierda es 0x18
    Enviar_Byte(0, 0x18)  # Enviamos el comando con el RS (Register Select) en 0 (comando)
    utime.sleep_ms(2)     # Esperam