Wyświetlacz siedmiosegmentowy x4, obsługa w Arduino

[ttmdear]

Cześć,

Mam wyświetlacz składający się z 4 znaków 7 segmnetowych. Metodą prób i błędów doszedłem do tego, że segment zapala się przez zwarcie do masy, a cała cyfra przez połączenie z plusem 🙂

Stworzyłem układ z dwoma rejestrami przesuwanymi 74HC595. Na pierwszym ustawiam które segmenty maja się zapalić. Robię to przez tranzystor. Na drugim rejestrze przesuwanym ustawiam która cyferka ma się zapalić.

Napisałem programik na Arduino obsługujący to wszystko. 

Sam program działa poprawnie, problem jest z wyświetlaniem cyferek. Jedna ostatnia cyferka jest jaśniejsza niż pozostałe. Jak naprawiłem problem i wszystkie cyferki wyświetlają się tak samo, to wszystkie ogólnie wyświetlają się dość słabo.

Od razu piszę, że cały czas się uczę i elektronika jest moim hobby 🙂 Więc proszę o wyrozumiałość.

Zastanawiam się również nad tym, czy w dobry sposób połączyłem rejestr przesuwny z wyświetlaczem. Czy jest konieczny tranzystor aby połączyć się z masą.

Poniżej wstawiam cały kod. Jest tam wariant (zakomentowany) w pętli wsuwam bity do rejestrów. W takim wariancie zawsze ostatnia cyferka świeci sie jaśniej niż pozostałe. 

W drugim wariancie staram się wsuwać bity tak aby na każdą cyferkę funkcja display() kończyła na każdej cyfrze. 

Schemat nie musi być zgodny z programem.

# define R_DS 8 // Wejście danych
# define R_OUTPUT_ENABLE 9 // Przenosi z na OUTPUT
# define R_ST_CP 10 // Przenosi z na OUTPUT
# define R_SH_CP 11 // SH_CP Wsuwa bity a R_DS
# define R_MR 12 // Resetuje bity
# define TEMPERATURE_INPUT A0

class DiodesDisplay {
    int pinDS;
    int pinOutputEnable;
    int pinSTCP;
    int pinSHCP;
    int pinMR;
    int lastMethod = 0;

    byte segmentsCharMaps[10] = {
        B11010111,
        B01010000,
        B11100110,
        B11110100,
        B01110001,
        B10110101,
        B10110111,
        B11010000,
        B11110111,
        B11110101,
    };

    public:

    DiodesDisplay(int pinDS, int pinOutputEnable, int pinSTCP, int pinSHCP, int pinMR) {
        this->pinDS = pinDS;
        this->pinOutputEnable = pinOutputEnable;
        this->pinSTCP = pinSTCP;
        this->pinSHCP = pinSHCP;
        this->pinMR = pinMR;
    }

    // void setLevel(int level) {
    //     digitalWrite(pinMR, HIGH);
    //     digitalWrite(pinOutputEnable, LOW);

    //     // 00000000 - 0
    //     // 10000000 - 1
    //     // 11000000 - 3
    //     // 11100000 - 7
    //     // 11110000 - 15
    //     // 11111000 - 31
    //     // 11111100 - 63
    //     // 11111110 - 127
    //     // 11111111 - 255

    //     digitalWrite(R_ST_CP, LOW);

    //     Serial.println(level);

    //     if (level <= 0) {
    //         shiftOut(pinDS, pinSHCP, MSBFIRST, 0);
    //     } else if (level <= 5) {
    //         shiftOut(pinDS, pinSHCP, MSBFIRST, 1);
    //     } else if (level <= 10) {
    //         shiftOut(pinDS, pinSHCP, MSBFIRST, 3);
    //     } else if (level <= 15) {
    //         shiftOut(pinDS, pinSHCP, MSBFIRST, 7);
    //     } else if (level <= 20) {
    //         shiftOut(pinDS, pinSHCP, MSBFIRST, 15);
    //     } else if (level <= 25) {
    //         shiftOut(pinDS, pinSHCP, MSBFIRST, 31);
    //     } else if (level <= 30) {
    //         shiftOut(pinDS, pinSHCP, MSBFIRST, 63);
    //     } else if (level <= 35) {
    //         shiftOut(pinDS, pinSHCP, MSBFIRST, 127);
    //     } else if (level > 35) {
    //         shiftOut(pinDS, pinSHCP, MSBFIRST, 255);
    //     }

    //     digitalWrite(R_ST_CP, HIGH);
    // }

    byte getBytesSequenceForNumber(int number, bool zeroAsNo = 0, bool dot = 0) {
        byte data = B00000000;

        if (number == 0) {
            if (zeroAsNo) {
                data = B00000000;
            } else {
                data = B11010111;
            }
        } else if (number == 1) {
            data = B01010000;
        } else if (number == 2) {
            data = B11100110;
        } else if (number == 3) {
            data = B11110100;
        } else if (number == 4) {
            data = B01110001;
        } else if (number == 5) {
            data = B10110101;
        } else if (number == 6) {
            data = B10110111;
        } else if (number == 7) {
            data = B11010000;
        } else if (number == 8) {
            data = B11110111;
        } else if (number == 9) {
            data = B11110101;
        }

        if (dot) {
            data = data | B00001000;
        }

        return data;
    }

    void display(float value) {
        Serial.println("display");

        byte data;

        int valueInteger = 100 * value;

        Serial.println(valueInteger);

        int a = valueInteger % 10;

        int b = (valueInteger - a) % 100;
        int c = (valueInteger - a - b) % 1000;
        int d = (valueInteger - a - b - d) % 10000;

        // a = a / 10;
        b = b / 10;
        c = c / 100;
        d = d / 1000;

        int toSlide[4] = {d, c, b, a};

        digitalWrite(pinMR, HIGH);
        digitalWrite(pinOutputEnable, LOW);

        int dd = 0;

        if (lastMethod == 0) {
            digitalWrite(R_ST_CP, LOW);
            shiftOut(pinDS, pinSHCP, LSBFIRST, B10000000);
            shiftOut(pinDS, pinSHCP, LSBFIRST, segmentsCharMaps[d]);
            digitalWrite(R_ST_CP, HIGH);
            delay(dd);

            digitalWrite(R_ST_CP, LOW);
            shiftOut(pinDS, pinSHCP, LSBFIRST, B01000000);
            shiftOut(pinDS, pinSHCP, LSBFIRST, segmentsCharMaps[c]);
            digitalWrite(R_ST_CP, HIGH);
            delay(dd);

            digitalWrite(R_ST_CP, LOW);
            shiftOut(pinDS, pinSHCP, LSBFIRST, B00100000);
            shiftOut(pinDS, pinSHCP, LSBFIRST, segmentsCharMaps[b]);
            digitalWrite(R_ST_CP, HIGH);
            delay(dd);

            digitalWrite(R_ST_CP, LOW);
            shiftOut(pinDS, pinSHCP, LSBFIRST, B00010000);
            shiftOut(pinDS, pinSHCP, LSBFIRST, segmentsCharMaps[a]);
            digitalWrite(R_ST_CP, HIGH);
            delay(dd);

            lastMethod++;
        } else if (lastMethod == 1) {
            digitalWrite(R_ST_CP, LOW);
            shiftOut(pinDS, pinSHCP, LSBFIRST, B01000000);
            shiftOut(pinDS, pinSHCP, LSBFIRST, segmentsCharMaps[c]);
            digitalWrite(R_ST_CP, HIGH);
            delay(dd);

            digitalWrite(R_ST_CP, LOW);
            shiftOut(pinDS, pinSHCP, LSBFIRST, B00100000);
            shiftOut(pinDS, pinSHCP, LSBFIRST, segmentsCharMaps[b]);
            digitalWrite(R_ST_CP, HIGH);
            delay(dd);

            digitalWrite(R_ST_CP, LOW);
            shiftOut(pinDS, pinSHCP, LSBFIRST, B00010000);
            shiftOut(pinDS, pinSHCP, LSBFIRST, segmentsCharMaps[a]);
            digitalWrite(R_ST_CP, HIGH);
            delay(dd);

            digitalWrite(R_ST_CP, LOW);
            shiftOut(pinDS, pinSHCP, LSBFIRST, B10000000);
            shiftOut(pinDS, pinSHCP, LSBFIRST, segmentsCharMaps[d]);
            digitalWrite(R_ST_CP, HIGH);
            delay(dd);


            lastMethod++;
        } else if (lastMethod == 2) {
            digitalWrite(R_ST_CP, LOW);
            shiftOut(pinDS, pinSHCP, LSBFIRST, B00100000);
            shiftOut(pinDS, pinSHCP, LSBFIRST, segmentsCharMaps[b]);
            digitalWrite(R_ST_CP, HIGH);
            delay(dd);

            digitalWrite(R_ST_CP, LOW);
            shiftOut(pinDS, pinSHCP, LSBFIRST, B00010000);
            shiftOut(pinDS, pinSHCP, LSBFIRST, segmentsCharMaps[a]);
            digitalWrite(R_ST_CP, HIGH);
            delay(dd);

            digitalWrite(R_ST_CP, LOW);
            shiftOut(pinDS, pinSHCP, LSBFIRST, B10000000);
            shiftOut(pinDS, pinSHCP, LSBFIRST, segmentsCharMaps[d]);
            digitalWrite(R_ST_CP, HIGH);
            delay(dd);

            digitalWrite(R_ST_CP, LOW);
            shiftOut(pinDS, pinSHCP, LSBFIRST, B01000000);
            shiftOut(pinDS, pinSHCP, LSBFIRST, segmentsCharMaps[c]);
            digitalWrite(R_ST_CP, HIGH);
            delay(dd);


            lastMethod++;
        } else if (lastMethod == 3) {
            digitalWrite(R_ST_CP, LOW);
            shiftOut(pinDS, pinSHCP, LSBFIRST, B00010000);
            shiftOut(pinDS, pinSHCP, LSBFIRST, segmentsCharMaps[a]);
            digitalWrite(R_ST_CP, HIGH);
            delay(dd);

            digitalWrite(R_ST_CP, LOW);
            shiftOut(pinDS, pinSHCP, LSBFIRST, B01000000);
            shiftOut(pinDS, pinSHCP, LSBFIRST, segmentsCharMaps[c]);
            digitalWrite(R_ST_CP, HIGH);
            delay(dd);

            digitalWrite(R_ST_CP, LOW);
            shiftOut(pinDS, pinSHCP, LSBFIRST, B00100000);
            shiftOut(pinDS, pinSHCP, LSBFIRST, segmentsCharMaps[b]);
            digitalWrite(R_ST_CP, HIGH);
            delay(dd);

            digitalWrite(R_ST_CP, LOW);
            shiftOut(pinDS, pinSHCP, LSBFIRST, B10000000);
            shiftOut(pinDS, pinSHCP, LSBFIRST, segmentsCharMaps[d]);
            digitalWrite(R_ST_CP, HIGH);
            delay(dd);

            lastMethod = 0;
        }

        // for(int i = 0; i < 4; i++) {
        //     digitalWrite(R_ST_CP, LOW);

        //     if (i == 0) {
        //         shiftOut(pinDS, pinSHCP, LSBFIRST, B10000000);
        //         shiftOut(pinDS, pinSHCP, LSBFIRST, segmentsCharMaps[toSlide[i]]);
        //         // shiftOut(pinDS, pinSHCP, LSBFIRST, getBytesSequenceForNumber(toSlide[i], 1));
        //     } else if (i == 1) {
        //         shiftOut(pinDS, pinSHCP, LSBFIRST, B01000000);
        //         shiftOut(pinDS, pinSHCP, LSBFIRST, segmentsCharMaps[toSlide[i]]);
        //         // shiftOut(pinDS, pinSHCP, LSBFIRST, getBytesSequenceForNumber(toSlide[i], 0, 1));
        //     } else if (i == 2) {
        //         shiftOut(pinDS, pinSHCP, LSBFIRST, B00100000);
        //         shiftOut(pinDS, pinSHCP, LSBFIRST, segmentsCharMaps[toSlide[i]]);
        //         // shiftOut(pinDS, pinSHCP, LSBFIRST, getBytesSequenceForNumber(toSlide[i]));
        //     } else if (i == 3) {
        //         shiftOut(pinDS, pinSHCP, LSBFIRST, B00010000);
        //         shiftOut(pinDS, pinSHCP, LSBFIRST, segmentsCharMaps[toSlide[i]]);
        //         // shiftOut(pinDS, pinSHCP, LSBFIRST, getBytesSequenceForNumber(toSlide[i]));
        //     }

        //     digitalWrite(R_ST_CP, HIGH);

        //     // digitalWrite(R_ST_CP, LOW);
        //     // shiftOut(pinDS, pinSHCP, LSBFIRST, B00000000);
        //     // shiftOut(pinDS, pinSHCP, LSBFIRST, B00000000);
        //     // digitalWrite(R_ST_CP, HIGH);
        // }
    }
};

//
void setup() {
    Serial.begin(9600);

    pinMode(R_DS, OUTPUT);
    pinMode(R_SH_CP, OUTPUT);
    pinMode(R_MR, OUTPUT);
    pinMode(R_ST_CP, OUTPUT);
    pinMode(R_OUTPUT_ENABLE, OUTPUT);
    pinMode(TEMPERATURE_INPUT, INPUT);
}

DiodesDisplay* diodesDisplay = new DiodesDisplay(R_DS, R_OUTPUT_ENABLE, R_ST_CP, R_SH_CP, R_MR);

double lastC = 0;

void loop() {
    Serial.println("loop");

    double v = analogRead(TEMPERATURE_INPUT) * 0.0048;

    double c = v * 100;

    if (abs(lastC - c) > 0.5) {
        diodesDisplay->display(c);

        lastC = c;
    } else {
        diodesDisplay->display(lastC);
    }
}

 

 

Edytowano Wrzesień 19, 2019 przez ttmdear

[Treker (Damian Szymański)]

@ttmdear główny problem będzie leżał w schemacie 🙂 W tej chwili masz jeden rezystor na każdą cyfrę, a powinieneś mieć 1 rezystor na każdy segment. Przy aktualnym połączeniu dzielisz prąd na liczbę włączonych segmentów. Zawsze będzie więc tak, że im więcej segmentów jest włączone tym będą one świecić słabiej. To błędne podłączenie. Sprawdź przykład z tego artykułu: Kurs Arduino II – #6 – wyświetlacze 7-segmentowe

[marek1707]

No i też to, że rejestry 74HC są słabsze niż tranzystory więc driver powinien wyglądać tak, że to elektrody wspólne (cyfry) powinny być sterowane przez tranzystory a rejestr bezpośrednio powinien napędzać tylko pojedyncze segmenty. W Twoim przypadku musiałbyś zmienić tranzystory na pnp i podłączyć je od strony anod wyświetlaczy (od plusa) a segmenty przez oporniki do wyjść rejestru. Wtedy w tym pierwszym rejestrze wybierałbyś konkretną cyfrę stanem niskim i podobnie, segmenty w niej także zapalałbyś stanem niskim w drugim rejestrze.

Weź pod uwagę, że prąd chwilowy segmentu w takim multipleksowaniu musi być ok. 4x większy niz statyczny, bo segment świeci tylko przez 1/4 czasu. Dlatego policzone(?) dla stanu ustalonego oporniki 220Ω mogą być sporo za duże już nawet dla niezłych (jasnych) wyświetlaczy. Co więcej, obecnie zmuszasz słabiutkie wyjście układu 74HC.. do zapalenia całej cyfry złożonej być może z 8 segmentów, a to może oznaczać zapotrzebowanie na prąd wypływający z wyjścia rzędu 100mA przy możliwościach tego scalaka na poziomie 5-10mA..

Tak więc do roboty: kupujesz 8 x pnp + mniejsze oporniki i przerabiasz układ na odwrotny bo ten po prostu nie pasuje do wyświetlaczy ze wspólną anodą i raportujesz wyniki. Pamiętaj też o ośmiu opornikach w bazach tranzystorów, bo to co obecnie zrobiłeś to jakaś herezja. Ile prądu wpływa do baz Twoich npn? Ograniczasz go czymś czy płynie "ile fabryka dała"? A na koniec, gdy już zrozumiesz jak to działa (w sumie to proste) to pomyśl o gotowym rozwiązaniu typu MAX7219, bo ten scalak robi to samo co skleciłeś na kolanie, ale dla 8 wyświetlaczy i na dodatek umie sterować jasnością. Niestety - o ile pamiętam - działa tylko z wyświetlaczami ze wspólną katodą:

https://botland.com.pl/pl/wyswietlacze-segmentowe-i-matryce-led/2996-modul-8-x-wyswietlacz-8-segmentowy-spi.html

lub 4 cyfry na TM1637:

https://botland.com.pl/pl/wyswietlacze-segmentowe-i-matryce-led/5973-modul-4x-wyswietlacz-7-segmentowy-interfejs-cyfrowy.html

Oba mają interfejs cyfrowy więc procesor nie musi zajmować się samym multipleksowaniem. Wysyłasz dane (numer i wygląd znaku) szeregowo do chipu i zapominasz o sprawie.

[ttmdear]

@Treker Dzięki 🙂

Wprowadzę zmiany w schemacie, przetestuje i dam znać. 

@marek1707 Dzięki 🙂

Zapoznałem się i spróbuje wprowadzić zmiany. 
 

Edytowano Wrzesień 20, 2019 przez ttmdear

[Polecacz 101]

Produkcja i montaż PCB - wybierz sprawdzone PCBWay!
   • Darmowe płytki dla studentów i projektów non-profit
   • Tylko 5$ za 10 prototypów PCB w 24 godziny
   • Usługa projektowania PCB na zlecenie
   • Montaż PCB od 30$ + bezpłatna dostawa i szablony
   • Darmowe narzędzie do podglądu plików Gerber
Zobacz również » Film z fabryki PCBWay

[ttmdear]

Zmontowałem układ na tranzystorach PNP i wszystkie segmenty zaczęły świecić. Zmierzyłem napięcie na wyściach z rejestru ok 0.30 V. Wydaje mi się, że jest to za mało aby PNP przestał przepuszczać. To 0.30V było pewnie dla NPN i też pewnie nie przepuszczał do końca. Układ zasilam zasilaczem 5V.

W wolnej chwili narysuje schemat i wrzucę. Zastanawiam się tylko, czemu na wyjściach rejestru przesuwanego przy stanie wysokim jest 0.30 V.  Czy ogólnie napięcie 5V jest za małe aby zasilić cały układ wyświetlacz/rejestry/mikrokontroler ? 

 

Edytowano Październik 3, 2019 przez ttmdear

[marek1707]

Gdy masz słabe pojęcie o tym co robisz, sugerowana kolejność działań jest następująca:

1. Rysuję schemat i zastanawiam się jak to będzie działać.

2. Wrzucam schemat na Forum i czytam opinie.

3. Modyfikuję schemat, buduję układ ze świeżo nabytym pełnym zrozumieniem zasad jego działania.

4. Z zadowoleniem obserwuję jak ładnie działa.

W sytuacji gdy piszesz:

10 godzin temu, ttmdear napisał:

Zastanawiam się tylko, czemu na wyjściach rejestru przesuwanego przy stanie wysokim jest 0.30 V.  Czy ogólnie napięcie 5V jest za małe aby zasilić cały układ wyświetlacz/rejestry/mikrokontroler ? 

można tylko rozłożyć ręce i zapłakać. Co bardziej odporni zwyczajnie poczekają na schemat bez wdawania się w bezowocną dyskusję.

Rozumiem, że zdanie:

Dnia 20.09.2019 o 10:02, marek1707 napisał:

Pamiętaj też o ośmiu opornikach w bazach tranzystorów

zwyczajnie zignorowałeś.

[ttmdear]

@marek1707 mój ostatni wpis był rozpaczliwym wołaniem o pomoc po 5 godzinach siedzenia nad płytką prototypową (oraz 8 siedzenia w pracy) i zastanawiania się czemu to nie działa. Mam nadzieje, że to mnie trochę usprawiedliwia 🙂 

23 godziny temu, marek1707 napisał:

1. Rysuję schemat i zastanawiam się jak to będzie działać.

2. Wrzucam schemat na Forum i czytam opinie.

3. Modyfikuję schemat, buduję układ ze świeżo nabytym pełnym zrozumieniem zasad jego działania.

4. Z zadowoleniem obserwuję jak ładnie działa.

Takie podejście jest optymalne, zgadzam się w 100%.

Ok, dzisiaj mam świeży umysł. @marek1707 przeczytałem twoją wiadomość nic nie zignorowałem !

Wrzucam schemat, ogólnie zauważyłem, że po podpięciu PNP na wyświetlaczu świecą sie wszystkie segmenty i wszystkie cyfry. Zmierzyłem napięcie na bazie na jednym z tranzystorów od segmentów, wyszło mi ok. 30mV przy stanie wysokim i około 0V przy stanie niskim. Wydaje mi się, że to napięcie jest za małe, aby tranzystor PNP przestał przepuszczać. 

Chciałbym się również doradzi, jakie polecacie (książki, publikacje) gdzie obliczanie układów zostało wytłumaczone tak dla laika. Mam problem z obliczaniem np. napięcia w danych punktach układu no i tym samym dopieranie odpowiednich oporników etc.

[marek1707]

Przykro mi to pisać, ale odnoszę wrażenie, że nie rozumiesz układu który próbujesz zbudować. Podstawową rzeczą jest to , że sterowanie takim wyświetlaczem jest niesymetryczne. Drivery elektrod wspólnych - w tym przypadku - anod muszą być silne i bardzo "sztywne". W poprzednim schemacie próbowałeś robić to za pomocą gołych wyjść rejestrów i to była główna wada, bo układy 74HC są słabe prądowo. Zaproponowałem tranzystory pnp i wstawiłeś je, ale bez sensu wyposażyłeś je w oporniki szeregowe w kolektorach. Przecież każda rezystancja na tej drodze spowoduje, że w zależności od liczby segmentów cyfra będzie świeciła mocniej lub słabiej: w lini wspólnej anody płynie suma prądów wszystkich segmentów danej cyfry. Tu ma być czysto: plus zasilania -> emiter -> kolektor -> anoda wyświetlacza. Oczywiście oporniki w bazach to dobry pomysł. A teraz driver segmentów: tu - ponieważ każde wyjście steruje tylko jednym segmentem w danej chwili - możesz spróbować "czystych" wyjść rejestru bez tranzystorów. Rzecz jasna wyjść rejestru wyposażonych w oporniki ograniczające/regulujące prąd. Ty natomiasrt wstawiłeś tranzystory (to jeszcze nie grzech), ale o złej polaryzacji i podłączone w dość głupi sposób. Albo dajesz tu npn w konfiguracji OE (emiter na masie, baza przez opornik do wyjścia rejestru, kolektor przez opornik do segmentów LED), albo sam opornik z wyjścia rejestru.

W układzie który zbudujesz (pnp "od góry", same oporniki "od dołu") włączasz poszczególne cyfry zerem w rejestrze, czyli musisz wystawiać kolejno coś w rodzaju 0111, 1011, 1101, 1110 i tak w kółko. Segmenty z drugiego rejestru także zapalasz zerami, więc gdybyś miał podłączone w kolejności ABCDEFGP to cyfra "1" wyglądałaby jak kombinacja 10011111 - świecą tylko segmenty B i C. Weź się w garść i a) poczytaj o tranzystorach w jakimś kursie, b) usiądź spokojnie i zastanów się jak właściwie ma działać to co robisz i co chcesz uzyskać, bo losowe podłączanie rzadko prowadzi do dobrych rozwiązań.

Oporniki 10k w bazach pnp mogą być troszkę za duże. To przy 5V zasilania daje ok. 0.5mA prądu, a przy wzmocnieniach tranzystorów rzędu 50 dostaniesz tylko ok. 25mA prądu anody. Pamiętając, że to suma prądów wszystkich segementów - zostaje wtedy ledwo 3mA/segment przy zapalonej cyfrze "8" co może być za mało przy multipleksowaniu 1:4 typowego wyświetlacza LED. Daj w bazy pnp po maks. 2k. A szeregowo z segementami spróbuj po 220-470Ω.

[ttmdear]

@marek1707 dzięki za odpowiedź.

Wiem, że mój układ nie jest idealny, pracuje nad tym. Bardziej mi chodzi o to
aby się czegoś nauczyć. Raz podłącze tak, raz inaczej, zobaczę co się dzieje
itp. Poproszę o pomoc na forum, doczytam coś z książki. Aby do przodu :)

Dzięki za porady, wprowadzę je układzie.

Zważyłem, że w samym programie np. niepotrzebnie za każdym razem przeliczałem
jakie segmenty mają się zapalić dla konkretnej cyfry. Wystarczyło, że te dane
zapisałem do zmiennej i była widoczna poprawa.
 

[marek1707]

24 minuty temu, ttmdear napisał:

Raz podłącze tak, raz inaczej, zobaczę co się dzieje

Właśnie o tym piszę. Tracisz mnóstwo wysiłku na próby, które mogłyby być odrzucone po minucie zastanowienia. Budujesz układy skazane na niedziałanie już u samych podstaw ich idei. Bardziej przypomina mi to działanie ewolucji niż celowe badania, tylko że ewolucja ma nieskończenie dużo czasu. Nie szkoda Ci go?

31 minut temu, ttmdear napisał:

za każdym razem przeliczałem jakie segmenty mają się zapalić dla konkretnej cyfry. Wystarczyło, że te dane zapisałem do zmiennej i była widoczna poprawa

Robisz tablicę zawierającą wyglądy wszystkich potrzebnych znaków. Ma mieć zera w miejscach zapalonych segmentów. Stałą tablicę, a nie zmienną:

static const uint8_t char_generator[] = {0x17, 0xF7, 0x62, ......};                                                                                                                                                                                                         

a potem tylko indeksujesz ją kodem znaku:

rejestr_segmentow = char_generator[kod_cyfry];

i tyle.

BTW: Możesz ją nawet zrobić w pamięci FLASH, żeby nie zajmowała RAMu.