Mikrokontrolery ARM (LPC2134)
obsługa interfejsu UART (kanał 0)
w przerwaniach
Białystok, styczeń 2015
Andrzej Pawluczuk:  Mikrokontrolery ARM (LPC2134) obsługa interfejsu UART (kanał 0) w przerw. -2/16-
Copyright (C) 2015, Andrzej Pawluczuk. email: [e-mail]
Wszystkie prawa zastrzeżone.
Redystrybucja i używanie, czy to w formie tekstu z
ródłowego, czy w formie kodu
wykonywalnego, są dozwolone pod warunkiem spełnienia poniższych warunków:
1. Redystrybucja tekstu z
ródłowego musi zawierać powyższe zastrzeżenie
własności praw autorskich, niniejszą listę warunków oraz poniższe oświadczenie
o wyłączeniu odpowiedzialności.
2. Redystrybucja kodu wykonywalnego musi zawierać w dokumentacji lub w
innych materiałach dostarczanych wraz z kopią oprogramowania powyższe
zastrzeżenie własności praw autorskich, niniejszą listę warunków oraz poniższe
oświadczenie o wyłączeniu odpowiedzialności.
3. Nazwisko autora nie może być użyte celem sygnowania lub promowania
produktów pochodzących od tego opracowania, bez szczególnego, wyrażonego
na piśmie zezwolenia.
To opracowanie jest dostarczone przez posiadacza praw autorskich  takim, jakie jest .
Każda, dorozumiana lub bezpośrednio wyrażona gwarancja, nie wyłączając dorozumianej
gwarancji przydatności handlowej i przydatności do określonego zastosowania, jest
wyłączona. W żadnym wypadku posiadacz praw autorskich nie może być odpowiedzialny
za jakiekolwiek bezpośrednie, pośrednie, incydentalne, specjalne, uboczne i wtórne
szkody (nie wyłączając obowiązku dostarczenia produktu zastępczego lub serwisu,
odpowiedzialności z tytułu utraty walorów użytkowych, utraty danych lub korzyści, a
także przerw w pracy przedsiębiorstwa) spowodowane w jakikolwiek sposób i na
podstawie istniejącej w torii odpowiedzialności kontraktowej, całkowitej lub deliktowej
(wynikłej zarówno z niedbalstwa, jak i innych postaci winy), powstałe w jakikolwiek
sposób w wyniku używania lub mające związek z używaniem oprogramowania, nawet
jeśli o możliwości powstania takich szkód ostrzeżono.
Andrzej Pawluczuk:  Mikrokontrolery ARM (LPC2134) obsługa interfejsu UART (kanał 0) w przerw. -3/16-
mikrokontrolerach ARM z rodziny LPC213x obsługa kontrolera
transmisji szeregowej UART0 jest bardzo podobna do obsługi w
W
komputerach PC (w końcu w mikrokontrolerze zaimplementowany jest
standard prawie identyczny z komputerami PC  właściwie należałoby użyć czasu
przeszłego, gdyż współczesne komputery osobiste tracą interfejsy szeregowe na
rzecz USB, no cóż, takie czasy...). Do komunikacji z mikrokontrolerem od strony
komputera PC użyty jest standardowy program HyperTerminal (w moim komputerze
jeszcze występują dwa klasyczne porty do transmisji szeregowej, więc nie mam
problemów, innym sympatykom komunikacji poprzez porty szeregowe pozostaje
użycie odpowiednich przejściówek z USB na RS232, ale nie zawsze to działa jak
powinno). W programie tym (emulatora terminala) należy określić parametry
transmisji szeregowej następująco:
prędkość transmisji 9600,
8 bitów danych,
bez bitu parzystości,
z 1 bitem stopu.
Powyższe parametry odpowiadają parametrom transmisji szeregowej
zastosowanej z systemie z mikrokontrolerem ARM. W jego programie sterującym
wszystkie nastawy i współczynniki pozwalają uzyskać prędkość transmisji 9600 bps.
Do obsługi kontrolera UART0 przewidziane są następujące rejestry
Symbol Adres Dostęp Znaczenie
rejestru
U0RBR 0xE000 C000 odczyt rejestr, z którego odczytywany jest odebrany kod
(DLAB=0) znaku
U0THR 0xE000 C000 zapis rejestr, do którego wpisywany jest kod znaku do
(DLAB=0) nadania
U0DLL 0xE000 C000 zapis rejestr, do którego wpisywany jest młodsza część
(DLAB=1) odczyt podzielnika częstotliwości
U0DLM 0xE000 C004 zapis rejestr, do którego wpisywany jest starsza część
(DLAB=1) odczyt podzielnika częstotliwości
U0IER 0xE000 C004 zapis rejestr określający jakie zdarzenia generują przerwanie
(DLAB=0) odczyt
U0IIR 0xE000 C008 odczyt rejestr pozwalający zidentyfikować przyczynę
przerwania
U0FCR 0xE000 C008 zapis rejestr sterujący kolejką FIFO
U0LCR 0xE000 C00C zapis rejestr sterujący trybem transmisji
odczyt
U0LSR 0xE000 C014 odczyt rejestr statusu odbiornika
U0SCR 0xE000 C01C zapis rejestr bez przydzielonej funkcji (w układach 16C550
odczyt był dopełnieniem do ośmiu komórek w przestrzeni
adresowej)
Andrzej Pawluczuk:  Mikrokontrolery ARM (LPC2134) obsługa interfejsu UART (kanał 0) w przerw. -4/16-
Symbol Adres Dostęp Znaczenie
rejestru
U0ACR 0xE000 C020 zapis
odczyt
U0FDR 0xE000 C028 zapis rejestr zawierający dodatkowe współczynniki
odczyt pozwalające doprecyzować prędkość transmisji
U0TER 0xE000 C030 zapis rejestr, poprzez który można włączać/wyłączać
odczyt UART0
Wybrane rejestry (zaznaczone kolorem) mają tą samą alokację w przestrzeni
adresowej. Dostęp do poszczególnych rejestrów jest rozróżniany na podstawie typu
operacji (zapis/odczyt) oraz wskaz
nika DLAB (bit numer 7 w rejestrze U0LCR).
Przejście do adresacji DLAB następuje po ustawieniu bitu b7 w rejestrze U0LCR
(zapisaniu do wymienionego rejestru takiej sekwencji bitowej, gdzie ustawiony jest
odpowiedni bit).
Poniższe fragmenty programu prezentują najistotniejsze elementy.
(...)
#include "LPC213x.H"
#include "system.h"
#include "lcdlib.h"
#include "irqservice.h"
#include "serialconst.h"
#include "uart0int.h"
volatile ULONG GeneralTimerConter ;
static const UCHAR HelloText1 [ ] = "**** Hello! ****" ;
static const UCHAR HelloText2 [ ] = "UART0->interrupt" ;
static const UCHAR UARTHelloText1 [ ] = "Witaj koles przy terminalu." ;
static const UCHAR UARTHelloText2 [ ] = "Obsluga UART0 w przerwaniach.... ;
static const UCHAR ServicePromptText [ ] = "Nacinales: " ;
static const UCHAR ServiceControlCharText[] = "znak kontrolny" ;
static const UCHAR ServiceOutRangeText [ ]= "znak niestandardowy" ;
Teksty, jako stałe nie wpływają na algorytm działania.
static void T0_IRQHandler ( void ) __irq ;
static void T0_IRQHandler ( void )
W programie używana jest obsługa przerwań od licznika/zegara 0, która
służy do odmierzania wymaganych interwałów czasowych. Polega to na
tym, że w przerwaniach od licznika/zegara 0 inkrementowana jest pewna
zmienna, która obrazuje upływ czasu. Sposób odmierzania czasu jest
pokazany niżej (patrz: funkcja Wait).
{
GeneralTimerConter ++ ;
T0IR = 1 ;
VICVectAddr = 0 ;
} /* T0_IRQHandler */
Andrzej Pawluczuk:  Mikrokontrolery ARM (LPC2134) obsługa interfejsu UART (kanał 0) w przerw. -5/16-
static void HardwareInit ( void )
{
T0MR0 = 14999 ;
T0MCR = 3 ;
T0TCR = 1 ;
InstallIrqSerivce ( TIMER0_INT , ( ULONG ) T0_IRQHandler ) ;
} /* HardwareInit */
static void EnvirInit ( void )
{
InitLCDEnvir ( ) ;
UART0InitEnvir ( ) ;
Użyta jest właściwa funkcja do odpowiedniego określenia środowiska
pracy kontrolera UART0 oraz zainicjowania obsługi jego przerwań.
} /* EnvirInit */
static void SoftInit ( void )
{
GeneralTimerConter = 0 ;
Funkcja przeznaczona do zainicjowania stanu zmiennych programu. W
tym programie sprowadza się to do wyzerowania licznika przerwań do
odmierzania upływu czasu.
} /* SoftInit */
static void Wait ( ULONG Ticks )
{
ULONG StartTimer ;
ULONG TimeDiff ;
/*-------------------------------------------*/
StartTimer = GeneralTimerConter ;
for ( ; ; )
{
TimeDiff = GeneralTimerConter - StartTimer ;
if ( TimeDiff > Ticks )
break ;
} /* for */ ;
Funkcja przeznaczona do odmierzenie określonego interwału czasu.
Zrealizowane jest to w następujący sposób:
przez pętlą zapamiętany jest stan zmiennej, w której przechowywany
jest aktualny stan licznika przerwań (ten licznik jest inkrementowany
przez funkcję obsługi przerwań od licznika/zegara 0, patrz wyżej
funkcja T0_IRQHandler),
w pętli obliczana jest liczba będąca różnicą między aktualnym
stanem licznika przerwań a zapamiętanym przed realizacją pętli,
Andrzej Pawluczuk:  Mikrokontrolery ARM (LPC2134) obsługa interfejsu UART (kanał 0) w przerw. -6/16-
jeżeli obliczona różnica jest większa niż wymagana (wniesiona do
funkcji w parametrze), to następuje wyjście z pętli (warto tu
zauważyć, że powyższy algorytm jest prawdziwy nawet jeżeli w
trakcie odczekiwania nastąpi przekręcenie /przepełnienie/ licznika
GeneralTimerConter),
} /* Wait */
static void Service ( UCHAR Ch )
{
Funkcja do  utylizacji odebranego z UART0 znaku.
/*-------------------------------------------*/
UART0SendString ( ServicePromptText ) ;
if ( Ch < 0x20 )
{
UART0SendString ( ServiceControlCharText ) ;
} /* if ... */
else
{
if ( Ch >= 0x80 )
{
UART0SendString ( ServiceOutRangeText ) ;
} /* if ... */
else
{
UART0Send ( Ch ) ;
} /* if ... else */ ;
} /* if ... else */ ;
UART0SendNewLine ( ) ;
Użyte są właściwe wersje funkcji do  smarowania po ekranie terminala
(emulatora terminala).
} /* Service */
int main ( void )
{
SysInit ( ) ;
HardwareInit ( ) ;
EnvirInit ( ) ;
SoftInit ( ) ;
UART0Init( PCLK , N81Mode , 9600 , IER_RBRIntEn | IER_THREIntEn ) ;
Użyta jest właściwa funkcja do obsługi kontrolera UART0.
EnableIRQ ( ) ;
Wait ( 200 ) ;
InitLCD ( ) ;
ClrScrLCD ( ) ;
WriteTextLCD ( HelloText1 ) ;
NewLineLCD ( ) ;
WriteTextLCD ( HelloText2 ) ;
Andrzej Pawluczuk:  Mikrokontrolery ARM (LPC2134) obsługa interfejsu UART (kanał 0) w przerw. -7/16-
UART0SendNewLine ( ) ;
UART0SendString ( UARTHelloText1 ) ;
UART0SendNewLine ( ) ;
UART0SendString ( UARTHelloText2 ) ;
UART0SendNewLine ( ) ;
Użyte są właściwe funkcje do obsługi kontrolera UART0.
for ( ; ; )
{
if ( UART0DataPresent ( ) )
Użyta jest właściwa funkcja do obsługi kontrolera UART0.
{
Service ( UART0GetData ( ) ) ;
Użyta jest właściwa funkcja do obsługi kontrolera UART0.
} /* if */ ;
} /* loop */ ;
} /* main */
Moduł obsługi UART0 w przerwaniach
(pliki uart0int.h i uart0int.c)
(...)
#ifndef _UART0_
#define _UART0_
#include "types.h"
extern void UART0InitEnvir ( void ) ;
extern void UART0Init ( ULONG /* PeriphClk */ ,
UCHAR /* SerialMode */ ,
ULONG /* SerialSpeed */ ,
ULONG /* InterruptEnable */ ) ;
extern void UART0InputReset ( void ) ;
extern void UART0Send ( UCHAR /* Data */ ) ;
extern void UART0SendString ( const UCHAR * /* String */ ) ;
extern ULONG UART0DataPresent ( void ) ;
extern UCHAR UART0GetData ( void ) ;
extern void UART0SendNewLine ( void ) ;
#endif
(...)
Andrzej Pawluczuk:  Mikrokontrolery ARM (LPC2134) obsługa interfejsu UART (kanał 0) w przerw. -8/16-
#include "LPC213x.h"
#include "irqservice.h"
#include "system.h"
#include "UART0int.h"
#include "serialconst.h"
#define InpSerialBuffSize 64
#define OutSerialBuffSize 128
Stałe określające wielkości buforów cyklicznych związanych z
nadajnikiem oraz odbiornikiem UART.
typedef struct {
USHORT RdDataPointer ;
USHORT WrDataPointer ;
UCHAR Buffer [ InpSerialBuffSize ] ;
} InpSerialBufferRecT ;
Struktura bufora cyklicznego związanego z operacjami odbioru znaków.
typedef struct {
USHORT RdDataPointer ;
USHORT WrDataPointer ;
USHORT BusyStatus ;
UCHAR Buffer [ OutSerialBuffSize ] ;
} OutSerialBufferRecT ;
Struktura bufora cyklicznego związanego z operacjami nadawania znaków.
static volatile InpSerialBufferRecT UART0InpBuffer ;
static volatile OutSerialBufferRecT UART0OutBuffer ;
Utworzone bufory cykliczne. Z racji współdzielenia zmiennych z
funkcjami obsługi przerwań, zmienne te mają kwalifikator volatile, by nie
dopuścić do powstania pętli bez wyjścia.
static void UART0IrqHandler ( void ) __irq ;
static void UART0IrqHandler ( void )
Funkcja obsługi przerwania. Układ UART generuje jeden sygnał
przerwania. Z tego względu w implementacji obsługi przerwania należy
rozpoznać przyczynę (oczywiście bez sygnału zgłoszenia przerwania od
zmiany wejściowych linii modemowych), w wyniku której został
wygenerowany sygnał przerwania (chyba, że UART jest skonfigurowany
do generowania przerwania jedynie od jednego zdarzenia).
{
UCHAR U0IrqStatus ;
UCHAR Data ;
/*-------------------------------------------*/
for ( ; ; )
Andrzej Pawluczuk:  Mikrokontrolery ARM (LPC2134) obsługa interfejsu UART (kanał 0) w przerw. -9/16-
Układ UART może wygenerować przerwanie sygnalizujące kilka zdarzeń,
które mogą zaistnieć jednocześnie. W pętli należy rozpoznać przyczynę
przerwania i odpowiednio je obsłużyć. Czynności te są powtarzane tak
długo, jak długi układ UART sygnalizuje przerwanie.
{
U0IrqStatus = U0IIR ;
Przyczynę przerwania należy rozpoznać na podstawie informacji
odczytanej z rejestru U0IIR.
if ( U0IrqStatus & IIR_PEND )
{
Jeżeli w odczytanych danych ustawiony jest najmłodszy bit, to oznacza, że
układ UART nie zgłasza przerwania (stała IIR_PEND selekcjonuje
najmłodszy bit).
VICVectAddr = 0 ;
return ;
} /* if */ ;
switch ( ( U0IrqStatus >> 1 ) & 0x07 )
Jeżeli najmłodszy bit ma wartość '0', to na kolejnych 3 bitach określona jest
przyczyna wygenerowania sygnału przerwania. Po przesunięciu zawartości
odczytanego statusu o jeden bit w prawo i wyselekcjonowaniu 3 bitów,
należy przejść do właściwego wariantu pozwalającego na właściwą
obsługę przerwania.
{
case IIR_RLS : /* 0 1 1 - reciever status */
Jeżeli jest to przerwanie od błędu odbiornika (błąd ranki, parzystości,
sygnał break itp.), należy odczytać rejestr (odczyt gasi te przerwanie). W
programie nie jest ono obsługiwane.
Data = U0LSR ;
break ;
case IIR_CTI : /* 1 1 0 - Character Time-out Indicator */
case IIR_RDA : /* 0 1 0 - reciever data */
Jeżeli jest to przerwanie od odbiornika (odebrano poprawny znak), należy
odczytany znak i umieścić go w buforze cyklicznym odbiornika do
póz
niejszej  konsumpcji .
Data = U0RBR ;
UART0InpBuffer . Buffer [ UART0InpBuffer . WrDataPointer ] = Data ;
UART0InpBuffer . WrDataPointer ++ ;
if ( UART0InpBuffer . WrDataPointer >= InpSerialBuffSize )
UART0InpBuffer . WrDataPointer = 0 ;
break ;
Andrzej Pawluczuk:  Mikrokontrolery ARM (LPC2134) obsługa interfejsu UART (kanał 0) w przerw. -10/16-
case IIR_THRE : /* 0 0 1 - transmitter */
Jeżeli jest to przerwanie od nadajnika (zostały zakończone operacje
związane z nadaniem ostatniego znaku i UART gotowy jest do nadania
kolejnego). W przypadku włączenia kolejki FIFO można nadać
jednocześnie kilka znaków (doputy odpowiednia flaga w rejestrze
statusowym na to pozwala).
while ( U0LSR & LSR_THRE )
{
if ( UART0OutBuffer.RdDataPointer == UART0OutBuffer.WrDataPointer )
{
UART0OutBuffer . BusyStatus = 0 ;
break ;
Badane jest, czy bufor cykliczny zawiera jeszcze jakiekolwiek dane do
wysłania. Jeżeli nie, to ustawiana jest informacja, że UART jest w stanie
bezczynnym.
} /* if */ ;
Data = UART0OutBuffer . Buffer [ UART0OutBuffer . RdDataPointer ] ;
UART0OutBuffer . RdDataPointer ++ ;
if ( UART0OutBuffer . RdDataPointer >= OutSerialBuffSize )
UART0OutBuffer . RdDataPointer = 0 ;
U0THR = Data ;
W przeciwnym wypadku, nadawany jest kolejny znak.
} /* while */ ;
break ;
default : /* Unknown */
Nierozpoznane przerwanie, sytuacja, która nie powinna się zdarzyć.
Data = U0LSR ;
Data = U0RBR ;
Data = U0MSR ;
break ;
} /* switch */ ;
} /* while */ ;
} /* UART0IrqHandler */
static void UART0Delay ( ULONG cnt )
{
while ( cnt -- )
{
asm volatile ( "nop" ) ;
} /* while */ ;
} /* UART0Delay */
void UART0InputReset ( void )
{
UART0InpBuffer . RdDataPointer = 0 ;
UART0InpBuffer . WrDataPointer = 0 ;
Andrzej Pawluczuk:  Mikrokontrolery ARM (LPC2134) obsługa interfejsu UART (kanał 0) w przerw. -11/16-
} /* UART0InputReset */
static void UART0OutputReset ( void )
{
UART0OutBuffer . RdDataPointer = 0 ;
UART0OutBuffer . WrDataPointer = 0 ;
UART0OutBuffer . BusyStatus = 0 ;
} /* UART0OutputReset */
void UART0InitEnvir ( void )
Zainicjowanie środowiska pracy układu UART. Odpowiednie piny portu
skojarzone z UART0 są przyłączone do kontrolera (umożliwiają połączenie
odpowiednich pinów znajdujących się w obrębie portu 0 z kontrolerem
UART0).
{
PINSEL0 &= ~ 0x0000000F ;
PINSEL0 |= 0x00000005 ;
} /* UART0InitEnvir */
void UART0Init ( ULONG PeriphClk ,
UCHAR SerialMode ,
ULONG SerialSpeed ,
ULONG InterruptEnable )
Funkcja do zainicjowania pracy UART (określenie trybu i prędkości
transmisji).
{
ULONG Fdiv ;
ULONG Fmod ;
ULONG LDivider ;
ULONG HDivider ;
ULONG cpsr ;
/*-------------------------------------------*/
cpsr = DisableIRQ ( ) ;
Konfigurowanie układu UART może w trakcie wygenerować przerwanie,
więc wszystkie czynności są robione przy zablokowanych przerwaniach.
U0IER = 0 ;
Wstępne określenie, że UART nie zgłasza przerwań.
UART0InputReset ( ) ;
UART0OutputReset ( ) ;
Wyzerowanie obu buforów cyklicznych.
Fdiv = ( PeriphClk / 16 ) / SerialSpeed ;
Fmod = ( PeriphClk / 16 ) % SerialSpeed ;
Andrzej Pawluczuk:  Mikrokontrolery ARM (LPC2134) obsługa interfejsu UART (kanał 0) w przerw. -12/16-
if ( ( Fmod << 1 ) >= SerialSpeed )
Fdiv ++ ;
LDivider = Fdiv % 256 ;
HDivider = Fdiv / 256 ;
Obliczenie nastaw podzielnika sygnału taktującego by uzyskać żądaną
prędkość transmisji (istnieje możliwość doprecyzowania podzielników, ale
tu nie jest ona wykorzystana).
U0LCR = 0x80 ;
Przejście do trybu DLAB poprzez ustawienie odpowiedniego bitu w
rejestrze U0LCR.
U0DLL = LDivider ;
U0DLM = HDivider ;
Zapis wyliczonych podzielników do odpowiednich rejestrów.
U0LCR = SerialMode ;
Wyjście z trybu DLAB poprzez wpisanie do rejestru sterującego kodu
określającego tryb transmisji (parametr SerialMode jako jedna ze stałych
określających tryb transmisji nie ma ustawionego najwyższego bitu).
U0FCR = 0 ;
Skonfigurowanie kolejki FIFO (praca bez kolejki).
InstallIrqSerivce ( UART0_INT , ( ULONG ) UART0IrqHandler ) ;
Zainstalowanie wektora przerwań związanego z obsługą sygnałów
generowanych przez UART0. Funkcja (UART0IrqHandler) musi być
odpowiednia do obsługi przerwań.
U0IER = InterruptEnable ;
Określenie jakie zdarzenia powodują wygenerowanie sygnału przerwania
(parametr wywołania w przykładowym programie umożliwia zgłaszania
przerwań od nadajnika oraz odbiornika UART).
RestoreIRQ ( cpsr ) ;
Powrót do stanu przerwań jakie obowiązywały na początku funkcji.
} /* UART0Init */
void UART0Send ( UCHAR Data )
{
USHORT WStop ;
ULONG cpsr ;
Andrzej Pawluczuk:  Mikrokontrolery ARM (LPC2134) obsługa interfejsu UART (kanał 0) w przerw. -13/16-
/*-------------------------------------------*/
cpsr = DisableIRQ ( ) ;
if ( ! UART0OutBuffer . BusyStatus )
{
U0THR = Data ;
UART0OutBuffer . BusyStatus = 1 ;
} /* if ... */
else
{
for ( ; ; )
{
WStop = UART0OutBuffer . WrDataPointer + 1 ;
if ( WStop >= OutSerialBuffSize )
WStop = 0 ;
if ( WStop != UART0OutBuffer . RdDataPointer )
{
UART0OutBuffer . Buffer [ UART0OutBuffer . WrDataPointer ] = Data ;
UART0OutBuffer . WrDataPointer = WStop ;
break ;
} /* if ... */
RestoreIRQ ( cpsr ) ;
UART0Delay ( 10 ) ;
cpsr = DisableIRQ ( ) ;
} /* for */ ;
} /* if ... else */ ;
RestoreIRQ ( cpsr ) ;
} /* UART0Send */
void UART0SendString ( const UCHAR * String )
{
while ( * String )
{
UART0Send ( * String ) ;
String ++ ;
} /* while */ ;
} /* UART0SendString */
ULONG UART0DataPresent ( void )
{
ULONG Result ;
ULONG cpsr ;
/*-------------------------------------------*/
Result = FALSE ;
cpsr = DisableIRQ ( ) ;
if ( UART0InpBuffer . RdDataPointer != UART0InpBuffer . WrDataPointer )
{
Result = TRUE ;
} /* if */ ;
RestoreIRQ ( cpsr ) ;
return ( Result ) ;
} /* UART0DataPresent */
UCHAR UART0GetData ( void )
{
UCHAR Data ;
ULONG cpsr ;
/*-------------------------------------------*/
cpsr = DisableIRQ ( ) ;
Andrzej Pawluczuk:  Mikrokontrolery ARM (LPC2134) obsługa interfejsu UART (kanał 0) w przerw. -14/16-
if ( UART0InpBuffer . RdDataPointer == UART0InpBuffer . WrDataPointer )
{
Data = 0 ;
} /* if ... */
else
{
Data = UART0InpBuffer . Buffer [ UART0InpBuffer . RdDataPointer ] ;
UART0InpBuffer . RdDataPointer ++ ;
if ( UART0InpBuffer . RdDataPointer >= InpSerialBuffSize )
UART0InpBuffer . RdDataPointer = 0 ;
} /* if ... else */ ;
RestoreIRQ ( cpsr ) ;
return ( Data ) ;
} /* UART0GetData */
void UART0SendNewLine ( void )
{
UART0Send ( '\r' ) ;
UART0Send ( '\n' ) ;
} /* UART0SendNewLine */
Do podłączenia zestawu ZL9ARM z mikrokontrolerem ARM z komputerem
PC poprzez kontroler UART0 należy użyć przewodu bez linii modemowych. Nie
wynika to z tego, że UART0 nie obsługuje linii modemowych, lecz z powodu, że w
tym zestawie można programować (ładować kod do pamięci FLASH
mikrokontrolera w trybie IAP) poprzez UART0 używając programu FLASHMAGIC.
Specyfiką tego trybu jest to, że w trakcie tej operacji określone linie modemowe
mają pewne znaczenie sprzętowe wykorzystywane w trakcie ładowania kodu do
mikrokontrolera w trybie IAP.
Zastosowanie do komunikacji programu HyperTerminal wchodzącego w
skład windozy z połączeniem za pomocą kabla pełnomodemowego może okazać się
porażką, gdyż geniusz tego programu oczywiście wysteruje linie modemowe
stwarzając problemy dla fajnego zestawu z ARM'em (z drugiej strony konstruktorzy
zestawu ZL9ARM mogliby wykazać się większą wyobraz
nią i zawrzeć bardziej
użytkowe rozwiązania niż przekładanie za każdym jazem określonej zworki). Tępota
umysłowa programu emulatora terminala nie przewiduje zakazania grzebania w
liniach modemowych, toteż jedynym wyjściem jest fizyczne odcięcie gnoja od
ślicznego ARM'ika (należy użyć kabla 3-żyłowego). Wtedy to ma szanse pokazać, że
działa normalnie.
Andrzej Pawluczuk:  Mikrokontrolery ARM (LPC2134) obsługa interfejsu UART (kanał 0) w przerw. -15/16-
Andrzej Pawluczuk:  Mikrokontrolery ARM (LPC2134) obsługa interfejsu UART (kanał 0) w przerw. -16/16-
Po zaprogramowaniu można podziwiać działanie programu po
skomunikowaniu się z zestawem poprzez emulator terminala HyperTerminal.