Tablice

Wyobraź sobie, że do diody LED wysyłamy szybko zmienny sygnał cyfrowy:

Gdy sygnał osiąga wartość 1, dioda LED świeci. Gdy sygnał ma wartość 0, dioda LED jest zgaszona. Jeśli sygnał ten zmienia się odpowiednio szybko (np. 30 razy w ciągu sekundy), to oko nie zauważy mrugania diody, co wiąże się ze skończoną szybkością spostrzegania zmian w odbieranym obrazie. Na tej zasadzie działa kino ruchome. Na ekranie są wyświetlane nieruchome obrazy, jednak dzieje się to 25 razy na sekundę. Oko odbiera tę serię obrazów jako obraz ruchomy. To samo dzieje się tutaj - dla naszego oka dioda LED będzie świeciła światłem ciągłym.

Regulując wypełnienie sygnału (czas trwania impulsu o wartości 1 w stosunku do czasu trwania stanu 0) wpływamy na czas świecenia diody. Im dużej dioda świeci, tym więcej wyśle energii, co nasze oko rozpozna jako wzrost jasności. W ten sposób możemy sterować jasnością świecenia diody LED.

Regulacji wypełnienia dokonamy w pętli, która będzie cyklicznie wykonywana w programie. Przed pętlą diody będą gaszone. Gdy licznik pętli osiągnie określoną wartość, diody LED zostaną zapalone i w tym stanie dotrwają do zakończenia pętli.

Program mrugający diodami LED - wersja 1

Do płytki bazowej APP000 podłącz programator oraz płytkę aplikacyjną APP001. Na płytce APP001 ustaw obie zworki J0 i J1 w położenie górne. Uruchom aplikację Eclipse, utwórz w niej nowy projekt dla ATTINY13, po czym załaduj do edytora poniższy program, skompiluj go i prześlij przez programator do mikrokontrolera na płytce APP000.

/*
 * main.c
 *
 *  Created on: 01 paź 2015
 *      Author: Geo
 */

#include <avr/io.h>

int main(void)
{
    uint8_t i,w=0;
    DDRB  = 0b011111; // PB0...PB4 jako wyjścia
    PORTB = 0;        // Gasimy wszystkie diody
    while(1)
    {
        for(i = 0; i < 255; i++)
            if(i < w) PORTB = 0b11111; // Zapalamy wszystkie diody
            else      PORTB = 0;       // Wyłączamy diody
    	w++; // Modyfikujemy wypełnienie
    }
}

W programie pojawia się nowy rodzaj pętli. Jest to tzw. pętla iteracyjna. Iteracją nazywamy numerowany obieg pętli. W pętli iteracyjnej każdy obieg posiada swój numer. Do tego celu używamy dodatkowej zmiennej, którą nazywamy zmienną sterującą pętli lub po prostu licznikiem pętli (ang. loop counter). Pętla for pozwala w prosty sposób tworzyć pętle iteracyjne. Składnia jest następująca:

for(początek; kontynuacja; koniec) instrukcja;
for(początek; kontynuacja; koniec)
{
   instrukcje; // dowolna liczba instrukcji
}

Pętla for działa w sposób następujący:

Program działa w sposób następujący:

Program mrugający diodami LED - wersja 2

Drugi program jest małą modyfikacją pierwszego. Tutaj współczynnik wypełnienia rośnie od 0 do 255, po czym znów maleje do 0 itd. W efekcie dostajemy ładną pulsację światła LED.

/*
 * main.c
 *
 *  Created on: 01 paź 2015
 *      Author: Geo
 */

#include <avr/io.h>

int main(void)
{
    uint8_t i,w=0;
    int8_t d=1;
    DDRB = 0b011111; // PB0...PB4 jako wyjścia
    PORTB = 0;       // Gasimy wszystkie diody
    while(1)
    {
        for(i = 0; i < 255; i++)
            if(i < w) PORTB = 0b11111; // Zapalamy wszystkie diody
            else      PORTB = 0;       // Gasimy wszystkie diody
        w += d; // Modyfikujemy wypełnienie
        if((w == 255) || !w) d = -d;
    }
}

Poruszaj szybko obiema płytkami tam i z powrotem – zobaczysz wtedy efekt przerywanego światła diod. W dalszej części kursu pokażemy, jak podobne efekty uzyskiwać w sposób sprzętowy za pomocą wbudowanych w mikrokontroler urządzeń.

Program sterujący jasnością świecenia diod LED

Na płytce APP001 ustaw zworki J0 i J1 w położenie dolne (do linii PB0 i PB1 zostaną dołączone przyciski W0 i W1). Napiszemy program, który reguluje jasność świecenia diod za pomocą przycisków. Naciśnięcie W0 będzie powodowało zmniejszenie jasności, a naciśnięcie W1 zwiększy jasność.

/*
 * main.c
 *
 *  Created on: 03 paź 2015
 *      Author: Geo
 */

#include <avr/io.h>

int main(void)
{
    DDRB  = 0b011100; // Określamy kierunek linii PB0...PB4
    PORTB = 0b000011; // Oporniki podciągające na PB0 i PB1
    uint8_t w = 127;  // Wypełnienie 1/2
    uint8_t i,j;
    while(1)
    {
        for(j = 0; j < 5; j++)
            for(i = 0; i <= 254; i++)       // Pętla cyklu
                if(i < w) PORTB = 0b11111;  // Włączamy diody
                else      PORTB = 0b00011;  // Wyłączamy diody
      if(!(PINB & 0b01) && (w)) w--;        // Obsługa przycisków
      if(!(PINB & 0b10) && (w < 255)) w++;
    }
}

typ nazwa[liczba_elementów];

Przykład:

uint8_t a[10] // Tworzy tablicę a o 10 elementach

W programie można zdefiniować tyle tablic, ile zmieści się nam w pamięci. Tablicę możemy również zdefiniować podając w klamerkach wartości dla kolejnych jej komórek oddzielone przecinkami. W takim przypadku nie musimy podawać liczby elementów, gdyż kompilator sam ją ustali na podstawie liczby wartości.

Przykład:

int8_x[] = {1,7,-15,2}; // Powstanie tablica 4 elementowa o podanej zawartości

Gdy już mamy zdefiniowaną tablicę, to dostęp do poszczególnych komórek uzyskujemy poprzez nazwę tablicy oraz numer komórki, który nazywamy indeksem. Na przykład poniższy fragment programu umieszcza w dwóch komórkach tablicy a[ ] dane:

a[5] = 4;
a[7] = 12;

Komórka tablicy jest normalną zmienną i dlatego stosują się do niej wszystkie operacje, które wykonujemy na zmiennych.

Przykłady:

a[5]++;          // zawartość komórki a[5] jest zwiększana o 1
c = a[1] + a[5]; // do zmiennej c trafi suma komórek a[1] i a[5]
a[2] <<= 2;      // bity komórki a[2] zostaną przesunięte w lewo o 2 pozycje

W języku C indeksy rozpoczynają się od wartości 0. Zatem pierwsza komórka tablicy posiada indeks zero, np. a[0]. Jeśli tablica ma n komórek, to ostatnia z nich ma indeks n-1, np. dla tablicy 10-cio elementowej a ostatnią komórką jest a[9]. Musisz o tym pamiętać, ponieważ kompilator nie zgłosi błędu, jeśli w programie użyjesz komórki np. a[10], której w tablicy już nie ma:

int8_t b[5]; // W tablicy mamy: b[0] b[1] b[2] b[3] i b[4]
b[5] = 15;   // To jest błędna operacja dla tablicy b, gdyż b[5] nie ma!

Zaletą tablic jest to, że mogą być przetwarzane w pętlach.

Program tworzący efekt przesuwającego się światła

Program wykorzystuje tablice 5 elementowe do sterowania poszczególnymi diodami. Sama zasada regulacji oświetlenia zostaje taka sama. Różnica polega na tym, iż współczynnik wypełnienia w dla każdej z diod będzie przechowywany w osobnej komórce tablicy. Wartości tych współczynników są tak dobrane, aby światło emitowane przez diody nabierało lub traciło intensywność w różnym czasie. W efekcie otrzymamy płynnie przesuwający się "wąż" świetlny.

/*
 * main.c
 *
 *  Created on: 02 paź 2015
 *      Author: Geo
 */

#include <avr/io.h>

int main(void)
{
    uint8_t i,j;
    uint8_t w[] = {0,32,64,96,128}; // Wypełnienia
    int8_t  d[] = {4,4,4,4,4};      // Kierunki zmian
    DDRB = 0b011111;                // PB0...PB4 jako wyjścia
    while(1)
    {
        PORTB = 0;                  // Gasimy wszystkie diody
        for(i = 0; i < 96; i++)
            for(j = 0; j < 5; j++)  // Przeglądamy tablicę w[]
                if(i > w[j]) PORTB |= 1<<j; // Zapalamy odpowiednią diodę

        for(i = 0; i < 5; i++)      // Modyfikujemy wypełnienia
        {
            w[i] += d[i];
            if((w[i] == 200) || !w[i]) d[i] = -d[i];
    	}
    }
}

Poeksperymentuj z wartościami w programie. Zmniejszając zakres pętli i, powodujesz przyspieszenie ruchu węża. Zmniejszając wartości w tablicy d spowalniasz węża. jednak uważaj, aby pierwszy warunek w ostatniej instrukcji if był osiągalny, inaczej efekt przestanie działać poprawnie.

Drobna modyfikacja programu daje ciekawy efekt świetlny:

/*
 * main.c
 *
 *  Created on: 02 paź 2015
 *      Author: Geo
 */

#include <avr/io.h>

int main(void)
{
    uint8_t i,j;
    uint8_t w[] = {0,0,0,0,0};      // Wypełnienia
    int8_t  d[] = {1,5,3,2,7};      // Kierunki zmian
    DDRB = 0b011111;                // PB0...PB4 jako wyjścia
    while(1)
    {
        PORTB = 0;                  // Gasimy wszystkie diody
        for(i = 0; i < 96; i++)
            for(j = 0; j < 5; j++)  // Przeglądamy tablicę w[]
                if(i > w[j]) PORTB |= 1<<j; // Zapalamy odpowiednią diodę

        for(i = 0; i < 5; i++)      // Modyfikujemy wypełnienia
        {
            w[i] += d[i];
            if((w[i] > 200) || !w[i]) d[i] = -d[i];
    	}
    }
}

Czy potrafisz wyjaśnić działanie tego programu?

Program tworzący efekt typu "Cylon"

Kilka lat temu popularnością cieszył się serial "Battle Star Galactica", który również transmitowała nasza telewizja.  Cyloni byli inteligentnymi robotami walczącymi z ludźmi. W miejscu oczy roboty posiadały przesuwające się tam i z powrotem światło. Efekt ten możesz zaobserwować na filmie:

Poniższy program tworzy taki efekt na płytce APP001. Program wykorzystuje tablicę w  do przechowywania współczynników wypełnień.

/*
 * main.c
 *
 *  Created on: 03 paź 2015
 *      Author: Geo
 */

#include <avr/io.h>

int main(void)
{
    DDRB  = 0b011111; // Określamy kierunek linii PB0...PB4
    PORTB = 0;        // Gasimy wszystkie diody LED
    uint8_t w[5];     // Tablica wypełnień
    int8_t p=0,d=-1,i,j,k;
    while(1)
    {
        if((p >= 0) && (p <= 4)) w[p] = 255;
        for(i = 0; i < 5; i++) if(i != p) w[i] >>= 1;
        for(k = 0; k < 2; k++)     // Pętla spowalniająca
            for(i = 0; i < 127; i++)
                for(j = 0; j < 5; j++)
                    if(i < w[j]) PORTB |= 1 << j;    // Ustawiamy bit
                    else         PORTB &= ~(1 << j); // Zerujemy bit
        p += d;
        if((p == 6) || (p == -2)) d = -d;
    }
}

Program działa w sposób następujący:

Zamek szyfrowy

Na płytce APP001 ustaw zworki J0 i J1 w położeniu dolnym.

Zamek szyfrowy działa następująco:

/*
 * main.c
 *
 *  Created on: 03 paź 2015
 *      Author: Geo
 */

#include <avr/io.h>
#include <util/delay.h>


int main(void)
{
    uint8_t kod[] = {0b111,0b101,0b001,0b110}; // 7,5,1,6 - kod zamka
    uint8_t dat[4];     // Tutaj gromadzimy kod od użytkownika
    uint8_t i,c=0,k;    // Zmienne robocze

    DDRB  = 0b011100;   // Określamy kierunek linii PB0...PB4
    PORTB = 0b000011;   // Oporniki podciągające na PB0 i PB1

    while(1)
    {
        while(c < 4)    // Powtarzamy do wprowadzenie wszystkich cyfr
        {
            while((k = PINB & 0b11) == 0b11); // Czekamy na klawisz
            _delay_ms(10);      // Opóźnienie na wygaśnięcie drgań styków

            while((PINB & 0b11) != 0b11); // Czekamy na zwolnienie klawisza
            _delay_ms(10);      // Opóźnienie na wygaśnięcie drgań styków
            
            if(k & 1)
            {
        	dat[c++] = (PORTB >> 2) & 0b111; // Wprowadzamy kod do tablicy
        	for(i = 0; i < 5; i++)
        	{
        	    PINB = 0b11100;  // Mrugamy diodami
        	    _delay_ms(50);
        	}
        	PORTB = 0b00011;     // Zerujemy kod
            }
            else
        	PORTB += 0b100;      // Zwiększamy kod
        }

        // Teraz sprawdzamy poprawność kodu

        for(i = 0; i < 4; i++) if(dat[i] != kod[i]) while(1) PORTB=0b111111; // Blokada
        while(1) // Efekt zliczania binarnego
        {
    	    PORTB += 0b100;
            _delay_ms(100);
        }
    }
}

Pętla iteracyjna:

for(początek; kontynuacja; koniec) instrukcja;
for(początek; kontynuacja; koniec)
{
   instrukcje; // dowolna liczba instrukcji
}

Definicja tablicy:

typ nazwa[liczba_elementów];

Indeksy tablicy mają wartości od 0 do n - 1, gdzie n jest liczbą elementów.

Element tablicy jest normalną zmienną i stosują się do niego wszystkie operacje dozwolone dla zmiennych:

a[5] = 12;  // Przypisanie
a[2]++;     // Modyfikacja
c = a[1] - a[3]; // Wyrażenia

Przesunięcie elementów w górę w tablicy n-elementowej. Na pierwszą pozycję trafia wartość v. Ostatni element jest tracony

for(i = n - 1; i > 0; i--) a[i] = a[i - 1];
a[0] = v;

Przesunięcie elementów w dół w tablicy n-elementowej. Na ostatnią pozycję trafia wartość v. Pierwszy element jest tracony

for(i = 0; i < n - 1; i++) a[i] = a[i + 1];
a[n - 1] = v;