foobar

"""

Описание сдвигового регистра тут

https://ampermarket.kz/base/ex8-indicator-and-74hc595n/

Цифры

0   A, B, C, D, E, F	    0b11000000	0x3F
1	B, C                    0b11111001	0x06
2	A, B, G, E, D	        0b10100100	0x5B
3	A, B, G, C, D	        0b10110000	0x5F
4	F, G, B, C	            0b10011001	0x66
5	A, F, G, C, D	        0b10010010	0x6D
6	A, F, G, C, D, E	    0b10000010	0x7D
7	A, B, C	                0b11111000	0x07
8	Все сегменты	        0b10000000	0x7F
9	A, B, C, D, F, G	    0b10010000	0x7F
-                           0b11000000  0xC0

Буквы

E   A, D, E, F, G           0b10000110  0x86
H   B, C, E, F, G           0b10001001  0x89
L   D, E, F                 0b11000111  0xC7

разряды сегментов

сегмент     1               0b00001000  0x08
сегмент     2               0b00000100  0x04
сегмент     3               0b00000010  0x02
сегмент     4               0b00000001  0x01

пример сообщения
second_message = [
    0b11000111000010001000100100001000,
    0b11000111000001001000011000000100,
    0b10000110000000101100011100000010,
    0b10001001000000011100011100000001,
]

"""
import RPi.GPIO as GPIO
from queue import Queue


class TM74HC595:
    def __init__(
        self,
        gpio: GPIO,
        dataPin: int = 21,          # GPIO для данных
        clockPin: int = 16,         # GPIO для тактового сигнала
        latchPin: int = 20,         # GPIO для сигнала обновления (RCLK)
    ) -> None:

        # pins settings
        self.gpio = gpio
        self.dataPin = dataPin
        self.clockPin = clockPin
        self.latchPin = latchPin
        self.gpio.setup(self.dataPin, self.gpio.OUT)
        self.gpio.setup(self.clockPin, self.gpio.OUT)
        self.gpio.setup(self.latchPin, self.gpio.OUT)

        # default values
        self.f_value = "----"
        self._f_cur_value = "----"
        self.s_value = "----"
        self._s_cur_value = "----"
        self.show = True

        # symbols values
        self.sym = {
            "0": 0xC0,
            "1": 0xF9,
            "2": 0xA4,
            "3": 0xB0,
            "4": 0x99,
            "5": 0x92,
            "6": 0x82,
            "7": 0xF8,
            "8": 0x80,
            "9": 0x90,
            "-": 0xC0,
        }
        self.segment = {
            1: 0x08,
            2: 0x04,
            3: 0x02,
            4: 0x01,
        }

    def latch(self) -> None:
        self.gpio.output(self.latchPin, self.gpio.HIGH)
        self.gpio.output(self.latchPin, self.gpio.LOW)

    def s_shiftOut(
        self,
        data: int
    ) -> None:
        for i in range(32):
            self.gpio.output(self.clockPin, self.gpio.LOW)
            self.gpio.output(self.dataPin, (data & (1 << (31 - i))) != 0)
            self.gpio.output(self.clockPin, self.gpio.HIGH)

    def build_message(
        self,
    ) -> list[int]:
        if self.f_value != self._f_cur_value and self.s_value != self._s_cur_value:
            curent_message = [
                (
                    (self.sym.get(self.s_value[0]) << 24)
                    | (self.segment.get(1) << 16)
                    | (self.f_value[0] << 8)
                    | self.segment.get(1)
                ),
                (
                    (self.sym.get(self.s_value[1]) << 24)
                    | (self.segment.get(2) << 16)
                    | (self.f_value[1] << 8)
                    | self.segment.get(2)
                ),
                (
                    (self.sym.get(self.s_value[2]) << 24)
                    | (self.segment.get(3) << 16)
                    | (self.f_value[2] << 8)
                    | self.segment.get(3)
                ),
                (
                    (self.sym.get(self.s_value[3]) << 24)
                    | (self.segment.get(4) << 16)
                    | (self.f_value[3] << 8)
                    | self.segment.get(4)
                ),
            ]
        else:
            curent_message = [
                0b10011001000010001100000000001000,
                0b10010010000001001111100100000100,
                0b10000010000000101010010000000010,
                0b11111000000000011011000000000001,
            ]
        self._f_cur_value = self.f_value
        self._s_cur_value = self.s_value
        self.set_messages(curent_message=curent_message)

    def set_messages(self, curent_message: list[int]):
        for data in curent_message:
            self.s_shiftOut(data=data)
            self.latch()

    def clean_up(self) -> None:
        self.gpio.cleanup()


if __name__ == "__main__":
    from RPi import GPIO
    from time import sleep
    from threading import Thread
    from queue import Queue
    import logging

    GPIO.setmode(GPIO.BCM)
    logging.basicConfig(level=logging.INFO)

    class DispData:
        f_value = "----"
        s_value = "----"

    disp_data = DispData()

    disp = TM74HC595(gpio=GPIO)
    app_queue = Queue()

    def show_disp():
        global disp
        global disp_data
        while disp.show:
            disp.f_value = disp_data.f_value
            logging.info(f"thread disp_data.f_value :{disp_data.f_value}")
            disp.s_value = disp_data.s_value
            logging.info(f"thread disp_data.s_value :{disp_data.s_value}")
            disp.build_message()
        disp.clean_up()

    thread = Thread(
        target=show_disp,
        daemon=True
    )
    thread.start()


    try:
        while True:
            for i in ("1234", "4567", "8912"):
                disp_data.f_value = i
                logging.info(f" base thread: {disp_data.f_value}")
                print(i)
                sleep(1)
    except KeyboardInterrupt:
        thread.join()