Mikrokontrolery ST7FLITE19/29

Troszeczkę przez sentyment do ST6, troszeczkę ze względu na cenę i bogate „uzbrojenie” w układy peryferyjne, do kilku ostatnio budowanych przeze mnie urządzeń, postanowiłem użyć mikrokontrolera ST7FLITE29 oraz oprogramowania napisanego za pomocą kompilatora języka C dla ST7 firmy Metrowerks. Moim zdaniem to bardzo dobry mikrokontroler, dobrze wyposażony i doskonale działający. Oczywiście jak każdy – ma swoje wady i zalety, jednak przy odrobinie akcji marketingowej oraz lepszym zaopatrzeniu dystrybutorów, firma ST Microelectronics ma ogromną szansę na przełamanie hegemonii niektórych producentów na polskim rynku, również w zastosowaniach amatorskich. Niniejszy artykuł będzie próbą opisu moich doświadczeń i wrażeń z pracy nad aplikacjami z ST7FLITE19/29 i być może pozwoli zaoszczędzić komuś czas, którego osobiście potrzebowałem bardzo dużo.

Rodzina mikrokontrolerów ST7 jest bardzo obszerna i zawiera układy o różnej ilości wyprowadzeń, różnych układach peryferyjnych, przeznaczone do zastosowań w szerokiej gamie urządzeń: począwszy od sprzętu powszechnego użytku aż do motoryzacji, lotnictwa i urządzeń przemysłowych. W tym artykule skupię się na jednym z „najmniejszych” i najtańszych układów z rodziny ST7: ST7FLITE19 i bliźniaczym LITE29. ST7FLITE19 i ST7FLITE29 to praktycznie te same układy. Różnią się pomiędzy sobą jedynie rozmiarem pamięci FLASH (ten pierwszy posiada jej 4kB, ten drugi 8kB) i pamięci RAM (LITE19 ma jej 256 bajtów, LITE29 – 384 bajty). FLASH o rozmiarze 4kB w układzie LITE19, to może nie za wiele, ale udało mi się korzystając z kompilatora Metrowerks i nawet nie wykorzystując z pełnych 4 kB pamięci, zbudować kilka całkiem „poważnych” urządzeń.
Układ oferowany jest w obudowie o 20-tu wyprowadzeniach, w wersjach do montażu przewlekanego i powierzchniowego. Tutaj jedna uwaga: obudowy te różnią się między sobą rozmieszczeniem doprowadzeń! Nie można narysować w programie do projektowania płytek schematu dla wersji DIL i bezboleśnie przejść do wersji SMD, tylko przez zmianę podstawki. Zmiany wymaga cały symbol elementu!
Skoro już wspomniałem o schemacie i płytce, to przy okazji dwie bardzo ważne uwagi. Po pierwsze: bezpośrednio do doprowadzeń zasilania, tuż obok nóżek układu scalonego lub wręcz między nimi (doprowadzenia zasilania znajdują się obok siebie, więc nie ma z tym problemu) należy dołączyć kondensator blokujący! Typowo używam w tym miejscu kondensatora ceramicznego SMD w obudowie 1206, o pojemności 100 nF. Zarówno wcześniejsza seria ST6, jak i nowa ST7, są bardzo wrażliwe na obecność tego elementu. Jego brak powoduje czasami, w niektórych sytuacjach, zakłócenia w pracy mikrokontrolera. Niestety z doświadczenia wiem, że bardzo często konstruktorzy (również płytek testowych dla ST7!) zapominają o tym elemencie. Po drugie (zalecenie to również można znaleźć w PDF) wszystkie niewykorzystane wyprowadzenia należy dołączyć do +5V przez rezystor pull-up. Można je ewentualnie dołączyć do masy (również przez rezystor), ale tak, czy inaczej, nie powinno się pozostawiać ich nie podłączonych.

Rysunek 1. ST7FLITE19/29 w obudowie SO-20 do montażu SMD

Rysunek 2. ST7FLITE19/29 w obudowie DIP-20 do montażu przewlekanego

Porty wejścia / wyjścia

Producent wyposażył mikrokontroler w 15 wejść – wyjść, które przynależą do dwóch 8-bitowych portów PA i PB, przy czym PB jest zubożony o jeden bit. Każdy port posiada stowarzyszone ze sobą dwa rejestry: danych DR oraz kierunku OR. Każdy bit portu może pełnić indywidualną – zupełnie niezależną od funkcji innych bitów – rolę, będąc wejściem cyfrowym, analogowym (tylko port B!), lub wyjściem cyfrowym. Można więc zaprogramować ST7 tak, aby na przykład część portu pracowała jako linie wejściowe a część jako linie wyjściowe. Niektóre z linii mają pewne specjalne funkcje, związane z wbudowanymi w strukturę układami peryferyjnymi: przetwornikiem A/D, kontrolerem przerwań, timerami, układami interfejsowymi.

W tabeli 1 podano nastawy bitów rejestrów OR i DDR oraz zależne od nich funkcje portów. Nastawa jest prosta i nie wymaga żadnych specjalnych zabiegów. Ilustruje ją poniższy przykład programu, zawierający nastawę funkcji portu A i B, bez zmiany ich stanów:

  PADDR = 0x0C;        //PA2,3 - "push pull output" (wyjścia), reszta - "input" (wejścia)
  PAOR = 0x0C;
  PBDDR = 0x60;        //PB0..2 - "analog input" (wejście pomiarowe),
  PBOR = 0x60;         //PB5..6 - "push pull output" (wyjścia)

Oczywiście funkcję portu można zmieniać w czasie pracy aplikacji. Aby zmienić stan portu lub odczytać wartości przyłożonych do niego z zewnątrz stanów logicznych, należy posługiwać się odpowiednim rejestrem DR. Na przykład ustawienie bitów wyjściowych portu PA z powyższego przykładu na wartość „1” logicznej, może wyglądać jak niżej:

  PADR = 0x0C

Lub bezpieczniej, w postaci sumy logicznej:

  PADR |= 0x0C

Port A mikrokontrolera ma wyjścia o podwyższonej obciążalności, które mogą być użyte na przykład do bezpośredniego sterowania bramką triaka czy tyrystora, czy też zasilania niewielkiego wyświetlacza LED. Ich obciążalność wynosi aż 20 mA w stanie wysokim. Oczywiście sterując tego typu obciążeniami zawsze należy uwzględnić dopuszczalną dla danej temperatury otoczenia i rodzaju obudowy moc strat.

Przerwania

Czymś, co sprawiło mi bardzo dużo kłopotów, ze względu na pewne (być może złe) nawyki programowania nabyte przy stosowaniu innych mikrokontrolerów, były przerwania. Przyzwyczaiłem się do tego, że przerwania włącza się niejako na dwóch poziomach. Pierwszy z nich – globalny – zezwala na akceptowanie przerwań. Drugi – lokalny – pozwala na przyjmowanie przerwań od określonego urządzenia. W ST7 jest nieco inaczej. Ustawienie bitu zezwalającego na obsługę przerwań załącza obsługę przerwań zewnętrznych, które są niemaskowalne![1] Wyłączyć je można jedynie przez wyzerowanie bitu w rejestrze OR, jednak w ten sposób odłączany jest wewnętrzny rezystor pull-up. Miałem mnóstwo problemów z aplikacją, w której chciałem użyć wyłącznie przerwania wewnętrznego timera. Oczywiście przerwanie to generowane było poprawnie i CPU dobrze odmierzało czas, jednak nie wiedzieć czemu mój program przestawał funkcjonować w trakcie pracy... Dopiero żmudna analiza aplikacji wykazała mój błąd. Ale do rzeczy.
Na listingu 1 umieszczono kompletną tablicę wektorów przerwań. Wektory te umieszczane są na końcu adresów pamięci programu, począwszy od adresu 0xFFFF (wektor 0 leży zajmuje adresy 0xFFFE-0xFFFF, wektor 13-ty 0xFFE1-0xFFE0). Nieco mylące jest to, że w dokumentacji producent numeruje od 0 wektory przerwań od adresu 0xFFFA-0xFFFB (przerwanie generowane przez funkcję Auto Wake Up), natomiast producenci kompilatorów jako 0 uważają przerwanie generowane przez funkcję reset. W związku z tym, numeracja przerwań przesunięta jest o dwa wektory, pominięte przez producenta w numeracji (reset i trap).

Listing1. Wykaz wektorów przerwań

//przerwanie funkcji Auto Wake Up
interrupt 0x02 void auto_wakeup()
//przerwanie zewnętrzne numer 0
interrupt 0x03 void ei0()
//przerwanie zewnętrzne numer 1
interrupt 0x04 void ei1()
//przerwanie zewnętrzne numer 2
interrupt 0x05 void ei2()
//przerwanie zewnętrzne numer interrupt 0x06 void ei3()
//przepełnienie timera lite
interrupt 0x07 void lt_csr2()
//przerwanie timera PWM (AT Timer)
interrupt 0x08 void attmr_pwm()
//przepełnienie timera AT
interrupt 0x09 void attmr_ovf()
//capture input (timer LT)
interrupt 0x0A void lt_capture()
//przepełnienie timera LT
interrupt 0x0B void lt_ovf()
//przerwanie od portu SPI
interrupt 0x0C void spi_irq()

Przerwania zewnętrzne mogą być generowane, gdy stan linii portu A lub portu B zmienia się lub ma określony poziom. O tym, która to będzie linia, decyduje nastawa rejestru EISR, natomiast warunek zgłoszenia przerwania określa nastawa rejestru EICR. Jest to dobrze opisane w dokumentacji technicznej, nie będę wyważać otwartych już drzwi. Wspomnę tylko, że przerwanie zewnętrzne może być generowane, gdy:
- na wejściu pojawiło się narastające zbocze sygnału,
- na wejściu pojawiło się opadające zbocze sygnału,
- na wejściu pojawiło się narastające i opadające zbocze,
- na wejściu pojawiło się opadające zbocze lub panuje stan niski.
Inną grupę przerwań stanowią te generowane przez wbudowane układy peryferyjne. Z nimi nie ma zazwyczaj problemu, ponieważ wszystkie należą do grupy przerwań maskowanych: jednym słowem można je włączać i wyłączać (oczywiście za wyjątkiem tego od sygnału reset). Na listingu 2 umieszczono przykład programu wykorzystującego przerwanie timer’a LT generowane co 1/170 sekundy.

Listing 2. Przykład użycia funkcji obsługi przerwania timer’a LT

/***************************************************
Przykład obsługi przerwania timera LT,
Kompilator Metrowerks CodeWarrior
***************************************************/
#include "hidef.h"               //wspólne makra i definicje
#include "st7flite1_periph.h"    //funkcje obsługi układów peryferyjnych
#define TMRVALH 0x00
#define TMRVALL 0x5F
unsigned char irqcnt;
unsigned char sec1cnt = 0;
/***********************************************
  funkcja obsługi przerwania od przepełnienia
  timer'a (tylko odliczanie sekund)
***********************************************/
interrupt 0x0B void lt_ovf()
{
    ATCSR;                       //kasowanie flagi OVF przez pobranie wartości rejestru TCSR
    irqcnt++;
    if (irqcnt >= 170)
    {
        irqcnt = 0;
        sec1cnt++;
    }
}

void main()
{
    PADDR = 0xFF;                //linie portu A jako wyjściowe
    PAOR = 0x00;
                                 //nastawy przerwania timer'a
    ATRH = TMRVALH;              //do timer'a zapis stałej odświeżania; timer liczy
    ATRL = TMRVALL;              //do przepełnienia
    ATCSR = 0x12;                //załączone przerwanie od przep.timer'a
    EnableInterrupts;            //załączenie przerwań dla funkcji odmierzania czasu
    for (;;) PADR = sec1cnt;
}

Generator zegarowy

Przy okazji omawiania systemu przerwań oraz przykładu wykorzystania przerwania timera, nie sposób nie wspomnieć o generatorze (a właściwie generatorach) sygnału taktującego pracą timerów i CPU. ST7FLITE19/29 ma możliwość pracy z różnymi źródłami sygnału zegarowego:
- z rezonatorem kwarcowym o częstotliwości od 32768 Hz (kwarc zegarkowy) do 16 MHz,
- z wbudowanym, kalibrowanym generatorem RC (nie wymaga żadnych elementów zewnętrznych) o częstotliwości 1 MHz.
- z zewnętrznym generatorem sygnału zegarowego.
Na pierwszy rzut oka struktura generatora sygnału zegarowego wygląda na bardzo skomplikowaną. Układ ST7 oprócz „głównego” źródła sygnału zegarowego, posiada również źródła alternatywne, różniące się znacznie częstotliwością od częstotliwości podstawowego zegara CPU, umożliwiające pracę timerów z częstotliwością inną, niż ta, którą taktowane jest CPU. Jest to funkcja bardzo użyteczna i przydatna zwłaszcza, jeśli wykorzystuje się generator PWM. Te źródła alternatywne, to dwa generatory zsynchronizowane z częstotliwością podstawową przy pomocy pętli PLL, mogące generować częstotliwość będącą wielokrotnością x4 lub x8 częstotliwości podstawowej, załączane przy pomocy nastaw bitów opcji. Dla przykładu wyborem źródła sygnału zegarowego dla timera AT steruje nastawa rejestru ATCSR (bity CK0 – CK1). Ponownie odsyłam do dokumentacji technicznej producenta.
Częstotliwość generatora zegarowego jest wewnętrznie dzielona przez 2, co dla kwarcu 16MHz daje cykl maszynowy trwając 250ns. Tu jedna bardzo ważna uwaga. Domyślnie generator RC jest załączany przez producenta i chcąc dołączyć zewnętrzny kwarc, należy ustawić odpowiednie bity opcji przy pomocy programatora! Bity te uwzględniają również częstotliwości dołączonego kwarcu, dobierając odpowiedni czas startu mikrokontrolera. Jeśli zapomnimy o tej cesze, może się okazać, że szukamy błędu w nastawach PWM, podczas gdy mimo dołączonego rezonatora kwarcowego pracuje wewnętrzny generator RC i jest on powodem tego, że nie możemy ani uzyskać poprawnej rozdzielczości PWM, ani też właściwej uzyskiwanej z PWM częstotliwości.

Generator PWM

W strukturę LITE19/29 wbudowane są 4 prawie niezależne generatory PWM. To znaczy generowane przez nie częstotliwość jest taka sama, ale współczynnik wypełnienia może być indywidualnie ustawiany dla każdego z nich. Oprócz tego każdy z sygnałów PWM może być indywidualnie negowany, co daje możliwość odpowiedniego (najczęściej dla stopnia mocy) doboru fazy sygnału lub współczynnika wypełnienia przebiegu wyjściowego. Programowanie PWM jest przejrzyste i nie nastręcza żadnych trudności nawet początkującym. Na listingu 3 umieszczono przykład nastaw PWM, jednak zanim o konkretnych zastosowaniach, jeszcze garść uwag praktycznych.
Generator PWM wykorzystuje 12-bitowy timer AT. Częstotliwość sygnału wyjściowego PWM (jak wspomniano wcześniej: wspólna dla wszystkich kanałów) można wyliczyć jako F_{timera AT} / (4096 – zawartość rejestru ATR[2]). Rozdzielczość PWM (liczba nastaw współczynnika wypełnienia) w dużej mierze zależy od generowanej przezeń częstotliwości. Można ją wyliczyć jako (1/(4096 – zawartość rejestru ATR)) x 100%. Jak łatwo zauważyć, maksymalną rozdzielczość uzyskuje się wówczas gdy rejestr ATR ma wartość 0. Zawartość rejestru ATR zawsze musi być mniejsza, niż rejestru DCR[3].
Wyjścia generatora PWM nie mogą być dołączane dowolnie do wyprowadzeń mikrokontrolera. I tak kanałowi PWM0 odpowiada wyjście PA2, PWM1 – PA3, PWM2 – PA4 a PWM3 – PA5. Wyjścia generatora PWM dołączane są do linii portu po ustawieniu odpowiednich bitów rejestru PWMCR (bity OEx, na przykład OE0 dla PWM0). Jak wspomniano wcześniej, wyjście może być dołączone wprost lub przez negację. Wyborem polaryzacji steruje nastawa bitu OPx w rejestrze PWMxCSR (odpowiednio OP0 w PWM0CSR dla PWM0 itd.).
Zmiana współczynnika wypełnienia sygnału generowanego przez PWM następuje po zapisie do odpowiedniego rejestru DCR wartości nastawy oraz ustawieniu bitu 0 w rejestrze TRANCR, powodującego zapis nastawy do generatora PWM. Sam zapis wartości do DCR oprócz zmiany jego stanu, nie powoduje żadnych zmian sygnału wyjściowego!

Listing 3. Przykład nastaw generatorów PWM0 i PWM1

#define     TMRREFL    0x39
#define     TMRREFH    0x0F
...
ATCSR = 0x10;            //nastawy PWM, f=40kHz (kwarc 16MHz!)
ATRH = TMRREFH;          //8x10^6/(4096-ATRH:ATRL), ATR=0x0F38
ATRL = TMRREFL-1;
PWM0CSR = 0x02;          //sygnał PWM0 z inwersją
PWM1CSR = 0x00;          //sygnał PWM1 bez inwersji
PWMCR = 0x05;            //załączone wyjście PWM0 i PWM1
BREAKCR = 0;             //funkcja BREAK wyłączona
DCR1L = ADC.t.ADC_LData; //nastawa współczynnika wypełnienia przebiegu na wyjściu PWM0
DCR1H = ADC.t.ADC_HData;
TRANCR = 0x01;           //zezwolenie na zmianę PWM
...

10 bitowy przetwornik A/D

W strukturę mikrokontrolera wbudowany został 7-wejściowy przetwornik A/D umożliwiający pomiar napięcia. Przetwornik posiada na wejściu multiplekser analogowy, dołączający w danym momencie jedno z wejść portu B. Oznacza to w praktyce, że wykonywanie jednoczesnego pomiaru na wszystkich wejściach, nie jest możliwe. Napięciem odniesienia jest napięcie zasilające mikrokontroler. Jeśli napięcie zasilania ma wartość 5V, to bez załączonego wzmocnienia sygnału, rozdzielczość mierzonego napięcia wynosi w przybliżeniu 5mV (przetwornik ma słowo o długości 10 bitów). Jeśli nie jest to wystarczające, można załączyć wewnętrzny wzmacniacz, o stałym wzmocnieniu sygnału x8, umożliwiający uzyskanie rozdzielczości około 0,6mV, ale jednocześnie obniżający maksymalną wartość napięcia wejściowego przetwornika do wartości napięcie zasilania / 8 (około 0,6V przy zasilaniu 5V).
Myślę, że najlepszym przykładem użycia przetwornika będzie fragment programu służącego do pomiaru napięcia. W zależności od wartości napięcia na wejściu PB0, zmieniany będzie współczynnik wypełnienia przebiegu generowanego przez generator PWM0, umożliwiając na przykład regulację jasności świecenia diody LED, dołączonej do PA2.

Listing 4. Przykład wykorzystania przetwornika A/D do pomiaru napięcia na wejściu PB0 i zmiany jasności świecenia diody LED dołączonej do PA2 (kanał PWM0)

/*********************************************
Kompilator Metrowerks CodeWarrior dla ST7
F zegara = 16MHz
*********************************************/
#include  <hidef.h>
#include  "st7lib_config.h"
#include  "adc.h"                       //funkcje obsługi przetwornika ADC
#include  "adc_hr.h"
//definicje pomocniczych typów zmiennych
#define   BYTE unsigned char
#define   WORD unsigned int
#define   INT signed int
#define   DWORD unsigned long
//wartość odświeżająca rejestr licznika timera
#define   TMRREFR    0x0F39
#define   TMRREFL     0x39
#define   TMRREFH    0x0F
//makra używane w programie
#define ADC_Wait() while (!ADC_Test_Conversn_Complete()) //oczekiwanie pomiar na przez A/D

//zmienne globalne
union Konwersja
{
    WORD ADC_Data;                //dane z przetwornika A/D
    struct
    {
        BYTE ADC_HData;           //młodszy i starszy bajt osobno
        BYTE ADC_LData;
    } t;
} ADC;

//***************** deklaracje nagłówków funkcji *********************
WORD pomiar_napiecia(BYTE kanal);  //funkcja zwraca zawartość rejestru przetwornika A/D
//program główny
void main(void)
{
    BYTE key;
                                  //inicjalizacja portów
    PADDR = 0xFF;                 //PA – wyjścia typu otwarty dren
    PAOR = 0x00;
    PBDDR = 0x00;                 //PB - wejścia
    PBOR = 0x00;
    ATCSR = 0x10;                 //nastawy PWM, f=40kHz
    ATRH = TMRREFH;               //8x10^6/(4096-ATRH:ATRL), ATR=0x0F38
    ATRL = TMRREFL-1;
    PWMCR = 0x01;                 //załączone wyjście PWM0
    BREAKCR = 0;                  //funkcja BREAK wyłączona
    ADC_Init(ADC_DEFAULT);        //inicjalizacja przetwornika A/D
    for (;;)
    {                             //zmiana np. jasności świecenia diody LED
        ADC.ADC_Data = pomiar_napiecia(0);
        ADC.ADC_Data >>= 2;       //odrzucam 2 najmłodsze bity
        ADC.ADC_Data += TMRREFR;  //wartość DCR nie może być mniejsza, niż ATR
        if (ADC.ADC_Data > 0x0FFD) ADC.ADC_Data = 0x0FFD;
        DCR0L = ADC.t.ADC_LData;  //konwersja (unia) na dwa, pojedyncze bajty
        DCR0H = ADC.t.ADC_HData;
        TRANCR = 0x01;            //zezwolenie na zmianę stanu PWM
    }
}

//funkcja zwraca zawartość rejestru przetwornika A/D, przy wejściu podaje się numer
//bitu portu B (0..7); funkcje obsługi przetwornika A/D predefiniowane przez firmę ST,
//dołączone do bibliotek standardowych przez firmę Metrowerks
WORD pomiar_napiecia(BYTE kanal)
{
    ADC_Select_Channel(kanal);    //wybór kanału (wejścia) pomiarowego
    ADC_Enable();                 //załączenie konwersji (ADON=1)
    ADC_Wait();                   //oczekiwanie na zakończenie konwersji
    ADC_Disable();                //wyłączenie przetwornika (ADON=0)
    return (ADC_Conversn_Read()); //odczyt danych z rejestru przetwornika
}

Jedną z cech przetwornika jest bardzo duża impedancja wejściowa. Dzięki niej możliwy jest pomiar napięć przy minimalnym zaledwie obciążeniu mierzonego obwodu.

Programowanie w układzie (in-circuit)

Do zapisu programu w pamięci mikrokontrolera, używałem kupionego w firmie PROPOX programatora (http:// www.propox.com/) oraz darmowego oprogramowania ST7 Visual Develop (z ST7 Visual Programmer) dostępnego na stronie producenta mikrokontrolera (http://www.st.com/, w czasie pisania artykułu pod adresem http://mcu. st.com/mcu/modules.php?name=Content &pa=showpage&pid=44). 

Rysunek 3. Rozmieszczenie sygnałów na doprowadzeniach gniazda programatora firmy PROPOX.

Programator (STICK), oferowany również przez firmę ST, jest prosty w budowie i tani (około 40 złotych). Niestety dołącza się go do portu równoległego komputera, co jak dla mnie nie jest najlepszym rozwiązaniem. Składa się z kilku układów z serii TTL-LS i pracuje niezawodnie, nie licząc przypadków, gdy przekroczona zostanie wartość napięcia zasilającego mikrokontroler (programator zasilany jest z programowanej płytki). W moim przypadku skończyło się to wymianą 4 układów scalonych (mikrokontroler wytrzymał, programator nie), na szczęście dostępnych w sklepach. Pamięć programu zapisywana jest bardzo szybko. Programator szeregowy umożliwia również nastawę i zapis bitów opcji, sterujących wyborem źródeł sygnału zegarowego (dla CPU i timerów) oraz częstotliwości jego pracy.
Aby programator nie „przeszkadzał” w normalniej pracy mikrokontrolera, najlepiej portów PA5, PA6 i PB4 używać jako linii wejściowych, gniazdo programatora dołączyć bezpośrednio do doprowadzeń mikrokontrolera, a wejścia odseparować od niego przy pomocy rezystorów o wartości 4,7 kOhm. Mimo, iż według materiałów producenta takie odseparowanie jest wystarczające, to programator bardzo źle toleruje pojemności dołączone do wejścia PA6.

Na zakończenie...

Mam nadzieję, że ten krótki artykuł pomoże w zastosowaniach ST7FLITE19/29 we własnych aplikacjach. Trudno jest opisać wszystkie szczegóły w ramach kilku stron, nie pisząc wręcz podręcznika programowania. ST7 to mikrokontrolery o bardzo dużych możliwościach i śmiało można je polecić również hobbystom, ponieważ – mimo tak bogatych peryferii – cena na przykład mikrokontrolerów z serii LITE nie jest zbyt wygórowana. Również narzędzia (na przykład kompilator języka C firmy Metrowerks, czy Raisonance) dostępne są w wersjach demonstracyjnych, umożliwiających pisanie programów o kodach wynikowych od 4 do 8kB. Jest to całkiem sporo, nawet dla programu napisanego w języku C, nie wspominając już o asemblerze. O narzędziach, napiszę w następnym artykule.

Jacek Bogusz
j.bogusz@easy-soft.net.pl