TM74HC595 py

"""

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

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
-                           0b10111111  0xBF
" "  пустой сегмент         0b11111111  0xFF

Буквы

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


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.new_value = "--------"
        self.cur_value = "--------"

        # symbols values
        self.sym = {
            "0": 0xC0,
            "1": 0xF9,
            "2": 0xA4,
            "3": 0xB0,
            "4": 0x99,
            "5": 0x92,
            "6": 0x82,
            "7": 0xF8,
            "8": 0x80,
            "9": 0x90,
            "-": 0xBF,
            " ": 0xFF
        }
        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]:
        return [
            (
                (self.sym.get(self.cur_value[4]) << 24)
                | (self.segment.get(1) << 16)
                | (self.sym.get(self.cur_value[0]) << 8)
                | self.segment.get(1)
            ),
            (
                (self.sym.get(self.cur_value[5]) << 24)
                | (self.segment.get(2) << 16)
                | (self.sym.get(self.cur_value[1]) << 8)
                | self.segment.get(2)
            ),
            (
                (self.sym.get(self.cur_value[6]) << 24)
                | (self.segment.get(3) << 16)
                | (self.sym.get(self.cur_value[2]) << 8)
                | self.segment.get(3)
            ),
            (
                (self.sym.get(self.cur_value[7]) << 24)
                | (self.segment.get(4) << 16)
                | (self.sym.get(self.cur_value[3]) << 8)
                | self.segment.get(4)
            ),
        ]

    def set_value(self):
        curent_message = self.build_message()
        for data in curent_message:
            self.s_shiftOut(data=data)
            self.latch()

    def chech_len_value(self):
        while len(self.new_value) <8:
            self.new_value = " " + self.new_value

    def check_symblos(self):
        for symbol in self.new_value:
            if symbol not in self.sym.keys():
                index = self.new_value.index(symbol)
                start_str = self.new_value[:index]
                end_str = self.new_value[index + 1:]
                self.new_value = start_str + "-" + end_str

    def compare_value(self):
        if self.cur_value != self.new_value:
            self.chech_len_value()
            self.check_symblos()
        self.cur_value = self.new_value
        self.set_value()


# testing
if __name__ == "__main__":
    from RPi import GPIO
    from time import sleep
    from threading import Thread
    import logging

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

    class DispData:
        value = "--------"


    disp_data = DispData()
    disp = TM74HC595(gpio=GPIO)

    def show_disp(disp: TM74HC595, disp_data: DispData):
        try:
            while True:
                disp.new_value = disp_data.value
                disp.compare_value()
        except KeyboardInterrupt:
            pass

    thread = Thread(
        target=show_disp,
        args=(disp, disp_data, ),
        daemon=False
    )
    thread.start()


    try:
        while True:
            logging.info("new cycle")
            for i in (
                "---[---0",
                "------01",
                "-----012",
                "----0123",
                "---01x34",
                "--012345",
                "-0123456",
                "234567z",
            ):
                disp_data.value = i
                logging.info(f" base thread: {disp_data.value}")
                sleep(1)
    except KeyboardInterrupt:
        thread.join()