C - Rozdzielanie zmiennej 32 bitowej, wyswietlanie w hex

W tym temacie chciałbym pokazać dwa proste programy pozwalające na rozdzielenie liczby dziesiętnej na pojedyncze elementy oraz wyświetlenie tej samej liczby jako wartości szesnastkowej.

Program do wyświetlenia wartości liczbowej po jednej cyfrze:

Poniżej przedstawiam rozwiązanie bez użycia pętli for. Tutaj jako zmienna rozdzielana będzie wykorzystywana 24 bitowa liczba w formacie uint32_t. 

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <time.h>
4. #include <stdint.h>
6. void WypiszWartosc(uint32_t wartosc_wypisz)
7. {
8.     uint32_t tablica[10] = {1000000000, 100000000, 10000000, 1000000,
9.                             100000, 10000, 1000, 100, 10, 1};
11.     uint32_t tymczasowa = 0;
13.     tymczasowa = wartosc_wypisz;
15.     tymczasowa = tymczasowa / tablica[0];
17.     printf("%d\n", tymczasowa);
19.     tymczasowa = wartosc_wypisz % tablica[0];
21.     tymczasowa = tymczasowa / tablica[1];
23.     printf("%d\n", tymczasowa);
25.     tymczasowa = wartosc_wypisz % tablica[1];
27.     tymczasowa = tymczasowa / tablica[2];
29.     printf("%d\n", tymczasowa);
31.     tymczasowa = wartosc_wypisz % tablica[2];
33.     tymczasowa = tymczasowa / tablica[3];
35.     printf("%d\n", tymczasowa);
37.     tymczasowa = wartosc_wypisz % tablica[3];
39.     tymczasowa = tymczasowa / tablica[4];
41.     printf("%d\n", tymczasowa);
43.     tymczasowa = wartosc_wypisz % tablica[4];
45.     tymczasowa = tymczasowa / tablica[5];
47.     printf("%d\n", tymczasowa);
49.     tymczasowa = wartosc_wypisz % tablica[5];
51.     tymczasowa = tymczasowa / tablica[6];
53.     printf("%d\n", tymczasowa);
55.     tymczasowa = wartosc_wypisz % tablica[6];
57.     tymczasowa = tymczasowa / tablica[7];
59.     printf("%d\n", tymczasowa);
61.     tymczasowa = wartosc_wypisz % tablica[7];
63.     tymczasowa = tymczasowa / tablica[8];
65.     printf("%d\n", tymczasowa);
67.     tymczasowa = wartosc_wypisz % tablica[8];
69.     tymczasowa = tymczasowa / tablica[9];
71.     printf("%d\n", tymczasowa);
72. }
74. int main(void)
75. {
76.     uint8_t raz = 0xFF;
77.     uint8_t raz2 = 0xFF;
78.     uint8_t raz3 = 0xFF;
79.     uint8_t raz4 = 0xFF;
80.     uint32_t polaczone = 0x00;
82.     polaczone = (raz4 | (raz3 << 8) | (raz2 << 16) | (raz << 24));
84.     printf("%lu\n", polaczone); //jak uint
85.     printf("%lx\n", polaczone); //szesnastkowo
87.     printf("Wartosci podzielone: \n");
89.     WypiszWartosc(polaczone);
91.     return 0;
92. }

Najpierw wprowadzane są zmienne, potem następuje ich połączenie oraz podzielenie, po czym za pomocą operacji dzielenia zwykłego oraz dzielenia bez reszty otrzymuje się najwyższą wartość z zdeklarowanej liczby. Dla mniejsze ilości cyfr program będzie działał poprawnie, dla większej natomiast trzeba by było go zmodyfikować. Przez co będę przechodził w następnych częściach tego postu.

Teraz przejdę do rozwiązania zawierającego pętle for, o którą powyższy program aż się prosi:

1. void WypiszWartosc(uint32_t wartosc_wypisz)
2. {
3.     uint32_t tablica[10] = {1000000000, 100000000, 10000000, 1000000,
4.                             100000, 10000, 1000, 100, 10, 1};
6.     uint32_t tymczasowa = 0;
7.     uint8_t i = 0;
9.     tymczasowa = wartosc_wypisz;
11.     tymczasowa = wartosc_wypisz / tablica[0];
13.     for(i=0; i<10; i++)
14.     {
15.         printf("%d\n", tymczasowa);
16.         tymczasowa = wartosc_wypisz % tablica[i];
17.         tymczasowa = tymczasowa / tablica[i+1];
18.     }
19. }

Rozwiązanie problemu poprzez rekurencję:

1. #define tablica_max 10
3. uint8_t WypiszWartoscRekurencja(uint32_t wartosc_wypisz)
4. {
5.     uint32_t tablica[tablica_max] = {1000000000, 100000000, 10000000, 1000000,
6.                                 100000, 10000, 1000, 100, 10, 1};
7.     uint32_t tymczasowa = 0;
8.     static uint8_t i;
10.     if(i == 0)
11.     {
12.         tymczasowa = wartosc_wypisz;
13.         tymczasowa = wartosc_wypisz / tablica[i];
14.         printf("%d\n", tymczasowa);
15.     }
16.     else if(i == (tablica_max-1))
17.     { return 0; }
19.     tymczasowa = ( wartosc_wypisz % tablica[i] ) / tablica[i+1];
20.     printf("%d\n", tymczasowa);
22.     i++;
24.     WypiszWartoscRekurencja(wartosc_wypisz);
25.    
26.     return 1;
27. }

Program do wyświetlenia wartości szesnastkowo:

W tej części zajmę się wyświetleniem przedstawionej wartości jako wartość szesnastkowa. W tym celu zmienną 32 bitową będę rozbijał na cztery 8 bitowe. Po czym każdą 8 bitową na dwie wartości 4 bitowe. Wartość 4 bitową będę sprawdzał z wartościami od 0 do F tak aby dobrać do niej odpowiednią daną w hexie. Ostatnim krokiem będzie wyświetlenie informacji na ekran.

Jeśli chodzi o czysty język C wykorzystywany do programowania tą sprawę można rozwiązać wykorzystując funkcję printf i liczbę podać jako %x. Natomiast jeśli chodzi o wykorzystanie mikrokontrolerów to nie jest to za dobre wyjście, zwłaszcza dla układów 8 bitowych ponieważ zabiera ona, tak samo jak funkcja scanf, strasznie dużo zasobów układu. I jest ona mocno nieefektywna jeśli te dane chce się wysłać np. poprzez UART czy na wyświetlacz. Ja natomiast w tym przypadku dla czystego kodu wykorzystam ją do wyświetlenia wartości w postaci znakowej.

Zacznę od funkcji sprawdzającej wartość na podstawie znaków ASCII:

1. void Sprawdz_Wartosc(uint8_t wartosc)
2. {
3.     //0 do 9 jako znaki znajduja sie na pozycji 30 do 39 HEX
4.      //od A do F od 65 do 70
5.     if(wartosc >= 0 && wartosc <= 9)
6.     {
7.         wartosc += 30;
8.     }
9.     else
10.     {
11.         wartosc += 65;
12.     }
13.     printf("%c", wartosc);
14. }

Teraz funkcja rozdzielająca dane najpierw na cztery ośmiobitowe, po czym każdą ośmiobitowa na dwie.

1. uint8_t PodzielWartosc(uint32_t liczba)
2. {
3.     uint8_t bit[4] = {liczba>>24, liczba >> 16, liczba >> 8, liczba};
4.     uint8_t petla = 0;
5.     uint8_t cztery_bity = 0x00;
7.     for(petla = 0; petla < 4; petla++)
8.     {
9.         cztery_bity = bit[petla] >> 4;
10.         Sprawdz_Wartosc(cztery_bity);
11.         cztery_bity = (bit[petla] &~ 0xF0);
12.         Sprawdz_Wartosc(cztery_bity);
13.     }
14.     printf("\n");
15. }
17. int main(void)
18. {
19.     uint32_t polaczone = 0x12345678;
21.     printf("%lu\n", polaczone); //jak uint
22.     printf("%lx\n", polaczone); //szesnastkowo
23.    
24.     printf("Wartosci podzielone, wyswietl HEX: \n");
26.     PodzielWartosc(polaczone);
28.     return 0;
29. }