|
Serwis Edukacyjny Nauczycieli w I-LO w Tarnowie 
|
Wyjście Spis treści Wstecz Dalej
Autor artykułu: mgr Jerzy Wałaszek |
©2026 mgr Jerzy Wałaszek
|
|
Serwis Edukacyjny Nauczycieli w I-LO w Tarnowie
|
Wyjście Spis treści Wstecz Dalej
Autor artykułu: mgr Jerzy Wałaszek |
©2026 mgr Jerzy Wałaszek
|
| SPIS TREŚCI |
Pojęcie bitu
Przesyłanie bitów
|
| Podrozdziały |
Bity są dwustanowymi symbolami, danymi. Stany bitów w informatyce oznaczamy tradycyjnie cyframi \(1\) i \(0\). Wewnątrz komputera oczywiście nie ma żadnych zer i jedynek – aby się o tym przekonać, wystarczy otworzyć obudowę i zaglądnąć do środka. Oszczędzimy ci jednak tej niebezpiecznej pracy – wnętrze komputera możesz sobie oglądnąć powyżej – i tak wiem, iż nic cię nie powstrzyma przed zaglądnięciem do środka, ale zrób to przynajmniej w czasie nieobecności ojca lub starszego brata... mogą nie zrozumieć twoich intencji...
Cyfr \(0\) i \(1\) używamy tylko do zapisu na papierze/tablicy stanu bitu. Wewnątrz komputera bity są reprezentowane przez napięcie elektryczne. Stan \(1\) to około 5V, a stan \(0\) to około 0V. Układy elektroniczne komputera wykorzystują te napięcia do przetwarzania danych bitowych.
Dla nas jednak wygodniej będzie posługiwać się właśnie tymi cyferkami \(1\) i \(0\) (ale pamiętaj o tym, co napisałem) . W tym rozdziale pokażę, do czego możemy wykorzystać bity, a są one nad wyraz użyteczne, o czym się wkrótce przekonasz.
Zadaniem bitów jest reprezentowanie informacji w taki sam sposób jak wyrazy reprezentują w mowie różne pojęcia. Zanim bity będą cokolwiek reprezentować, najpierw musimy troszeczkę popracować. Poniższe punkty są dobrą wskazówką:
Procedura kodowania informacji za pomocą bitów
|
W ten sposób zbudujemy tzw. kod binarny (ang. binary code). Słówka tego kodu będą reprezentowały przydzielone im informacje. Oczywiście aby odczytać te informacje, należy znać dokładnie sposób kodowania, czyli przydzielania informacji słówkom kodowym.
Na pierwszy rzut oka zadanie wydaje się beznadziejne – jak mogę przekształcić piękne obrazy Rubensa w jakieś tam bity przyjmujące stany \(0\) lub \(1\)? Na pewno masz rację, przekształcić ich nie możemy, lecz z pewnym przybliżeniem możemy zakodować zawartą w tych obrazach informację o kolorach. Na początek musimy zastanowić się, w jaki sposób będziemy przedstawiali informację zawartą w grafice, czyli nad sposobami jej reprezentacji (kodowania).
Postawmy sobie chwilowo mniej ambitne zadanie. Załóżmy, iż nasza grafika zawiera tylko dwa różne kolory – biały i czarny. Za pomocą bitów zakodujemy kolor na obrazku. Ponieważ mamy tylko dwa różne kolory, wystarczy na to jeden bit:
Określiliśmy sposób przyporządkowania informacji do bitu – to jakby język
naszej nowej mowy kodującej grafikę czarno-białą. Pozostaje tylko problem, w
jaki sposób ta informacja zawarta w bitach będzie połączona z obrazkiem.
Rozwiązanie jest dosyć proste. Obrazek dzielimy na drobną siateczkę punktów,
tzw. raster. W obrębie danego punktu (zwanego pikselem – ang.
pixel = picture element, czyli element obrazowy) kolor jest stały – albo
biały, albo czarny.
Na pewno jest to pewnym oszustwem. Ale jeśli siateczka punktów jest bardzo gęsta, to możemy dać się na nie nabrać – po prostu nasze oko nie zobaczy poszczególnych punktów, tylko obraz. O to właśnie chodzi. Poniżej ten sam obrazek, ale w "normalnej wielkości".
Wygląda całkiem miło. Tak otrzymany obrazek zamieniamy na bity: punkty czarne kodujemy bitem o stanie \(1\), a punkty białe kodujemy bitem o stanie \(0\). W postaci bitowej obrazek wygląda tak:
0000111111110000 0011111111111100 0111111111111110 0111111111111110 1100000000000111 1000000000000011 1001111001111001 1000110000110001 1000000000000001 1000000000000001 1000001111000001 1000100000010001 0100011111100010 0100000000000010 0011100000011100 0000011111100000 |
W takiej formie obrazek może być przechowywany we wnętrzu komputera (pamiętamy oczywiście, iż bity są kodowane w komputerze poziomami napięć), przesłany przez sieć teleinformatyczną lub przetwarzany przez odpowiednie algorytmy operujące na bitach. Z postaci bitowej też można bez problemu odzyskać zawartość obrazka. W tym celu wystarczy zbudować urządzenie, które na ekranie monitora obrazuje siatkę punktów graficznych, czyli raster. Następnie do urządzenia przesyłamy informację w postaci bitów dla poszczególnych punktów siatki, a ono wyświetla na ekranie odpowiednio punkt biały dla bitu \(0\) i czarny dla bitu \(1\). Tak właśnie działa karta graficzna komputera.
Zadanie kodowania grafiki pozornie się komplikuje, gdy obrazek zawiera więcej kolorów. Załóżmy, iż do narysowania naszej mordki wykorzystamy cztery kolory:
Ponieważ teraz każdy piksel obrazka może przyjąć jeden z czterech różnych kolorów, to informacji tej nie zmieścimy w jednym bicie – potrzebujemy pary bitów. Dwa bity mogą przyjąć cztery różne kombinacje swoich stanów: 00, 01, 10 i 11 tworząc cztery różne binarne słówka kodowe. Każdemu słowu kodowemu przypiszemy jeden kolor piksela. Określmy takie przypisanie:
| – 00 | |
| – 01 | |
| – 10 | |
| – 11 |
Taki sposób kodowania kolorów nazywa się kodowaniem palety barw. Polega on na tym, iż każdemu kolorowi na obrazku przypisujemy osobne słowo kodowe. Zdefiniowawszy paletę można już bez problemów przekształcić obrazek w odpowiedni ciąg bitów:
00000000010101010101010100000000 00000101010101010101010101010000 00010101010101010101010101010100 00010101010101010101010101010100 01011010101010101010101010010101 01101010101010101010101010100101 01101011111111101011111111101001 01101010111110101010111110101001 11101010101010101010101010101011 11101010101010101010101010101011 11101010101011111111101010101011 11101010111010101010101110101011 00111010101111111111111010101100 00111010101010101010101010101100 00001111111010101010101111110000 00000000001111111111110000000000 |
Odkodowanie obrazka nie nastarcza większych trudności, jeśli znamy paletę kolorów i sposób jej przyporządkowania słowom kodu. Paleta dwubitowa pozwala na zdefiniowanie czterech kolorów. Paleta \({8{-}\text{bitowa}}\) definiuje już \(256\) kolorów. Paleta \({16{-}\text{bitowa}}\) to \(65536\) barw.
W tekstach występują litery oraz inne znaki pisarskie. To właśnie one będą informacjami kodowanymi za pomocą bitów. Dla uproszczenia załóżmy, iż nasze teksty składają tylko z wielkich liter, cyfr, kropek oraz spacji. W ten sposób określimy zbiór informacji do zakodowania:
| { A, Ą, B, C, Ć, D, E, Ę, F, G, H, I, J, K, L, Ł, M, N, Ń, O, Ó, P, R, S, Ś, T, U, W, Y, Z, Ź, Ż, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, kropka, spacja } |
Wybrany zbiór zawiera \(44\) różne znaki. Potrzebujemy słówek binarnych o liczbie bitów równej:
| \[ {n\ge\log_244 = 5{,}4594\dots,\;n=6} \] |
\({6{-}\text{bitowe}}\) słówka binarne dają \({2^6=64}\) różnych kombinacji słówek bitowych kodu. My wykorzystamy tylko \(44\), zatem \(20\) słów kodowych pozostanie wolne, bez określonego znaczenia (możemy je w przyszłości wykorzystać na nowe znaki – np. literę X, której chwilowo nie potrzebujemy). Sam przydział słówek binarnych literkom na etapie projektowania jest zupełnie dowolny (dobrze jednak zastosować tutaj pewien schemat – w przyszłości może to zaowocować uproszczeniem przy sortowaniu alfabetycznym tekstów) – ważne jest jedynie to, aby każda literka otrzymała inny kod. W przeciwnym razie skąd byśmy wiedzieli, o którą literkę chodzi?. Możemy to zrobić tak:
|
|
|
|
Określiliśmy tzw. kod znakowy (ang. character code). W takiej postaci literki mogą już być przetwarzane przez komputery. Dla przykładu zakodujmy w tym systemie jakieś zdanie:
| M | I | Ś | U | S | Z | A | T | E | K | |
| \(010000\) | \(001011\) | \(011000\) | \(101011\) | \(011010\) | \(010111\) | \(011101\) | \(000000\) | \(011001\) | \(000110\) | \(001101\) |
| \(000000001110000000101011010000000000101011011111010100001111011011001011000000\) |
| \(000000\;001110\;000000\;101011\;010000\;000000\;101011\;011111\;010100\;001111\;011011\;001011\;000000\) |
| \(000000\) | \(001110\) | \(000000\) | \(101011\) | \(010000\) | \(000000\) | \(101011\) | \(011111\) | \(010100\) | \(001111\) | \(011011\) | \(001011\) | \(000000\) |
| A | L | A | M | A | Ż | Ó | Ł | W | I | A |
Teraz pokażemy sposób przedstawiania liczb naturalnych za pomocą bitów. Wyobraźmy sobie, iż żyjemy w takim dziwnym kraju (no, może tak bardzo tego nie musimy sobie wyobrażać, wystarczy się rozglądnąć), w którym wszystkie monety mają nominały równe potęgom liczby \(2\):
| Nominał | Potęga 2 |
|---|---|
| \(1\) | \(2^0\) |
| \(2\) | \(2^1\) |
| \(4\) | \(2^2\) |
| \(8\) | \(2^3\) |
| \(16\) | \(2^4\) |
| \(32\) | \(2^5\) |
| \(64\) | \(2^6\) |
| ... | ... |
Załóżmy, iż w tym dziwnym kraju wyszło zarządzenie, które głosi, iż wszystkie kwoty należy wypłacać najmniejszą możliwą liczbą monet. Za nieprzestrzeganie tego zarządzenia rząd nałożył olbrzymią karę \(2^{64}\). Cóż, nikt tyle pieniążków nie miał, zatem wszyscy rozpoczęli skrupulatne odmierzanie sum pieniężnych.
Z sumami będącymi potęgami liczby \(2\) nie ma problemu – wystarczy jedna moneta o właściwym nominale. Pozostałe sumy wyliczamy następująco:
Trzeba wypłacić \(157\). Aby monet było jak najmniej, każda o właściwym nominale powinna wystąpić co najwyżej raz. Ano zobaczmy:
Pierwszą monetą może być \(128\) (\(256\) byłoby za duże, a \(64\) musielibyśmy użyć dwukrotnie). Zatem płacimy \(128\). Pozostaje wciąż:
| \(157-128=29\) |
Najbliższą monetą będzie \(16\). Płacimy \(16\). Pozostaje:
| \(29-16=13\) |
Teraz płacimy \(8\). Pozostaje:
| \(13-8=5\) |
Płacimy \(4\). Pozostaje:
| \(5-4=1\) |
I na koniec wypłacamy \(1\).
Podsumujmy:
| \(157=128+16+8+4+1\) |
No dobrze, powiesz. Co to ma jednak wspólnego z bitami? A ma. Zwróć uwagę, iż przy wypłacie sumy podejmujemy dla poszczególnych nominałów monet jedną z decyzji:
| Wypłacić daną monetę | – \(1\) |
| Nie wypłacać monety | – \(0\) |
A to są przecież nasze kochane bity. Ułóżmy monety kolejno z prawa na lewo od najmniejszej do największej. Otrzymamy następujący ciąg nominałów:
| Nominał | ... | \(1024\) | \(512\) | \(256\) | \(128\) | \(64\) | \(32\) | \(16\) | \(8\) | \(4\) | \(2\) | \(1\) |
| Potęga 2 | ... | \(2^{10}\) | \(2^9\) | \(2^8\) | \(2^7\) | \(2^6\) | \(2^5\) | \(2^4\) | \(2^3\) | \(2^2\) | \(2^1\) | \(2^0\) |
Teraz pod tak wypisanymi nominałami zapisujemy dla danej sumy pieniężnej wypłaconą liczbę monet danego nominału:
| Nominał | ... | \(1024\) | \(512\) | \(256\) | \(128\) | \(64\) | \(32\) | \(16\) | \(8\) | \(4\) | \(2\) | \(1\) |
| Potęga 2 | ... | \(2^{10}\) | \(2^9\) | \(2^8\) | \(2^7\) | \(2^6\) | \(2^5\) | \(2^4\) | \(2^3\) | \(2^2\) | \(2^1\) | \(2^0\) |
| \(157=\) | \(0\) | \(0\) | \(0\) | \(1\) | \(0\) | \(0\) | \(1\) | \(1\) | \(1\) | \(0\) | \(1\) |
Ponieważ dana moneta może wystąpić co najwyżej raz, to pod nominałami zapisujemy tylko cyfry \(0\) lub \(1\). Jeśli cyfry potraktujemy teraz jako bity, otrzymamy zapis binarny danej liczby dziesiętnej:
| \(157_{(10)}={\dots}00010011101_{(2)}\) |
W zapisie tym bit o stanie \(1\) ma wartość odpowiadającej mu potęgi liczby \(2\). Bit o stanie \(0\) ma wartość \(0\). Aby obliczyć wartość całej liczby binarnej wystarczy zatem zsumować wartości bitów o stanie \(1\).
Oto inny przykład:
W dziwnym kraju na czeku bankier wypisał sumę pieniężną zaznaczając liczbę monet o kolejnych nominałach, które należy wypłacić klientowi banku. Zrobił to tak:
| \(1011101101\) |
Jaką sumę należy wypłacić? My już wiemy. Skoro poszczególne cyfry oznaczają liczbę monet o danym nominale, zapisujemy to tak:
| Nominał | \(512\) | \(256\) | \(128\) | \(64\) | \(32\) | \(16\) | \(8\) | \(4\) | \(2\) | \(1\) |
| Potęga 2 | \(2^9\) | \(2^8\) | \(2^7\) | \(2^6\) | \(2^5\) | \(2^4\) | \(2^3\) | \(2^2\) | \(2^1\) | \(2^0\) |
| SUMA = | \(1\) | \(0\) | \(1\) | \(1\) | \(1\) | \(0\) | \(1\) | \(1\) | \(0\) | \(1\) |
Teraz sumujemy nominały wypłaconych monet i otrzymujemy:
| \(512+128+64+32+8+4+1=749\) |
Proste? Jeśli nie, to przeczytaj to kolejny raz, aż zrozumiesz.
Formalnie rzecz biorąc, jeśli mamy \({n{-}\text{bitową}}\) liczbę binarną:
| \(b_{n-1}\;b_{n-2}\;\dots\;b_2\;b_1\;b_0,\) gdzie \(b_i=0\) lub \(1,\) dla \(i=0,1,2,\dots,n-1\) |
to jej wartość dziesiętną obliczamy zgodnie z poniższym wzorem (więcej na ten temat szukaj w rozdziale o liczbach):
| wartość = \(b_{n-1}\cdot2^{n-1}+b_{n-2}\cdot2^{n-2}+\dots+b_2\cdot2^2+b_1\cdot2^1+b_0\cdot2^0\) |
W rozdziale pokazaliśmy trzy sposoby kodowania informacji za pomocą bitów:
Bity dają nieograniczone możliwości kodowania informacji. Jeśli tylko znajdziemy zbiór wiadomości, które chcemy zakodować, a następnie określimy sposoby przypisania tym wiadomościom słówek bitowych, będziemy mogli zakodować je za pomocą bitów i przetwarzać na komputerach. Dlatego bity są tak potężnym narzędziem w rękach informatyków.
Zapamiętaj:Bity w świecie komputerów nie ograniczają się jedynie do kodowania różnych informacji – cała współczesna informatyka oraz technologia komputerowa jest na nich oparta. Komputery są maszynami bitowymi nie tylko w sensie przetwarzania danych, ale również w sensie swojej budowy – procesory, pamięci, porty wejścia/wyjścia – wszystkie te elementy mają budowę binarną. Dalsze rozdziały leksykonu opisują elementy logiczne, z których buduje się układy cyfrowe. Bity są podstawą funkcjonowania tych elementów. Zatem nie bez powodu komputery nazywamy binarnymi maszynami cyfrowymi. |
 |
| Zespół Przedmiotowy Chemii-Fizyki-Informatyki w I Liceum Ogólnokształcącym im. Kazimierza Brodzińskiego w Tarnowie ul. Piłsudskiego 4 ©2026 mgr Jerzy Wałaszek |
Materiały tylko do użytku dydaktycznego. Ich kopiowanie i powielanie jest dozwolone pod warunkiem podania źródła oraz niepobierania za to pieniędzy.
Pytania proszę przesyłać na adres email:
Serwis wykorzystuje pliki cookies. Jeśli nie chcesz ich otrzymywać, zablokuj je w swojej przeglądarce.
Informacje dodatkowe.
