rpi2040 gives correct output on logic analizer for 8bit but not for 9bit communication about micropython HOT 12 OPEN

from machine import Pin
import utime

class UART:
    def __init__(self, tx_pin, baud_rate=2500):
        self.tx_pin = Pin(tx_pin, Pin.OUT)
        self.baud_rate = baud_rate
        self.bit_period_us = int(1000000 / baud_rate)

    def send_data(self, data):
        for byte in data:
            # Start bit
            self.tx_pin.value(0)
            utime.sleep_us(self.bit_period_us)  # Start bit duration

            for _ in range(8):  # 8 data bits
                self.tx_pin.value(byte & 1)
                byte >>= 1
                utime.sleep_us(self.bit_period_us)  # Data bit duration

            # Stop bit
            self.tx_pin.value(1)
            utime.sleep_us(self.bit_period_us)  # Stop bit duration

            # Ensure total byte transmission duration
            utime.sleep_us(self.bit_period_us * 2 - 4)  # Total byte transmission duration

# Example usage:
if __name__ == "__main__":
    uart = UART(tx_pin=8, baud_rate=2500)  # Initialize UART with TX pin connected to GPIO pin 8 and baud rate of 2500
    data = bytearray([102, 104, 0x0F9])  # Data to be transmitted
    uart.send_data(data)  # Send data

import pigpio
import time

# Set up GPIO mode
pi = pigpio.pi()  # Use default BCM numbering

# UART settings
BAUD_RATE = 2500  # Change baud rate to 2500 bps
BIT_PERIOD = 400000/ BAUD_RATE  # Time for one bit in microseconds
START_BIT = 0
STOP_BIT = 1
pin = 14

# Data to send
DATA = [
    (0x02, 1),
    (0x04, 1),
    (0xF9, 0)
]

# Function to send a single byte
def send_byte(byte, parity_bit, pin):
    pi.set_mode(pin, pigpio.OUTPUT)

    # Start bit
    pi.write(pin, START_BIT)
    time.sleep(BIT_PERIOD / 1000000)  # Sleep for the bit period in microseconds

    # Data bits
    for i in range(8):
        bit = (byte >> i) & 0x01
        pi.write(pin, bit)
        time.sleep(BIT_PERIOD / 1000000)  # Sleep for the bit period in microseconds

    # Parity bit
    pi.write(pin, parity_bit)
    time.sleep(BIT_PERIOD / 1000000)  # Sleep for the bit period in microseconds

    # Stop bit
    pi.write(pin, STOP_BIT)
    time.sleep(BIT_PERIOD / 1000000)  # Sleep for the bit period in microseconds

try:
    while True:
        # Send data on pins 8, 10, and 27 (BCM numbering)
        #for pin in [14,8, 10, 27]:
        
        for byte, parity_bit in DATA:
            send_byte(byte, parity_bit, pin)
            #time.sleep(0.000681)  # Sleep for the bit period in microseconds
            #time.sleep(0.000450)  # Sleep for the bit period in microseconds
        time.sleep(0.371)  # Sleep for the bit period in microseconds 
except KeyboardInterrupt:
    pass

# Clean up GPIO
pi.stop()

from machine import Pin, Timer
from rp2 import PIO, StateMachine, asm_pio

UART_BAUD = 2500
PIN_BASE = 8
NUM_UARTS = 1

# Define the hexadecimal values to be sent
hex_values = [0x102, 0x104, 0x0F9]

# Assembly code for UART transmission
@asm_pio(sideset_init=PIO.OUT_HIGH, out_init=PIO.OUT_HIGH, out_shiftdir=PIO.SHIFT_RIGHT)
def uart_tx():
    # Block with TX deasserted until data available
    pull()
    # Initialise bit counter, assert start bit for 8 cycles
    set(x, 8)  .side(0)       [7]
    # Shift out 9 data bits, 9 execution cycles per bit
    label("bitloop")
    out(pins, 1)              [7]
    jmp(x_dec, "bitloop")
    # Assert stop bit for 8 cycles total (incl 1 for pull())
    nop()      .side(1)       [6]

# Initialize StateMachine for UART
sm = StateMachine(
    0, uart_tx, freq=9 * UART_BAUD, sideset_base=Pin(PIN_BASE), out_base=Pin(PIN_BASE)
)
sm.active(1)

# Function to print the hexadecimal values
def pio_uart_hex(sm, hex_values):
    for hex_val in hex_values:
        sm.put(hex_val)
        # Insert a slight delay between bytes
        for _ in range(1550):  # Adjust this number for the desired delay
            pass

# Print the hexadecimal values from the UART
pio_uart_hex(sm, hex_values)

# Function to repeat the transmission every 200ms
def repeat_send(timer):
    pio_uart_hex(sm, hex_values)

# Initialize timer for repeating transmission
tim = Timer(-1)
tim.init(period=275, mode=Timer.PERIODIC, callback=repeat_send)