Systemy Wbudowane i Mikroprocesory - eti.pg.edu.pl · PDF file• Kompilator języka C – MPLAB_C18_Libraries_ , MPLAB_C18_Getting_Started.pdf, MPLAB_C18_User_Guide_51288j.pdf •

1

Systemy Wbudowane i

Mikroprocesory

Laboratorium

Części 1, 2

Politechnika Gdańska Wydział Elektroniki, Telekomunikacji i Informatyki

Gdańsk 2012

2

3

Spis treści Część 1 Mikrokontroler PIC18F4520 Ćwiczenie 1. Podstawowe właściwości oraz tryb oszczędzania energii mikrokontrolera rodziny PIC ................ 7

Ćwiczenie 2. Współpraca mikrokontrolera PIC z klawiaturą i wyświetlaczem .................................................. 10

Ćwiczenie 3. Sprzętowy interfejs szeregowy RS232 .......................................................................................... 13

Ćwiczenie 4. Komunikacja mikrokontrolera PIC z urządzeniami z interfejsem I2C ............................................ 14

Część 2 Mikrokontroler ATMega128

Ćwiczenie 5. Układy czasowe i przerwania zegarowe ....................................................................................... 19

Ćwiczenie 6. Wyświetlacz LCD ........................................................................................................................... 21

Ćwiczenie 7. Przetwornik analogowo-cyfrowy ................................................................................................. 23

Ćwiczenie 8. Magistrala 1-Wire ......................................................................................................................... 25

Sprzęt wykorzystywany w laboratorium

Płytka demonstracyjna PICDEM 2 PLUS................................................................................................................ 29

Programator MPLAB ICD3..................................................................................................................................... 32

Układ ewaluacyjno-uruchomieniowy EVB503 ...................................................................................................... 33

Programator JTAGICE mkII .................................................................................................................................... 36

Dodatki Dodatek A. Programowanie mikrokontrolera PIC18F4520 w języku C.............................................................. 39

Dodatek B. Tworzenie projektu, kompilacja oraz uruchamianie programów w środowisku MPLAB ............... 44

Dodatek C. Układ laboratoryjny Keybord + Display ........................................................................................... 48

Dodatek D. Obsługa klawiatury matrycowej ..................................................................................................... 50

Dodatek E. Interfejs szeregowy RS232 .............................................................................................................. 56

Dodatek F. Interfejs I2C ...................................................................................................................................... 61

Dodatek G. Programowanie mikrokontrolera ATMega128 w języku C ............................................................. 66

Dodatek H. Tworzenie projektu, kompilacja oraz uruchamianie programów w środowisku AVR Studio ......... 81

Dodatek I. Układy czasowe 8-bitowe (Timer0) .................................................................................................. 85

Dodatek J. Wyświetlacz LCD .............................................................................................................................. 92

Dodatek K. Przetwornik analogowo cyfrowy ................................................................................................... 101

Dodatek L. Magistrala 1-Wire .......................................................................................................................... 106

4

5

Część 1

Ćwiczenia 1-4 Mikrokontroler PIC18F4520

6

7

Ćwiczenie 1. Podstawowe właściwości oraz tryb oszczędzania energii mikrokontrolera rodziny PIC Wykorzystywany sprzęt

• Układ laboratoryjny PICDEM 2 plus

• Układ programatora MPLAB ICD 3

• Komputer z oprogramowaniem

Cel ćwiczenia Poznanie budowy, podstawowych właściwości, trybu oszczędzania energii i specyfiki programowania w języku Asembler oraz C mikrokontrolera PIC

Szczegółowe zagadnienia

• Podstawowe instrukcje mikrokontrolera

• Pętle, instrukcje warunkowe

• Czas wykonywania instrukcji

• Zwłoki czasowe

• Porty wej/wyj

• Instrukcja SLEEP - wyłączenie mikrokontrolera • Watchdog

• Preskaler

• Kontynuacja programu po restarcie

Zadanie 1

• Napisać program zapalający i gaszący w wybranej sekwencji diody LED, podłączone do czterech portów mikrokontrolera w języku Asembler oraz C

• Każda dioda powinna świecić przez inny czas

• Do określenia odstępów czasu należy wykorzystać: o (asembler) pętle opóźniające, instrukcje dekrementacji i skoku warunkowego

oraz rejestry ogólnego przeznaczenia (GPR) jako liczniki o (C) funkcję delay() , inkrementację zmiennej

• Skompilować program

• Zaprogramować układ

• Sprawdzić, czy program działa zgodnie z założeniami

Zadanie 2

• Napisać program zapalający i gaszący w wybranej sekwencji diody LED, podłączone do czterech portów mikrokontrolera w języku Asembler oraz C

• Procesor przez większość czasu musi pozostawać w stanie Sleep, jako licznik czasu wykorzystując watchdoga wraz z preskalerem

• Po wciśnięciu klawisza Reset lub włączeniu zasilania powinny zapalić się na krótki czas wszystkie cztery diody, następnie program ma generować niekończącą się sekwencję błysków


8



Potrzebne informacje • Opis układu laboratoryjnego – PICDEM_2_Plus_Users_Guide.pdf

• Definicje nazw rejestrów (asembler) – plik nagłówkowy P18F4520.INC

• Definicje nazw rejestrów (C) – p18f4520.h

• Karta katalogowa mikrokontrolera – PIC18F4520_Data_Sheet.pdf

• Opis środowiska MPLAB – MPLAB_IDE_User_Guide_51519c.pdf

• Kompilator języka Asembler – MPASM_User_Guide.pdf

• Kompilator języka C – MPLAB_C18_Libraries_51297f.pdf, MPLAB_C18_Getting_Started.pdf, MPLAB_C18_User_Guide_51288j.pdf

• Tworzenie projektu, kompilacja oraz uruchamianie programów w środowisku MPLAB – dodatek B

Uwagi do realizacji programu • Na początku pliku źródłowego należy włączyć plik z definicjami rejestrów

P10F202.INC (asembler), lub plik nagłówkowy p18f4520.h (C), za pomocą dyrektywy INCLUDE

• Następnie, na początku programu, należy ustawić porty we/wy w odpowiedni stan • Włączanie i wyłączanie oraz ustalanie preskalera dla Watchdoga odbywa się za

pomocą dyrektywy Config (watchdog włączony, preskaler ma wartość 512)

CONFIG WDT=ON, WDTPS=512; asembler #pragma config WDT=ON, WDTPS=128//j ęzyk C

Przykładowe programy Po wciśnięciu klawisza Reset lub włączeniu zasilania zapalają się na krótki czas wszystkie cztery diody, następnie program generuje niekończącą się sekwencję błysków.

• Kod napisany w asemblerze

LIST P=18F4520, R=DEC INCLUDE P18F4520.INC

CNT0 EQU 0x000 CNT1 EQU 0x001 ORG 00000H GOTO START ORG 00020H START CLRF LATB CLRF TRISB MOVLW 00001111B MOVWF LATB, 0 CALL WAIT CALL WAIT CALL WAIT

9

LOOP MOVLW 00000001B MOVWF LATB, 0 CALL WAIT MOVLW 00000010B MOVWF LATB, 0 CALL WAIT MOVLW 00000100B MOVWF LATB, 0 CALL WAIT MOVLW 00001000B MOVWF LATB, 0 CALL WAIT GOTO LOOP WAIT CLRF CNT0 CLRF CNT1 WAIT1 DECFSZ CNT0 GOTO WAIT1 DECFSZ CNT1 GOTO WAIT1 RETURN END

• Kod napisany w języku C

#include <p18f4520.h> void delay() { int i, j; for(i=0; i<=255; i++) { for(j=0; j<=255; j++) { } } } void main() { LATB=0x00; TRISB=0x00; LATB=0x0F; delay(); delay(); delay(); while(1) { LATB=0x01; delay(); LATB=0x02; delay(); LATB=0x04; delay(); LATB=0x08; delay(); } }

10

Ćwiczenie 2. Współpraca mikrokontrolera PIC z klawiaturą i wyświetlaczem Wykorzystywany sprzęt


• Układ laboratoryjny Keyboard + Display



Cel ćwiczenia Opanowanie współpracy multipleksowanej klawiatury i wyświetlacza 7-segmentowego z mikrokontrolerem

Szczegółowe zagadnienia • Zasada działania multipleksowanej klawiatury i wyświetlacza

• Pętle, instrukcje warunkowe

• Operacje na pojedynczych bitach, rotacje

• Porty wej/wyj

• Przerwania

Zadania • Napisać program odczytujący wciśnięte klawisze i wyświetlający ich kod na wyświetlaczu

7-segmentowym

• Klawiszom przyporządkować kody od 0 do F

• Każde wciśnięcie klawisza ma spowodować wyświetlenie jego kodu na skrajnym wyświetlaczu i przesunąć poprzednie










• Opis układu laboratoryjnego Keyboard + Dislplay – dodatek C

• Obsługa klawiatury matrycowej – dodatek D

Uwagi do realizacji programu

• Program powinien cyklicznie wystawiać 0 na linie RB4..7

11

• Odstęp czasowy pomiędzy przesunięciem 0 do następnej kolumny powinien być rzędu kilkunastu do kilkudziesięciu milisekund

• Cały port D jest wyjściem sterującym segmentami wyświetlaczy. Stan niski odpowiada zapaleniu segmentu, wyświetlacza zaadresowanego przez linie RB4.. 7

• Pojawienie się stanu niskiego na wejściu RB0..3 oznacza wciśnięcie klawisza z odpowiedniej kolumny

• Linie portu B powinny być „podciągnięte do góry - weak pull-up" (rejestr INTCON2)

• Piny portu B przestawić z funkcji analogowego wejścia na cyfrowe wejście/wyjście (rejestr ADCON1)

• Można, lecz nie trzeba, wykorzystać przerwania generowane poprzez zmianę stanu na wejściach RB0..4 oraz funkcję Sleep()

• Niekonieczna jest eliminacja drgań styków, lecz warto o tym pomyśleć

• Do obsługi Timera oraz opóźnień można wykorzystać gotowe funkcje (timers.h, delays.h)

• Każdy port oprócz funkcji cyfrowego wejścia i wyjścia (Digital I/O) posiada również alternatywne funkcje, z których te o wyższym priorytecie należy wyłączyć za pomocą dyrektywy Config pragma config LVP=OFF, DEBUG=OFF

Przykładowy program Po wciśnięciu klawisza Reset lub włączeniu zasilania generuje niekończącą się sekwencję błysków dwóch diod RB0 i RB1. Dioda RB0 miga z częstotliwością ustaloną za pomocą Timer0 z wykorzystaniem przerwania generowanego przez niego po przepełnieniu licznika. Dioda RB1 miga z częstotliwością ustaloną za pomocą funkcji bibliotecznej Delay10KTCYx(n). #include <p18f4520.h> #include <timers.h> #include <delays.h> int counter=0; void timer_isr (void); #pragma code high_vector=0x08 void high_interrupt (void) { _asm GOTO timer_isr _endasm } #pragma code #pragma interrupt timer_isr void timer_isr (void) { counter++; if (counter==255) { LATB^=0x01; counter=0; } INTCONbits.TMR0IF=0; }

12

void main(void) { TRISB=0xFC; LATB=0x0FC; OpenTimer0 (TIMER_INT_ON & T0_SOURCE_INT & T0_8BIT ); INTCONbits.GIE = 1; while (1) { LATB^=0x02; Delay10KTCYx(30); } }

13

Ćwiczenie 3. Sprzętowy interfejs szeregowy RS232 Wykorzystywany sprzęt




Cel ćwiczenia Zapoznanie się ze sprzętowym asynchronicznym szeregowym interfejsem USART mikrokontrolerów rodziny PIC

Szczegółowe zagadnienia • Konfiguracja sprzętowego modułu USART

• Komunikacja układu mikrokontrolerowego z komputerem

Zadania • Napisać program umożliwiający szeregową komunikację pomiędzy komputerem, a

układem mikrokontrolera • Wysyłane znaki powinny wyświetlać się na wyświetlaczu LCD • Skompilować program









• Nota aplikacyjna AN774 Microchip - Asynchronous Communication with the PICmicro USART - DS00774A – AN774.pdf

• Interfejs szeregowy RS232 – dodatek E

Uwagi do realizacji programu • Należy zwrócić szczególną uwagę na identyczne ustawienia prędkości i rodzaju

transmisji w mikrokontrolerze i komputerze PC

• W przypadku kłopotów z transmisją warto napisać mały programik konfigurujący jedynie port RS232 i wysyłający jakiś znak lub echo odebranego

• Do obsługi wyświetlacza wykorzystać gotową implementację zawartą w pliku LCD.c

• Do obsługi Timera, opóźnień oraz modułu USART można wykorzystać gotowe funkcje (timers.h, delays.h, usart.h)

14

Ćwiczenie 4. Komunikacja mikrokontrolera PIC z urządzeniami z interfejsem I2C

Wykorzystywany sprzęt • Układ laboratoryjny PICDEM 2 plus



Cel ćwiczenia Zapoznanie się ze sprzętowym interfejsem I2C mikrokontrolera PIC

Szczegółowe zagadnienia

• Urządzenia wykorzystujące standard I2C • Protokół I2C i jego właściwości

• Komunikacja i konfiguracja z termometrem cyfrowym z interfejsem I2C

• Konwersja liczb binarnych na dziesiętne

Zadania • Napisać program odczytujący temperaturę z termometru cyfrowego i wyświetlający

ją na wyświetlaczu LCD

• Temperatura powinna być wyświetlana w stopniach Celsiusza z dokładnością 2 cyfr po przecinku

• Temperatur ujemnych, ani powyżej 100 stopni nie należy się spodziewać w laboratorium

• Odczyt i wyświetlenie temperatury termometru może być cykliczny (np. co sekundę)





• Definicje nazw rejestrów (C) – pic18f4520.h




• Opis termometru cyfrowego TC74 – TC74.pdf • Tworzenie projektu, kompilacja oraz uruchamianie programów w środowisku MPLAB

– dodatek B

• Interfejs I2C – dodatek F

15

Uwagi do realizacji programu • Do obsługi wyświetlacza wykorzystać gotową implementację obsługi wyświetlacza

LCD zawartą w pliku LCD.c • Do obsługi Timera, opóźnień oraz interfejsu I2C można wykorzystać gotowe funkcje

(times.h, delays.h, i2c.h)

16

17

Część 2

Ćwiczenia 5-8 Mikrokontroler ATMega128

18

19

Ćwiczenie 5. Układy czasowe i przerwania zegarowe

Wykorzystywany sprzęt • System uruchomieniowy EVB503 z procesorem ATMega128

• Urządzenie JTAGICE mkII, kabel USB

• Komputer: środowisko AVR Studio, kompilator avr-gcc

Cel ćwiczenia Poznanie sposobu obsługi układu czasowego oraz przerwań.

Szczegółowe zagadnienia • Wektor przerwań, procedury obsługi przerwań.

o Makro ISR(vect) z modułu <avr\interrupt.h>

• Rejestry obsługi portów WE/WY o Rejestr kierunku DDRn o Rejestr danych wyjściowych PORTn o Rejestr danych wejściowych PINn

• Rejestry związane z obsługą układu czasowego o rejestry sterujące TCCRn o rejestr licznika TCNTn o rejestry porównania OCRn i ICRn o rejestry masek przerwań TIMSK i ETIMSK o rejestry flag przerwań TIFR i ETIFR

• Tryby pracy i sposoby wykorzystania układu czasowego w programie

Zadania • Założyć nowy projekt o nazwie TIMER.

• Napisać program wykorzystujący TIMER0 w trybie CTC do uzyskania przerwań w odstępach czasowych 10 ms. Działanie programu powinno być demonstrowane za pomocą diod LED.

Uwaga: rejestry mikrokontrolera dostępne są jako zmienne typu uint8 o nazwach

zgodnych z dokumentacją układu.

• Skompilować i uruchomić program.

• Napisać program wykorzystujący TIMER1 w trybie PWM do uzyskania sygnału o regulowanym wypełnieniu. Działanie programu powinno być demonstrowane za pomocą diod LED.


Potrzebne informacje • Instrukcja użytkownika układu EVB503 – EVB503.pdf

• Schematy układu EVB503 – EVB503sch.plf

• Instrukcja modułu adaptacyjnego dla płyt EVB50x – TOP50X3.pdf

• Instrukcja użytkownika JTAGICE mkII – JTAGICE_mkII.pdf

20

• Karta katalogowa mikrokontrolera – ATMega128DS.pdf o Porty WE/WY – str. 65-88 o Układy czasowe 8-bitowe – str. 92-109, dodatek I

• Programowanie w języku C – dodatek G

• Wektor przerwań, procedury obsługi przerwań w języku C – dodatek G

• Tworzenie projektu, kompilacja oraz uruchamianie programów w środowisku AVR Studio – dodatek H

21

Ćwiczenie 6. Wyświetlacz LCD


• Panel wyświetlacza LCD (HY1602F4)



Cel ćwiczenia Poznanie zagadnień związanych z obsługą wyświetlacza ciekłokrystalicznego.

Szczegółowe zagadnienia • Dostęp w programie do rejestrów wyświetlacza (Extended RAM).

o Rejestr MCUCR o Rejestr XMCRA o Wysyłanie słów rozkazowych do rejestru IR wyświetlacza o Wysyłanie danych do pamięci DD RAM wyświetlacza.

• Funkcje realizowane przez sterownik wyświetlacza.

• Generowanie i użytkowanie własnych symboli. o Projektowanie znaków w matrycy 5×7 o Czytanie danych z pamięci FLASH (<avr\pgmspace.h>) o Zapisywanie danych w pamięci CG RAM wyświetlacza.

Zadania • Założyć nowy projekt, wykorzystując pliki lcd.h oraz lcd.c (pliki te zostały umieszczone

w ścieżce include kompilatora, plik lcd.c dołączany jest automatycznie po dołączeniu lcd.h). Program powinien po uruchomieniu i naciśnięciu dowolnego przycisku (SW0 .. SW7) wyświetlić na wyświetlaczu napis: START LCD.




• Wprowadzić do programu modyfikacje: o generowanie własnych symboli o animacja (przewijanie) tekstu.






• Dostęp do pamięci rozszerzonej RAM – ATMega128DS.pdf (str. 26-35) o Rejestr MCUCR – str. 31

22

o Rejestr XMCRA – str. 31



• Funkcje realizowane przez sterownik wyświetlacza – dodatek J

23

Ćwiczenie 7. Przetwornik analogowo-cyfrowy



• Źródło mierzonego napięcia (potencjometr)



Cel ćwiczenia Poznanie zagadnień związanych z obsługą przetwornika analogowo-cyfrowego.

Szczegółowe zagadnienia • Rejestry sterujące przetwornikiem analogowo-cyfrowym (ADMUX, ADCSRA).

• Dostęp do rejestrów wyjściowych przetwornika (ADCH i ADCL).

• Inicjalizacja przetwornika.

• Programowa realizacja opóźnień (<util\delay.h>).

• Tryby pracy przetwornika. Multipleksowanie sygnałów wejściowych.

Zadania • Założyć nowy projekt. Program powinien mieć możliwość obsługi wyświetlacza LCD.

Po uruchomieniu i naciśnięciu przycisku SW0 przetwornik powinien dokonać pomiaru napięcia na wybranym wejściu i wyświetlić na wyświetlaczu napis "Pomierzono:". Najstarsze 8 bitów pomierzonej wartości należy wyświetlić w postaci binarnej na wyświetlaczu diodowym ("0" – dioda nie świeci, "1" – dioda świeci).




• Wprowadzić do programu modyfikacje: o zamiana wyniku z postaci binarnej na dziesiętną i wyświetlenie na

wyświetlaczu LCD wielkości napięcia w [V]. o wykonywanie pomiarów i wyświetlanie wyników w sposób ciągły.






• Dostęp do pamięci rozszerzonej RAM – ATMega128DS.pdf (str. 26-35) o Rejestr MCUCR – str. 31 o Rejestr XMCRA – str. 31


24


• Przetwornik analogowo-cyfrowy – ATMega128DS.pdf (str. 232-248), dodatek K

25

Ćwiczenie 8. Magistrala 1-Wire



• Czytnik układów iButton

• Układ iButton DS1992



Cel ćwiczenia Poznanie zagadnień związanych z przesyłaniem danych magistralą 1-Wire.

Szczegółowe zagadnienia • Protokół komunikacyjny magistrali 1-Wire.

o Rozkaz RESET o Sprawdzenie obecności urządzeń 1-Wire w linii. o Wysłanie pojedynczego bitu ("0" lub "1"). o Wczytanie pojedynczego bitu z linii 1-Wire. o Programowa realizacja opóźnień (<util\delay.h>).

• Realizacja magistrali 1-Wire z wykorzystaniem portu wejścia-wyjścia mikrokontrolera ATMega128.

o Linia sygnałowa. o Linie sterujące diodami w czytniku. o Zestaw komend dla układu DS1992. o Rozkaz 33h – wczytanie ROM (kodu identyfikacyjnego). o Rozkaz 55h – poszukiwanie układu o zadanym kodzie identyfikacyjnym.

• Naliczanie sumy kontrolnej CRC8 w układzie iButton (<util\crc16>).

Zadania • Założyć nowy projekt. Program powinien mieć możliwość obsługi wyświetlacza LCD.

Program powinien cyklicznie sprawdzać obecność układu DS1992 w czytniku. Brak układu powinien być sygnalizowany półsekundowymi błyskami czerwonej diody czytnika w odstępach jednosekundowych. Wykrycie układu w czytniku powinno być sygnalizowane świeceniem zielonej diody czytnika przez okres trzech sekund.




• Wprowadzić do programu modyfikacje o odczytanie 48-bitowego kodu identyfikującego i wyświetlenie tej informacji

na wyświetlaczu LCD. o sprawdzenie poprawności CRC we wczytanym kodzie


26





• Dostęp do pamięci rozszerzonej RAM – ATMega128DS.pdf (str. 26-35) o Rejestr MCUCR – str. 31 o Rejestr XMCRA – str. 31



• Realizacja magistrali 1-Wire – dodatek L

27

Sprzęt wykorzystywany w laboratorium

28

29

Płytka demonstracyjna PICDEM 2 PLUS Na rysunku poniżej przedstawiono zdjęcie płytki demonstracyjnej PICDEM 2 PLUS.

Składa się ona z:

1. Gniazda na mikrokontrolery rodziny PIC. W ćwiczeniach wykorzystywany jest mikrokontroler 40-nóżkowy PIC18F4520.

2. Blok zasilacza. 3. Blok interfejsu RS232 zbudowany z gniazda żeńskiego DB9 i układu MAX232AC. 4. Gniazdo telefoniczne do podłączenia interfejsu ISP z MPLAB ICD. 5. Potencjometr podłączony do pinu RA0 mikrokontrolera wykorzystywany do

zadawania napięcia mierzonego przez przetwornik analogowo-cyfrowy. 6. Trzy przyciski S1 (RESET), S2 (podłączonego do linii RA4 mikrokontrolera) i S3

(podłączonego do linii RB0 mikrokontrolera i używanego do generacji przerwania INT0).

7. Dioda zielona LED D1 (PWR) sygnalizująca zasilanie układu. 8. Cztery diody LED podłączone do linii RB0-RB3 portu PORTB (do linii RB0 podłączony

jest również przycisk S3). 9. Jumper J6 służący do dołączenia lub odłączenia napięcia zasilania do czterech diod

LED. 10. Generator Y2 przebiegu zegarowego o częstotliwości 4.00 MHz podawanego na

wejście oscylatora mikrokontrolera. 11. Oscylator kwarcowy Y1 nie zamontowany na płytce. 12. Oscylator kwarcowy 32,xxx kHz.

30

13. Jumper J7 służący do podłączenia oscylatora kwarcowego Y1. 14. Pamięć EEPROM 24LC256 z interfejsem I2C. 15. Dwurzędowy (2 rzędy po 16 znaków 5x8) wyświetlacz LCD z kontrolerem HD44780

firmy Hitachi. 16. Brzęczek (Buzzer). 17. Pole lutownicze. 18. Termometr TC74A5-5.0VAT z interfejsem I2C.

Na rysunku poniżej przedstawiono rozmieszczenie elementów na płytce PICDEM 2 PLUS.

Inne ważniejsze cechy płytki PICDEM 2 PLUS:

• magistrala danych wyświetlacza LCD jest 4-bitowa. Podłączona jest do czterech linii RD0-RD3 portu PORTD. Trzy linie sterujące kontroler wyświetlacza LCD podłączone są do portu PORTA, odpowiednio; linia E strobująca dane do RA1, linia R/W wyboru kierunku przepływu danych do RA2 i linia RS wyboru dane/instrukcja do RA3.

• Brzęczek sterowany jest linią RC2.

• Pamięć EEPROM 24LC256 i termometr TC74 A5 są podłączone do interfejsu I2C – linie SDA (RC4) i SCL (RC3).

• Interfejs RS232 za pośrednictwem układu MAX232 dołączony jest do interfejsu USART – linie TX (RC6) i RX (RC7).

• Przyciski podczas naciśnięcia dające stan niski podłączone są odpowiednio: S1 – wejście resetu zewnętrznego MCLR, S2 – RA4 i S3 – RB0 (wejście przerwania INT0).

• Diody LED podłączone są do linii RB0-RB3 portu PORTB. Świecą gdy na tych liniach wystawiony jest stan niski.

31

Poniżej przedstawiono zdjęcie (nowszej wersji w stosunku do tej zaprezentowanej powyżej) płytki wykorzystywanej podczas zajęć laboratoryjnych.

32

Programator MPLAB ICD3 MPLAB ICD3 jest najnowszym programatorem/debuggerem o doskonałych parametrach. Za jego pomocą można debuggować i programować 8- 16- i 32-bitowe mikrokontrolery Microchip oraz mikrokontrolery sygnałowe z serii dsPIC®. Narzędzie współpracuje z MPLAB IDE, wydajnym i prostym w obsłudze graficznym środowiskiem programistycznym.

W stosunku do poprzednika, MPLAB® ICD2 (przy zachowaniu pełnej kompatybilności), ICD3 oferuje znacznie większe możliwości. Zaprogramowanie dowolnego mikrokontrolera zajmuje średnio 15-krotnie mniej czasu niż w przypadku ICD2. Programator zbudowany został z wykorzystaniem procesora dsPIC33 pracującego z częstotliwością 40MHz. Cechy MPLAB® ICD3:

• Debbugguje mikrokontrolery 8- 16- i 32-bitowe PIC® z pamięcią Flash oraz mikrokontrolery sygnałowe z serii dsPIC

• Emulacja w czasie rzeczywistym, przy max. szybkości debuggowanego mikrokontrolera

• Debuggowanie kodu źródłowego, wykonywanie programu “krok-po-kroku”, obsługa pułapek (do 1000 programowych) i programowanie w obwodzie (In-Circuit Serial Programming).

• Kompatybilny ze środowiskiem programistycznym MPLAB IDE. • Upgrade firmware’u poprzez MPLAB IDE® (nowe, zaawansowane funkcje). • Ochrona przed przepięciami i przetężeniami z debuggowanego obwodu. • Złącze High Speed USB 2.0 (480 Mbps) do połączenia z komputerem PC. • Zasilanie poprzez złącze USB. • Zapewnia zasilanie systemu programowanego (do 100mA). • Posiada wewnętrzny bufor pamięci 1MB w celu zwiększenia szybkości komunikacji.

Układ ewaluacyjno- Głównym elementem każdego ćwiczenia jest układ EVB503. Jest to rozbudowane środowisko do tworzenia i testowania aplikacji dla głównej znajduje się szereg układów peryferyjnych najczęściej wykorzystywanych przez projektantów i konstruktorów. Można tutaj wymienić takie układy, jak:

• zewnętrzna pamięć danych SRAM,

• zegar czasu rzeczywistego z mag

• zegar czasu rzeczywistego z magistralą I

• pamięć szeregowa z magistralą SPI DataFlash,

• pamięć szeregowa z magistralą I

• zestaw ośmiu mikroprzełączników,

• zestaw ośmiu diod świecących,

• brzęczyk,

• oscylator kwarcowy.

Konstrukcja płyty pozwala na szybkie skonfigurowanie układu tak, aby procesor miał właściwe środowisko do pracy. Uzyskano to dzięki szpilkowym złączom GOLDPIN, które pozwalają na łatwe dołączanie układów i urządzeń peryferyjnych do portów mikroprocesora. Szczegółowy opis płyty EVB503 znajduje się w „Instrukcji użytkownika”.

33

-uruchomieniowy EVB503

Głównym elementem każdego ćwiczenia jest układ EVB503. Jest to rozbudowane środowisko do tworzenia i testowania aplikacji dla mikrokontrolerów 8-bitowych. Na płycie głównej znajduje się szereg układów peryferyjnych najczęściej wykorzystywanych przez

konstruktorów. Można tutaj wymienić takie układy, jak:

zewnętrzna pamięć danych SRAM,

zegar czasu rzeczywistego z magistralą SPI – DS1305,

zegar czasu rzeczywistego z magistralą I2C – PCF8583,

pamięć szeregowa z magistralą SPI DataFlash,

pamięć szeregowa z magistralą I2C,

zestaw ośmiu mikroprzełączników,

zestaw ośmiu diod świecących,

strukcja płyty pozwala na szybkie skonfigurowanie układu tak, aby procesor miał właściwe środowisko do pracy. Uzyskano to dzięki szpilkowym złączom GOLDPIN, które pozwalają na łatwe dołączanie układów i urządzeń peryferyjnych do portów mikroprocesora.

egółowy opis płyty EVB503 znajduje się w „Instrukcji użytkownika”.

Głównym elementem każdego ćwiczenia jest układ EVB503. Jest to rozbudowane bitowych. Na płycie

głównej znajduje się szereg układów peryferyjnych najczęściej wykorzystywanych przez

strukcja płyty pozwala na szybkie skonfigurowanie układu tak, aby procesor miał właściwe środowisko do pracy. Uzyskano to dzięki szpilkowym złączom GOLDPIN, które pozwalają na łatwe dołączanie układów i urządzeń peryferyjnych do portów mikroprocesora.

34

Połączenie mikroprocesora z płytą EVB503 zrealizowano stosując moduły adaptacyjne. Daje to możliwość dołączania mikroprocesorów 8-bitowych różnego typu i w różnych obudowach, a moduł adaptacyjny służy jako „przejściówka” doprowadzająca linie portów i sygnałów procesora do odpowiednich linii płyty EVB503. Wykorzystywany w ćwiczeniach mikroprocesor ATMega128 firmy Atmel został osadzony w płycie EVB503 za pośrednictwem modułu adaptacyjnego TOP50X3. Moduł ten posiada złącze ISP do podłączenia programatorów szeregowych oraz złącze JTAG pozwalające na uruchamianie programów bezpośrednio w mikroprocesorze. Zdjęcie oraz szkic rozmieszczenia elementów i złącz modułu TOP50X3 z mikroprocesorem ATMega128 przedstawia poniższy rysunek.

Szczegółowe dane na temat modułu adaptacyjnego znajdują się w „Instrukcji użytkownika modułu adaptacyjnego TOP50X3”.Wszystkie porty mikroprocesora oraz dodatkowe układy peryferyjne są wyprowadzone na złączach szpilkowych typu GOLDPIN. Widok złącz przedstawia poniższa fotografia.

35

Szczegółowe dane na temat modułu adaptacyjnego znajdują się w „Instrukcji użytkownika modułu adaptacyjnego TOP50X3”. Wszystkie porty mikroprocesora oraz dodatkowe układy peryferyjne są wyprowadzone

kowych typu GOLDPIN. Widok złącz przedstawia poniższa fotografia.

Szczegółowe dane na temat modułu adaptacyjnego znajdują się w „Instrukcji użytkownika

Wszystkie porty mikroprocesora oraz dodatkowe układy peryferyjne są wyprowadzone kowych typu GOLDPIN. Widok złącz przedstawia poniższa fotografia.

36

Programator JTAGICE mkII JTAGICE mkII to sprzętowy debuger współpracujący ze wszystkimi AVR'ami wyposażonymi w interfejs JTAG, ISP oraz debugWire. Umożliwia emulację mikrokontrolerów z pamięcią Flash od 1kB do 256kB. JTAGICE mkII jest również dedykowanym narzędziem dla nowych mikrokontrolerów UC3 z rdzeniem AVR32.

Cechy JTAGICE mkII:

• Współpracuje z programem Atmel AVR Studio oraz AVRDUDE

• Umożliwia emulowanie i programowanie w systemie procesorów AVR wyposażonych w interfejs JTAG, ISP oraz debugWire

• Umożliwia debuggowanie kodu napisanego zarówno w Asemblerze, jak i w języku C

• Możliwość akutalizacji poprzez AVRStudio

• Możliwość podłączenia poprzez port USB lub RS232

• Praca emulatora sygnalizowana jest na wbudowanych trzech diodach LED

• Standardowe 10-wyprowadzeniowe złącze do układu docelowego w standardzie JTAG Atmela

• Zasilanie programatora z magistrali USB lub poprzez zewnętrzny zasilacz Połączenie z układem docelowym powinno być wykonane przy pomocy załączonego 10-żyłowego kabla paskowego, zakończonego standardowymi wtykami IDC z rastrem 2.54mm. Układ docelowy powinien posiadać złącze JTAG o układzie wyprowadzeń identycznym z złączem JTAG emulatora. Linie magistrali JTAG łączymy z odpowiadającymi im liniami magistrali JTAG mikrokontrolera. Złącze JTAG jest kompatybilne ze standardem 10-wyprowadzeniowym firmy Atmel.

37

Dodatki

38

39

Dodatek A. Programowanie mikrokontrolera PIC18F4520 w języku C Jednym z wielu kompilatorów języka C dla mikrokontrolerów PIC jest MPLAB C18 firmy Microchip. Jest to kompilator generujący kod dla mikrokontrolerów PIC z rdzeniem 18-bitowym. Kompilator jest zgodny ze standardem ANSI C.

Przykłady programów napisanych w języku C (kompilator MPLAB C18) na płytkę demonstracyjną PICDEM2 PLUS z mikrokontrolerem PIC18F4520 Przykład 1. Diody LED oraz przerwania

/* 1 */ #include <p18f4520.h> /* 2 */ #include <timers.h> /* 3 */ /* 4 */ #define NUMBER_OF_LEDS 8 /* 5 */ /* 6 */ void timer_isr (void); /* 7 */ /* 8 */ static unsigned char s_count = 0; /* 9 */ /* 10 */ #pragma code low_vector=0x18 /* 11 */ void low_interrupt (void) /* 12 */ { /* 13 */ _asm GOTO timer_isr _endasm /* 14 */ } /* 15 */ /* 16 */ #pragma code /* 17 */ /* 18 */ #pragma interruptlow timer_isr /* 19 */ void /* 20 */ timer_isr (void) /* 21 */ { /* 22 */ static unsigned char led_display = 0; /* 23 */ /* 24 */ INTCONbits.TMR0IF = 0; /* 25 */ /* 26 */ s_count = s_count % (NUMBER_OF_LEDS + 1); /* 27 */ /* 28 */ led_display = (1 << s_count++) - 1; /* 29 */ /* 30 */ PORTB = led_display; /* 31 */ } /* 32 */ /* 33 */ void /* 34 */ main (void) /* 35 */ { /* 36 */ TRISB = 0; /* 37 */ PORTB = 0; /* 38 */ /* 39 */ OpenTimer0 (TIMER_INT_ON & T0_SOURCE_INT & T0_16BIT); /* 40 */ INTCONbits.GIE = 1; /* 41 */ /* 42 */ while (1) /* 43 */ { /* 44 */ } /* 45 */ }

40

Linia 1: Plik nagłówkowy z definicjami nazw rejestrów dla mikrokontrolera PIC18F4520.

Linia 10: Wymuszenie adresu dla kolejnych rozkazów, które będą zapisywane w pamięci programu mikrokontrolera. W tym przypadku jest, to początek wektora przerwań o niskim priorytecie.

Linia 13: Wstawka asemblerowa z instrukcją. W tym przypadku jest to rozkaz skoku do obsługi przerwania.

Linia 16: Wymuszenie domyślnego adresu dla kolejnych rozkazów, które będą zapisywane w pamięci programu mikrokontrolera.

Linia 19-20: Definicja funkcji realizującej obsługę przerwania. Linia 24: Instrukcja, która spowoduje wyzerowanie bitu TMROIF w rejestrze

konfiguracyjnym INTCON (zgodnie z definicja w pliku p18f4520.h). Linia 30: Sposób modyfikacji stanu pinów portu B. Linia 36-37: Inicjalizacja portu B. Rejestr TRISB ustawia kierunek portu B (0 - wyjście),

rejestr PORTB wymuszenie stanu poszczególnych pinów portu. Linia 39: Funkcja inicjalizacji timera 0 (zgodnie z definicja w pliku timers.h). Linia 40: Włączenie obsługi przerwań. Bit GIE ustawiony na 1 w rejestrze INTCON

(zgodnie z definicja w pliku p18f4520.h). Przykład 2. Bufor z danymi oraz moduł USART

/* 1 */ #include <p18f4520.h> /* 2 */ #include <usart.h> /* 3 */ /* 4 */ void rx_handler (void); /* 5 */ /* 6 */ #define BUF_SIZE 25 /* 7 */ /* 8 */ /* /* 9 */ * Step #1 – The data is allocated into its own section. /* 10 */ */ /* 11 */ #pragma idata bigdata /* 12 */ char data[11][BUF_SIZE+1] = { /* 13 */ { "String #0\n\r" }, /* 14 */ { "String #1\n\r" }, /* 15 */ { "String #2\n\r" }, /* 16 */ { "String #3\n\r" }, /* 17 */ { "String #4\n\r" }, /* 18 */ { "String #5\n\r" }, /* 19 */ { "String #6\n\r" }, /* 20 */ { "String #7\n\r" }, /* 21 */ { "String #8\n\r" }, /* 22 */ { "String #9\n\r" }, /* 23 */ { "Invalid key (0-9 only)\n\r" } /* 24 */ }; /* 25 */ #pragma idata /* 26 */ /* 27 */ #pragma code rx_interrupt = 0x8 /* 28 */ void rx_int (void) /* 29 */ { /* 30 */ _asm goto rx_handler _endasm /* 31 */ } /* 32 */ #pragma code /* 33 */ /* 34 */ #pragma interrupt rx_handler

41

/* 35 */ void rx_handler (void) /* 36 */ { /* 37 */ unsigned char c; /* 38 */ /* 39 */ /* Get the character received from the USA RT */ /* 40 */ c = ReadUSART(); /* 41 */ if (c >= '0' && c <= '9') /* 42 */ { /* 43 */ c -= '0'; /* 44 */ /* Display value received on LEDs */ /* 45 */ PORTB = c; /* 46 */ /* 47 */ /* /* 48 */ * Step #2 – This example did not need an a dditional /* 49 */ * pointer to access the large memory becau se of the /* 50 */ * multi-dimension array. /* 51 */ * /* 52 */ * Display the string located at the array offset /* 53 */ * of the character received /* 54 */ */ /* 55 */ putsUSART (data[c]); /* 56 */ } /* 57 */ else /* 58 */ { /* 59 */ /* /* 60 */ * Step #2 – This example did not need an a dditional /* 61 */ * pointer to access the large memory becau se of the /* 62 */ * multi-dimension array. /* 63 */ * /* 64 */ * Invalid character received from USART. /* 65 */ * Display error string. /* 66 */ */ /* 67 */ putsUSART (data[10]); /* 68 */ /* 69 */ /* Display value received on LEDs */ /* 70 */ PORTB = c; /* 71 */ } /* 72 */ /* 73 */ /* Clear the interrupt flag */ /* 74 */ PIR1bits.RCIF = 0; /* 75 */ } /* 76 */ /* 77 */ void main (void) /* 78 */ { /* 79 */ /* Configure all PORTB pins for output */ /* 80 */ TRISB = 0; /* 81 */ /* 82 */ /* /* 83 */ * Open the USART configured as /* 84 */ * 8N1, 2400 baud, in polled mode /* 85 */ */ /* 86 */ OpenUSART (USART_TX_INT_OFF & /* 87 */ USART_RX_INT_ON & /* 88 */ USART_ASYNCH_MODE & /* 89 */ USART_EIGHT_BIT & /* 90 */ USART_CONT_RX & /* 91 */ USART_BRGH_HIGH, 103); /* 92 */ /* 93 */ /* Display a prompt to the USART */ /* 94 */ putrsUSART ( /* 95 */ (const far rom char *)"\n\rEnter a digit 0 -9!\n\r");

42

/* 96 */ /* 97 */ /* Enable interrupt priority */ /* 98 */ RCONbits.IPEN = 1; /* 99 */ /* 100 */ /* Make receive interrupt high priority * / /* 101 */ IPR1bits.RCIP = 1; /* 102 */ /* 103 */ /* Enable all high priority interrupts */ /* 104 */ INTCONbits.GIEH = 1; /* 105 */ /* 106 */ /* Loop forever */ /* 107 */ while (1) /* 108 */ ; /* 109 */ }

Linia 1: Plik nagłówkowy z definicjami nazw rejestrów dla mikrokontrolera PIC18F4520.

Linia 11: Zostanie utworzony bufor z zainicjowanymi danymi w pamięci danych dla zmiennej data.

Linia 25: Powrót do domyślnej lokalizacji w pamięci danych. Linia 27: Wymuszenie adresu dla kolejnych rozkazów, które będą zapisywane w

pamięci programu mikrokontrolera. W tym przypadku jest, to początek wektora przerwań o wysokim priorytecie.

Linia 32: Wymuszenie domyślnego adresu dla kolejnych rozkazów, które będą zapisywane w pamięci programu mikrokontrolera.

Linia 35: Definicja funkcji realizującej obsługę przerwania. Linia 45, 70: Sposób modyfikacji stanu pinów portu B. Linia 55, 67: Wykorzystanie danej zapisanej w buforze data. Linia 74: Czyszczenie flagi na zakończenie obsługi przerwania. Bit RCIF ustawiony na

0 w rejestrze PIR1 (zgodnie z definicja w pliku p18f4520.h). Linia 80: Rejestr TRISB ustawia kierunek portu B (0 – wyjście). Linia 86-91: Funkcja inicjalizacji USART (zgodnie z definicja w pliku timers.h). Linia 98: Włączenie priorytetów dla przerwań. Bit IPEN ustawiony na 1 w rejestrze

RCON (zgodnie z definicja w pliku p18f4520.h). Linia 101: Ustawienie wysokiego priorytetu dla przerwania. Bit RCIP ustawiony na 1 w

rejestrze IPR1 (zgodnie z definicja w pliku p18f4520.h). Linia 104: Włączenie obsługi przerwań o wysokim priorytecie. Bit GIEH ustawiony na

1 w rejestrze INTCON (zgodnie z definicja w pliku p18f4520.h).

Moduły biblioteczne Kompilator MPLAB C18 posiada funkcje biblioteczne dla takich urządzeń peryferyjnych, jak:

• Przetwornik analogowo-cyfrowy (adc.h)

• Moduł I2C (i2c.h)

• Porty we/wy (portx.h)

• Moduł 1-wire (mwire.h)

• Moduł PWM - Pulse-Width Modulation (pwm.h)

• Moduł SPI (spi.h)

• Moduł licznika (times.h)

• Moduł USART (usart.h)

43

Kompilator MPLAB C18 posiada funkcje biblioteczne wspierające realizację programową interfejsów do:

• Wyświetlaczy LCD ze sterownikiem Hitachi HD44780 (xlcd.h)

• Szyny CAN MCP2510 (can2510.h)

• Szyny I2C (sw_i2c.h)

• Szyny SPI (sw_spi.h)

• UART (sw_uart.h) Inne funkcje biblioteczne:

• Character Classification Functions (ctype.h)

• Data Conversion Functions (stdlib.h)

• Memory and String Manipulation Functions (string.h)

• Delay Functions (delays.h)

• Reset Functions (reset.h)

• Character Output Functions (stdio.h)

• Mathematic (math.h)

44

Dodatek B. Tworzenie projektu, kompilacja oraz uruchamianie programów w środowisku MPLAB Nowy projekt

• Uruchomić program MPLAB IDE

• Z menu Project wybrać Project Wizard

• Z menu Device wybrać PIC18F4520

• Dla projektu w asemblerze o Ustawić opcje według rysunku poniżej

o Podać nazwę i ścieżkę do nowego projektu o Jeżeli zostały wcześniej utworzone, dodać pliki do projektu o Zakończyć tworzenie nowe projektu

• Dla projektu w języku C o Ustawić opcje według rysunku poniżej

45

o Podać nazwę i ścieżkę do nowego projektu o Jeżeli zostały wcześniej utworzone, dodać pliki do projektu o Zakończyć tworzenie nowe projektu

Dodawanie plików z kodem do projektu

• Z menu File wybrać New

• Podczas zapisywania pliku nadać mu rozszerzenie .asm dla plików w asemblerze, lub .c dla plików w języku C

• Dodać plik do projektu wybierając z menu Project opcje Add Files to Project … poprzez wskazanie właściwego pliku

Kompilacja, programowanie i uruchamianie projektu • Kompilacja projektu wykonywana jest poprzez wciśnięcie Make na pasku narzędzi

o W przypadku pierwszej kompilacji programu napisanego w asemblerze należy

odpowiedzieć na poniższe pytanie wybierając opcje Absolute

46

• Po udanej kompilacji zostanie wyświetlony komunikat o Dla projektów w asemblerze

o Dla projektów w języku C

• W celu zaprogramowania układu wybrać programator z menu Programmer opcja

Select Programmer

• Po wyborze programatora, w przypadku pojawienia się okienka z ostrzeżeniem o

zasilaniu, należy wybrać opcje OK

47

• Następnie wybrać z menu Programmer Program

• Program zostanie uruchomiony automatycznie po zaprogramowaniu układu

48

Dodatek C. Układ laboratoryjny Keybord + Display Schemat ideowy

49

Rysunek układu

Opis układu Układ składa się z 16-polowej klawiatury multipleksowanej z 4-cyfrowym 7-segmentowym wyświetlaczem. Posiada 2 złącza RB i RD. Starsza połowa portu RB – RB4..7 (ustawiona jako wyjście mikrokontrolera) używana jest do wyboru kolumny matrycy klawiatury oraz jednocześnie cyfry wyświetlacza. Wyboru dokonuje się poprzez wystawienie 0 na odpowiedniej linii. Młodsza połowa portu – RB0..4 (ustawiona jako wejście mikrokontrolera) służy do detekcji (pojawi się 0) wciśniętego klawisza z zaadresowanej kolumny. Cały port RD (wyjście mikrokontrolera) służy do wyboru segmentów wyświetlaczy. Stanem aktywnym jest 0.

50

Dodatek D. Obsługa klawiatury matrycowej Efekty przy przełączaniu Sygnał powstający przy naciśnięciu/zwolnieniu klawisza zawiera szereg przejść ze stanu niskiego do wysokiego i na odwrót. Przyczyny takiego zachowania to mechaniczne drżenie styków oraz generowane przypadkowo przejścia, w czasie gdy sygnał ma stan nieokreślony w TTL. Stabilizacja sygnału następuje po pewnym czasie (rzędu kilkunastu milisekund). Innym źródłem takich efektów mogą być zakłócenia elektromagnetyczne, często pojawiające się w środowiskach przemysłowych przy przełączeniach dużych prądów w sieciach indukcyjnych. Usunięcie niepożądanych efektów może się odbywać przy zastosowaniu odpowiednich układów dodatkowych (np. zatrzasków RS czy też obwodów RC) lub za pomocą odpowiedniego oprogramowania.

Program eliminacji niepożądanych efektów najczęściej pobiera kilka kolejnych próbek sygnału w niewielkich (kilkumilisekundowych) odstępach czasu i porównuje ich wartości.

Sprzętowe usuwanie efektów łączeniowych Istnieje wiele metod sprzętowego usuwania zakłóceń powstałych przy przełączaniu styków. Podstawą prostego rozwiązania przedstawionego na schemacie poniżej jest zastosowanie kondensatora C filtrującego szybkie zmiany napięcia na stykach:

Występująca na schemacie dioda D ma zapewnić małą stałą czasową ładowania kondensatora (przez rezystor R1). Rozładowanie kondensatora odbywa się przez rezystor R2, a układ Schmitt'a zabezpiecza sygnał wyjściowy przed przypadkowym przełączaniem. Układ usuwania zakłóceń może być znacznie bardziej skomplikowany, realizujący sprzętowo koncepcje programowe za pomocą systemów cyfrowych lub specjalizowanych układów scalonych. Są to rozwiązania dość kosztowne, zwłaszcza w zastosowaniu do układów zawierających wiele styków (jak np. klawiatury).

51

Programowe usuwanie efektów łączeniowych W literaturze spotyka się różne procedury usuwające efekty łączeniowe - od banalnie prostych do całkiem skomplikowanych algorytmów, obsługujących wiele styków jednocześnie. Możliwe jest określenie pewnych podstawowych założeń dla takich procedur.

• Należy minimalizować czas obsługi, gdyż problem efektów łączeniowych jest na ogół czymś marginalnym z punktu widzenia działania całego systemu.

• Przełącznik powinien być dołączony do programowanej linii portu wejścia/wyjścia, a nie do linii przerwania zewnętrznego (aczkolwiek sprzętowo odkłócone styki często dołączane są do linii przerwań).

• Należy unikać próbkowania stanu styku z częstotliwością na której mogą występować zakłócenia elektromagnetyczne (np. 50 Hz).

• W wielu przypadkach należy dążyć do jak najszybszego podjęcia decyzji, w przeciwnym przypadku możemy wywołać frustrację użytkownika, który nie może się doczekać reakcji systemu na swoje działanie. Oznacza to, że decyzja powinna być podjęta przed upływem ok. 50 ms.

Algorytm zliczeniowy Podstawą tego algorytmu jest poszukiwanie n kolejnych jednakowych odczytów stanu styku, gdzie n jest liczbą w zakresie od 1 (algorytm wyłączony) do dowolnie dużych wartości. Program wykrywa zmianę stanu, a następnie rozpoczyna dekrementację lub inkrementację licznika, każdorazowo powtarzając odczyt stanu styku, aż wykryty zostanie stan n kolejnych jednakowych odczytów. Naciśnięciu przycisku (styk zamknięty) odpowiada zwracany przez funkcję RawKeyPressed() stan 0, a zwolnieniu - odpowiednio stan 1. Jeśli odczytany stan nie jest stabilny, licznik zostaje wyzerowany i proces rozpoczyna się od początku. Odstępy między kolejnymi odczytami można zrealizować za pomocą układu czasowego (timera) wbudowanego w mikroprocesor lub programowo, przez zastosowanie pętli tracenia czasu. Przykład 1 #define CHECK 5 // Odczyt stanu przycisku co 5 ms #define PRESS 10 // Wymagany czas (ms) dla decyzji o naci śni ęciu #define RELEASE 100 // Wymagany czas (ms) dla decyzji o zwolnieniu #define BUTTON_PORT PINC // Rejestr wej ściowy #define BUTTON_LINE 0 // Numer linii w porcie wej ściowym // Odczyt stanu przycisku. 0 - naci śni ęty, 1 - zwolniony char RawKeyPressed (){return BUTTON_PORT & ~_BC(BUTTON_LINE); } char DebouncedKeyState = 0; // Zmienna przechowuj ąca przetworzony stan przycisku. char KeyChanged; // Informacja o zmianie stanu przycisku char KeyPressed; // Bie Ŝący, przetworzony stan przycisku // Procedura wywoływana co CHECK ms do usuwania zak łóce ń obu zboczy void DebounceSwitch1 () { static uint8_t Count = RELEASE / CHECK; char RawState; KeyChanged = 0; KeyPressed = DebouncedKeyState; RawState = !RawKeyPressed ();

52

if (RawState == DebouncedKeyState ) { // Ustaw licznik dla podj ęcia decyzji o amianie stanu. if (DebouncedKeyState ) Count = RELEASE / CHECK; else Count = PRESS / CHECK; } else { // Stan styku zmienił si ę - odczekaj aby si ę upewni ć. if (--Count == 0) { // Koniec przedziału - zapisz zmian ę. DebouncedKeyState = RawState; KeyChanged = 1; KeyPressed = DebouncedKeyState; // i zregeneruj licznik. if (DebouncedKeyState ) Count = RELEASE / CHECK; else Count = PRESS / CHECK; } } }

Funkcja DebounceSwitch1() ustawia wartości dwóch zmiennych globalnych. KeyPressed jest bieżącym stanem, przewidywanym do podjęcia decyzji, natomiast KeyChanged sygnalizuje, że właśnie stan przycisku zmienił się z zamkniętego na otwarty lub odwrotnie. Wprowadzenie dwóch niezależnych stałych umożliwia określenie różnych przedziałów dla otwarcia i zamknięcia styku. Stosując stosunkowo niewielką wartość stałej PRESS i nieco większą dla RELEASE uzyskamy krótki czas reakcji systemu przy pewnym zabezpieczeniu przed zakłóceniami elektromagnetycznymi. Zamieszczona poniżej przykładowa procedura zwraca wartość 1 po wykryciu opadającego zbocza sygnału zamykania styku. Procedura DebounceSwitch2(), podobnie jak procedura z poprzedniego przykładu, jest wywoływana regularnie przez przerwania zegarowe lub podobny mechanizm opóźniający. Przesuwa ona bieżący, odczytany stan styku w zmiennej State. Przy założeniu, że styk zwraca wartość zerową przy zamknięciu, procedura będzie zwracała wartość zero aż do wykrycia dwunastu kolejnych stanów zerowych. Przykład 2 // Procedura do usuwania zakłóce ń obu zboczy, wywoływana co CHECK ms char DebounceSwitch2 () { static uint16_t State = 0; // Bie Ŝacy stan przetworzony State = (State << 1 ) | RawKeyPressed () | 0xE000 ; if (State == 0xF000 ) return 1; return 0; }

Jak długo styk pozostaje otwarty, 16-bitowy rejestr State pozostaje wypełniony jedynkami. Naciśnięcie i przytrzymanie przycisku powoduje wprowadzanie do rejestru i przesuwanie w lewo ciągu zer i jedynek, tak jak to pokazano na rysunku. W końcu jednak sytuacja się stabilizuje i po ostatniej jedynce zostaje wprowadzony ciąg zer. Na rejestrze jest wykonywana suma logiczna z 0xE000 (eliminująca nieistotne najstarsze bity). W momencie gdy ostatnia jedynka znajdzie się na najwyższej istotnej pozycji procedura wygeneruje wartość jeden. W ten sposób eliminuje się wpływ przypadkowych odczytów i wykrywa się przejście ze stanu otwarcia do zamknięcia styków. Zmieniając dwie stałe heksadecymalne możemy dopasować się do różnych warunków pracy styków i częstotliwości testowania ich stanu. Inną zaletą tego algorytmu jest łatwa adaptacja do kodu asemblerowego.

53

Obsługa wielu wejść Często mamy do czynienia z przypadkiem, gdy zestaw przełączników jest obsługiwany przez pojedynczy port. W takiej sytuacji nie ma potrzeby stosowania algorytmu indywidualnie do każdego ze styków. Możliwe podejście zaprezentowano w przykładzie 3. W tym przypadku funkcja RawKeyPressed() zwraca 8 - bitowy stan styków dołączonych do portu (stan 0 odpowiada naciśnięciu styku a 1 jego zwolnieniu). Przykład 3 #define MAX_CHECKS 10 // Ilo ść próbek stanu styku uint8_t DebouncedKeyState; // Pozycje naci śni ęte uint8_t ChangedState; // Wykrywanie naci śni ęcia uint8_t State[MAX_CHECKS]; // Wektor przechowuj ący stany przej ściowe uint8_t Index; // Wska źnik w wektorze State // Procedura wywoływana okresowo void DebounceSwitch3 () { uint8_t i, j; State[Index] = ~RawKeyPressed (); ++Index; j = 0xFF; for (i = 0; i < MAX_CHECKS; i++ ) j = j & State[i]; ChangedState = ~ DebouncedKeyState & j; DebouncedKeyState = j; if (Index >= MAX_CHECKS ) Index = 0; }

Funkcja DebounceSwitch3() jest okresowo wywoływana np. przez przerwanie zegarowe. Odczytuje ona stany 8 indywidualnych przełączników dołączonych do portu. Każdorazowo dane wprowadzane są na wejście kolejki cyklicznej State, która może być traktowana jak macierz składającą się z kolumn, odpowiadających kolejnym odczytom stanu styków oraz wierszy związanych z poszczególnymi stykami. W pętli wyznaczany jest bitowy iloczyn logiczny wszystkich kolumn State. Wynikowa zmienna DebouncedKeyState zawiera 1 tylko na pozycjach tych styków, które były zamknięte przez ostatnie MAX_CHECKS przerwań. W zmiennej ChangedState wartość 1 będą miały bity na tych pozycjach, w których DebounceKeyState zmieniło się od 0 do 1, czyli wykryte naciśnięcia przycisków. Jeszcze inną koncepcję przedstawiono w przykładzie 4 w postaci pełnego programu. Przykład 4 #include <avr/io.h> #include <avr/interrupt.h> #define RAW_STATE PINC #define KEY_DIR DDRC char DebouncedKeyState; // Przetworzony stan styków // bit = 1: styk zamkni ęty char KeyPressed; // Zapami ętanie zamkni ęcia styku void DebounceSwitch4 (); ISR (TIMER0_COMP_vect) { DebounceSwitch4 (); // Obsługa przerwania zegarowego

54

} void DebounceSwitch4 () { static char ct0, ct1, ct2; char i; i = DebouncedKeyState ^ ~RAW_STATE; // Czy wykryto zmiany stanu ct0 = (ct0 & i ) ^ 0xFF; // Reset ct0 lub zliczanie ct1 = (ct1 & i ) ^ ct0; // Reset ct1 lub zliczanie ct2 = (ct2 & i ) ^ (ct0 & ct1 ); // Reset ct2 lub zliczanie i &= ct0 & ct1 & ct2; // Zliczanie do przepełnienia DebouncedKeyState ^= i; // Zmiana stanu po przepełnieniu KeyPressed |= DebouncedKeyState & i; // 0->1: Wykrycie naci śni ęcia } char GetKeyPress (char keyMask ) { cli (); keyMask &= KeyPressed; KeyPressed ^= keyMask; // Kasowanie wykrycia sei (); return keyMask; } int main ( void ) { KEY_DIR = 0x00 ; // Wszystkie linie jako wej ścia DebouncedKeyState = 0; KeyPressed = 0; TCCR0 = _BV (WGM01) | _BV (CS02); // Podział przez 64 TIMSK = 1 << OCIE0; // Maska przerwania OCR0 = 6000 * 2 / 64.0 ; // Czas = 2 ms, zegar 6 MHz sei (); for(;;) { ... } // main loop }

Działanie pętli głównej programu jest przerywane w stałych odstępach czasu (regulowanych przez układ czasowy pracujący w trybie CTC). Procedura obsługi przerwania co 2 ms wywołuje funkcję DebounceSwitch4(), której zadaniem jest sprawdzenie stanu styków podłączonych do portu RAW_STATE. Na poszczególnych pozycjach zmiennej ~RAW_STATE jedynki oznaczają aktualnie wykryty stan zamknięcia styku. Zmienna DebouncedKeyState zawiera jedynki na pozycjach odpowiadających wykrytym zamkniętym stykom. Zmienna i zawiera porównanie stanu wynikowego (DebouncedKeyState) z aktualnym wczytanym stanem styków. Na pozycjach, gdzie występują różnice, bity zmiennej i będą miały wartość 1. Bity zmiennych ct0, ct1 i ct2 stanowią trójkami liczniki zliczające kolejne jedynki na poszczególnych pozycjach zmiennej i. Liczniki te są zerowane po wykryciu zera na odpowiadającej pozycji zmiennej i. Jeżeli aktualny stan na danej pozycji w RAW_STATE utrzymuje się w ośmiu kolejnych próbkach (przepełnienie licznika), to następuje zarejestrowanie tego w zmiennej DebouncedKeyState. Teraz zawartość DebouncedKeyState i ~RAW_STATE zrównują sie (odpowiednie pozycje zmiennej i będą zerowe), aż do wystąpienia kolejnych zmian w RAW_STATE.

55

W programie dodatkowo wprowadzono globalną zmienną KeyPressed, która zawiera flagi zamknięcia poszczególnych styków. Flagi te, po wykorzystaniu można kasować, oczekując na kolejne zamknięcie styków, jak to pokazano przykładowo w funkcji GetKeyPress().

56

Dodatek E. Interfejs szeregowy RS232

Standard RS–232 (Recommended Standard) został ustanowiony w 1969 r. przez Electronic Industries Association. Definiuje on sposób nawiązania i przeprowadzenia łączności między dwoma urządzeniami tzw. DTE ( Data Terminal Equipment) za pośrednictwem modemów tzw. DCE (Data Communication Equipment) lub bez nich. Jest to obecnie standard łącza szeregowego do połączenia komputera PC z urządzeniami zewnętrznymi. Połączenia między urządzeniami (DTE – DCE lub DTE – DTE) dokonuje się za pomocą złączy 25 – stykowych lub 9 – stykowych. Najważniejsze linie magistrali RS– 232C podane są w tabeli.

Linie Danych (obowiązuje logika negatywna):

• TxD – dane nadawane.

• RxD – dane odbierane Linie sterujące (obowiązuje logika pozytywna):

• RTS – żądanie nadawania danych zgłaszane przez terminal DTE

• CTS – gotowość do nadawania zgłaszana przez modem DCE (przesyła potwierdzenie odebrania sygnału RTS)

• DSR – gotowość modemu DCE do dalszej współpracy z DTE (aktywny przez cały czas trwania połączenia)

• DTR – gotowość DTE do dalszej współpracy z DCE (aktywny przez cały czas trwania połączenia)

• DCD – sygnał wykrycia przez modem fali nośnej (oznacza, że łączy się on z innym modemem)

Linie masy:

• SG – masa sygnałowa

• PG – masa ochronna połączona z obudową urządzenia Istnieje wiele sposobów wykorzystania różnych podzbiorów tych linii. W najprostszym przypadku wykorzystuje się tylko 3 linie:

• TxD – dane nadawane

57

• RxD – dane odbierane

• SG – masa sygnałowa Jeżeli łączymy urządzenie typy DTE (komputer) z urządzeniem z DCE (modem) to styki łączymy wprost. Jeżeli komputer do komputera to używamy tzw. konfiguracji null modem. Na przykład dla wtyków 9-cio pinowych:

Linie DTR, DSR, RTS, CTS i DCD umożliwiają synchronizację transmisji tak, dane były wysyłane zawsze wtedy, gdy urządzenie po drugiej stronie połączenia jest gotowe do ich odbioru. Prosty przykład transmisji jednokierunkowej (simplex) może wyglądać następująco:

1. Aby transmisja była możliwa oba urządzenia muszą ustawić linie gotowości na „1”. Gotowość komputera (DTR) i modemu (DSR) musi być utrzymywana na „1” przez całą transmisję.

2. Komputer ustawia RTS (żądanie nadawania) na „1” 3. W odpowiedzi na RTS modem ustawia linię CTS (gotowość do nadawania) na „1” 4. Widząc to komputer rozpoczyna nadawanie

Rodzaje transmisji ze względu na kierunek przepływu danych:

• Transmisja simpleksowa – jednokierunkowa transmisja, w której tylko DTE1 przekazuje dane DTE2 lub tylko DTE2 przekazuje dane DTE1

• Transmisja półdupleksowa – dwukierunkowa transmisja niejednoczesna np. najpierw DTE1 – DTE2, a następnie DTE2 – DTE1

• Transmisja dupleksowa – dwukierunkowa transmisja jednoczesna, w tym samym czasie DTE1 – DTE2 i DTE2 – DTE1

Transmisja szeregowa w mikrokontrolerach może być zaimplementowana na dwa sposoby:

• Programowo – niezbędne sygnały do realizacji transmisji generowane i interpretowane są przez mikrokontroler, wystawiane i odbierane na zewnątrz poprzez porty we/wy

58

• Sprzętowo – poprzez moduł USART zaimplementowany w mikrokontrolerze (np. PIC18F4520)

Rejestry wykorzystywane w czasie transmisji PORTC Piny modułu USASRT zostały wyprowadzone na zewnątrz z wykorzystaniem portu C (RC6/TX/CK, RC7/RX/DT). W celu uruchomienia transmisji szeregowej należy:

• Bit SPEN (RCSTA<7>) ustawić na 1

• Bit TRISC<7> ustawić na 1

• Bit TRISC<6> ustawić na 1 TXSTA Rejestr statusu i kontroli nadawania

Bit 7 CSRC: bit wyboru źródła sygnału zegara:

Tryb Asynchroniczny: bez znaczenia. Tryb Synchroniczny: 1 = Tryb Master (Zegar generowany wewnętrznie z BRG), 0 = Tryb Slave (Zegar z źródła zewnętrznego).

Bit 6 TX9 : bit włączenia transmisji 9 – bitowej: 1 = transmisja 9 bitowa, 0 = transmisja 8 bitowa.

Bit 5 TXENbit włączający transmisję: 1 = transmisja możliwa, 0 = transmisja niemożliwa. Uwaga : SREN/CREN jest nadrzędny w stosunku do TXEN w trybie SYNC.

Bit 4 SYNC : bit wyboru trybu USART, 1 = tryb synchroniczny, 0 = tryb asynchroniczny.

Bit 2 BRGH : bit wyboru szybkiej prędkości bodowej: Tryb Asynchroniczny: 1 = duża prędkość, 0 = niska prędkość. Tryb Synchroniczny: Nieużywany w tym trybie

Bit 1 TRMT : bit statusu rejestru przesuwającego w nadawaniu: 1 = TSR pusty, 0 = TSR pełny.

Bit 0 TX9D : 9–ty bit danych transmitowanych - może być bitem parzystości.

59

RCSTA Rejestr statusu i kontroli odbioru

Bit 7 SPEN : bit uaktywniania portu szeregowego

1 = port szeregowy aktywny (konfiguruje piny RX/DT i TX/CK jako piny portu szeregowego), 0 = port szeregowy nieaktywny.

Bit 6 RX9 : bit włączenia odbioru 9 – bitowego: 1 = odbiór 9 bitowa, 0 = odbiór 8 bitowa.

Bit 5 SREN bit włączający jednokrotny odbiór: Tryb Asynchroniczny: bez znaczenia. Tryb Synchroniczny – Master: 1= włącza jednokrotny odbiór, 0= wyłącza jednokrotny odbiór. Bit jest zerowany po zakończeniu odbioru. Tryb Synchroniczny – Slave: bez znaczenia.

Bit 4 CREN : bit aktywowania odbioru ciągłego: Tryb Asynchroniczny: 1= włącza ciągły odbiór, 0= wyłącza ciągły odbiór. Tryb Synchroniczny: 1=ciągły odbiór dopóki bit CREN nie jest wyzerowany (CREN jest nadrzędny w stosunku do SREN), 0=wyłącza ciągły odbiór.

Bit 3 ADDEN : bit aktywowania wykrywania adresu: Tryb Asynchroniczny 9 – bitowy (RX9 = 1 ) 1 = uaktywnia wykrywanie adresu , uaktywnia przerwanie i opróżnia bufor odczytu, kiedy RSR<8> jest ustawiony, 0 = dezaktywuje wykrywanie adresu, wszystkie bajty są odczytywane i dziewiąty bit może być wykorzystany jako bit parzystości.

Bit 2 FERR : bit błędu ramki: 1=błąd ramki (może być zmieniony przez odczyt rejestru RCREG i odbiór następnego znaczącego bajtu), 0=brak błędu ramki.

Bit 1 OERR : bit błędu przepełnienia 1 = błąd przepełnienia (kasowanie poprzez wyzerowanie bitu CREN), 0 = brak błędu przepełnienia

Bit 0 RX9D : 9–ty bit danych odebranych (może być bitem parzystości).

60

SPBRG Rejestr generatora szybkości transmisji Układ BRG wspomaga oba tryby pracy interfejsu USART – synchroniczny i asynchroniczny. Jest to dedykowany 8-bitowy generator szybkości transmisji. Rejestr SPBRG kontroluje okres swobodnej pracy 8-bitowego zegara. W trybie asynchronicznym bit BRGH (TXSTA<2>) kontroluje również szybkość transmisji. W trybie synchronicznym bit BRGH jest ignorowany. Poniższa tabela pokazuje wzory potrzebne do obliczenia szybkości transmisji dla różnych trybów USART. Mając podaną żądaną szybkość transmisji i Fosc, najbliższa wartość całkowita dla rejestru SPBRG może być obliczona przy użyciu wzorów z poniższej tabeli. Korzystne może być użycie wysokiej szybkości transmisji (BRGH=1) nawet dla wolniejszych zegarów transmisji. Dzieje się tak dlatego, gdyż równanie Fosc/(16(X+1)) może w niektórych przypadkach zredukować błąd transmisji. Wpisanie nowej wartości do rejestru SPBRG powoduje zresetowanie timera BRG.

TXREG Bufor dla danych wyjściowych RCREG Bufor dla danych wejściowych PIR1 Rejestr flag przerwań

Bit 5 RCIF Przerwanie generowanie w czasie odbioru danych 1=bufor pełny (rejestr RCREG)

0=bufor pusty (rejestr RCREG) Bit 4 TXIF Przerwanie generowane w czasie wysyłania danych 1=bufor pusty (rejestr TXREG) 0= bufor pełny (rejestr TXREG)

Dodatek F. Interfejs I I²C jest to szeregowa, dwukierunkowa magistrala służąca do przesyłania danych w urządzeniach elektronicznych. Została opracowana przez firmę Philips na początku lat 80. Znana również pod akronimem IIC, którego angielskie rozwinięcieI2C składa się z dwóch linii sygnałowych

• SDA (serial data) - do przesyłania danych

• SCL (serial clock) - do przesyłania sygnału taktującego, oraz linii masy. Obydwie linie magistrali I2C są liniami dwukierunkowymi. Dzięki przemyślanej konstrukcji magistrali I2C może być do niej podłączonych wiele układów.Transmisja danych po szynie Iprzesyłanym linią SCL. Gdy na linii SCL panuje stan wysoki, to dane muszą się znajdować w stanie ustalonym, natomiast gdy linia SCL jest w stanie niskim, to stan linii Szmienić.

Każda transmisja magistralą I2

jest nadawany poprzez wygenerowanie na linii SDA linii SCL jest stan wysoki. Natomiast bit stopu SDA zbocza narastającego przy wysokim stanie linii SCL.

Każdy bajt przesłany magistralą Inajbardziej znaczącego do bitu najmniej znaczącego. Liczba bajtów przesłanych podczas jednej transmisji nie jest ograniczona. Każda transmisja basygnałem potwierdzenia wystawianym przez urządzenie odbierające dane.

61

Interfejs I2C

szeregowa, dwukierunkowa magistrala służąca do przesyłania danych w iach elektronicznych. Została opracowana przez firmę Philips na początku lat 80.

Znana również pod akronimem IIC, którego angielskie rozwinięcie to Intera się z dwóch linii sygnałowych:

do przesyłania danych

do przesyłania sygnału taktującego, oraz linii masy. C są liniami dwukierunkowymi. Dzięki przemyślanej konstrukcji

magistrali I2C może być do niej podłączonych wiele układów. ransmisja danych po szynie I2C jest transmisją synchroniczną i jest taktowana sygnałem

przesyłanym linią SCL. Gdy na linii SCL panuje stan wysoki, to dane muszą się znajdować w stanie ustalonym, natomiast gdy linia SCL jest w stanie niskim, to stan linii S

2C rozpoczyna sie bitem startu, a kończy bitem stopu. Bit startu zez wygenerowanie na linii SDA opadającego zbocza w momencie gdy na

linii SCL jest stan wysoki. Natomiast bit stopu jest nadawany poprzez wygenerowanie na linii SDA zbocza narastającego przy wysokim stanie linii SCL.

Każdy bajt przesłany magistralą I2C musi się składać z 8 bitów. Dane są przesyłane od bitu najbardziej znaczącego do bitu najmniej znaczącego. Liczba bajtów przesłanych podczas jednej transmisji nie jest ograniczona. Każda transmisja bajtu danych powinna się zakończyć

a wystawianym przez urządzenie odbierające dane.

szeregowa, dwukierunkowa magistrala służąca do przesyłania danych w iach elektronicznych. Została opracowana przez firmę Philips na początku lat 80.

ter-Integrated Circuit.

do przesyłania sygnału taktującego, oraz linii masy. C są liniami dwukierunkowymi. Dzięki przemyślanej konstrukcji

ą i jest taktowana sygnałem przesyłanym linią SCL. Gdy na linii SCL panuje stan wysoki, to dane muszą się znajdować w stanie ustalonym, natomiast gdy linia SCL jest w stanie niskim, to stan linii SDA może się

C rozpoczyna sie bitem startu, a kończy bitem stopu. Bit startu adającego zbocza w momencie gdy na

jest nadawany poprzez wygenerowanie na linii

C musi się składać z 8 bitów. Dane są przesyłane od bitu najbardziej znaczącego do bitu najmniej znaczącego. Liczba bajtów przesłanych podczas

jtu danych powinna się zakończyć a wystawianym przez urządzenie odbierające dane.

Transmisja szeregowa z wykorzystaniem interfejsu Izaimplementowana na dwa sposoby:

• Programowo – niezbędne sygnały do realizacji transmisji generowane i interpretowane są przez mikrokontroler, wystawiane i odbierane na zewnątrz poprzez porty we/wy

• Sprzętowo – poprzez moduł zaimplementowany w mikrokontrolerze (np. PIC18F4520)

Moduł synchroniczny portu szeregowego (Master Synchronousszeregowym interfejsem używanym do komunikacji z układami peryferyjnymi lubmikrokontrolerami. Tymi urządzeniami mogą być szeregowe pamięci EEPROM,przesuwne, sterowniki wyświetlaczy, przetworniki A/D i inne. Modułjednym z dwóch trybów:

• szeregowy interfejs SPI (Serial Peripheral Interface),

• szeregowy interfejs I2C (Inter Interfejs I2C sprzętowo obsługuje następujące tryby pracy:

• tryb nadrzędny (master mode)

• tryb (multi-master mode)

• tryb podrzędny (slave mode)

Rejestry związane z interfejsem I SSPSTAT Rejestr statusu

Bit 7 SMP: wybór momentu próbkowania danych wej

Tryb SPI Master: 1 = dana wejściowa jest próbkowana na końcu czasu wyjścia danych,0 = dana wejściowa jest próbkowana w środku czasu wyjścia danych.Tryb SPI Slave: Bit SPM musi być wyzerowany, kiedy SPI jest u

62

Transmisja szeregowa z wykorzystaniem interfejsu I2C w mikrokontrolerach może być zaimplementowana na dwa sposoby:

niezbędne sygnały do realizacji transmisji generowane i rzez mikrokontroler, wystawiane i odbierane na zewnątrz

poprzez moduł MSPP (synchroniczny port szeregowy)zaimplementowany w mikrokontrolerze (np. PIC18F4520)

Moduł synchroniczny portu szeregowego (Master Synchronous Serial Port ywanym do komunikacji z układami peryferyjnymi lub

mikrokontrolerami. Tymi urządzeniami mogą być szeregowe pamięci EEPROM,przesuwne, sterowniki wyświetlaczy, przetworniki A/D i inne. Moduł MSSP mo

szeregowy interfejs SPI (Serial Peripheral Interface),

szeregowy interfejs I2C (Inter-Integrated Circuit).

Interfejs I2C sprzętowo obsługuje następujące tryby pracy:

(master mode),

master mode),

(slave mode),

Rejestry związane z interfejsem I2C

SMP: wybór momentu próbkowania danych wejściowych:

1 = dana wejściowa jest próbkowana na końcu czasu wyjścia danych,= dana wejściowa jest próbkowana w środku czasu wyjścia danych.

Bit SPM musi być wyzerowany, kiedy SPI jest używany w trybie Slave

C w mikrokontrolerach może być

niezbędne sygnały do realizacji transmisji generowane i rzez mikrokontroler, wystawiane i odbierane na zewnątrz

MSPP (synchroniczny port szeregowy)

Serial Port – MSSP) jest ywanym do komunikacji z układami peryferyjnymi lub innymi

mikrokontrolerami. Tymi urządzeniami mogą być szeregowe pamięci EEPROM, rejestry MSSP może pracować w

1 = dana wejściowa jest próbkowana na końcu czasu wyjścia danych, = dana wejściowa jest próbkowana w środku czasu wyjścia danych.

ywany w trybie Slave

63

Bit 6 CKE: wybór zbocza sygnału zegarowego dla transmisji danych: CKP=0: 1 = dana transmitowana przy narastającym zboczu SCK, 0 = dana transmitowana przy opadającym zboczu SCK. CKP=1: 1 = dana transmitowana przy opadającym zboczu SCK, 0 = dana transmitowana przy narastającym zboczu SCK.

Bit 5 D/~A: dane/zanegowany adres ():

używany tylko w trybie I2C Bit 4 P: bit STOP:

używany tylko w trybie I2C, bit ten jest zerowany, kiedy moduł MSSP jest wyłączony, SSPEN jest zerowany,

Bit 3 S: bit START:

używany tylko w trybie I2C, Bit 2 R/~W: zapis/odczyt informacji:

używany tylko w trybie I2C, Bit 1 UA: wskaźnik aktualizacji adresu:

używany tylko w trybie I2C, Bit 0 BF: flaga zajętości bufora SSPBUF(tylko w trybie odbioru):

1 = odbiór kompletny, SSPBUF jest pełny, 0 = odbiór nie jest kompletny, SSPBUF jest pusty.

SSPCON1 Rejestr kontrolny

Bit 7 WCOL: detekcja kolizji (tylko w trybie nadawania):

1 = rejestr SSPBUF jest zapisywany podczas trwania transmisji poprzedniego słowa (musi być wyzerowany programowo), 0 = brak kolizji.

Bit 6 SSPPOV: przepełnienie rejestru przy odbiorze:

tryb Slave SPI 1 = nowy bajt jest odbierany, podczas gdy rejestr SSPBUF nadal przechowuje poprzednią daną. W razie przepełnienia dana w SSPSR jest tracona. Przepełnienie może wystąpić jedynie w trybie Slave. Aby uniknąć przepełnienia użytkownik musi odczytać SSPBUF, nawet gdy tylko transmituje daną. (musi być zerowany programowo), 0 = brak przepełnienia,

64

Bit 5 SSPEN: uaktywnienie modułu SSP: 1 = uaktywnienie portu szeregowego i skonfigurowanie SCK, SDO, SDI i ~SS jako pinów portu szeregowego, 0 = zablokowanie portu szeregowego i skonfigurowanie tych pinów jako pinów portu we/wy. Aktywne piny muszą być skonfigurowane odpowiednio jako wejścia lub wyjścia

Bit 4 CKP: bit polaryzacji zegara:

1 = stan czuwania dla zegara jest poziomem wysokim, 0 = stan czuwania dla zegara jest poziomem niskim,

Bit 3-0 SSPM3: SSPM0: wybór trybu pracy SSP:

0101 = tryb SPI Slave, zegar = pin SCK, pin kontrolny ~SS nie aktywny, pin ~SS może być użyty jako pin we/wy, 0100 = tryb SPI Slave, zegar = pin SCK, pin kontrolny ~SS aktywny, 0011 = tryb SPI Master, zegar= wyjście TMR2/2, 0010 = tryb SPI Master, zegar = Fosc/64, 0001 = tryb SPI Master, zegar = Fosc/16, 0000 = tryb SPI Master, zegar = Fosc/4, 1111 = I2C Slave mode, 10-bit address with Start and Stop bit interrupts enabled 1110 = I2C Slave mode, 7-bit address with Start and Stop bit interrupts enabled 1011 = I2C Firmware Controlled Master mode (Slave Idle) 1000 = I2C Master mode, clock = FOSC/(4 * (SSPADD + 1)) 0111 = I2C Slave mode, 10-bit address 0110 = I2C Slave mode, 7-bit address

SSPCON2 Rejestr kontrolny

Bit 7 GCEN: General Call Enable bit (Slave mode only)

1 = Enables interrupt when a general call address (0000h) is received in the SSPSR 0 = General call address disabled.

Bit 6 ACKSTAT: Acknowledge Status bit (Master Transmit mode only)

1 = Acknowledge was not received from slave 0 = Acknowledge was received from slave

Bit 5 ACKDT: Acknowledge Data bit (Master Receive mode only)

1 = Not Acknowledge 0 = Acknowledge

Bit 4 ACKEN: Acknowledge Sequence Enable bit (Master Receive mode only)

1 = Initiates Acknowledge sequence on SDA and SCL pins and transmit ACKDT data bit. Automatically cleared by hardware.

65

0 = Acknowledge sequence Idle Bit 3 RCEN: Receive Enable bit (Master mode only)

1 = Enables Receive mode for I2C 0 = Receive Idle

Bit 2 PEN: Stop Condition Enable bit (Master mode only)

1 = Initiates Stop condition on SDA and SCL pins. Automatically cleared by hardware. 0 = Stop condition Idle

Bit 1 RSEN: Repeated Start Condition Enable bit (Master mode only)

1 = Initiates Repeated Start condition on SDA and SCL pins. Automatically cleared by hardware. 0 = Repeated Start condition Idle

Bit 0 SEN: Start Condition Enable/Stretch Enable bit

In Master mode: 1 = Initiates Start condition on SDA and SCL pins. Automatically cleared by hardware. 0 = Start condition Idle In Slave mode: 1 = Clock stretching is enabled for both slave transmit and slave receive (stretch enabled) 0 = Clock stretching is disabled

SSPADD W trybie Master służy do programowania prędkości transmisji (patrz opis rejestru SSPCON1) SSPBUF Rejestr buforujący dane nadawane i odbierane PIR1 Rejestr flag przerwań

Bit 3 SSPIF Przerwanie generowane w czasie nadawania/odbierania danych 1 = nadawanie/odbiór zakończone (musi być kasowany programowo)

0 = nadawanie/odbiór w toku

66

Dodatek G. Programowanie mikrokontrolera ATMega128 w języku C W projektach realizowanych w Laboratorium można używać modułów opracowanych dla sprzętu wykorzystywanego w ćwiczeniach (wyświetlacz LCD oraz komunikacja 1-Wire). Aby użyć modułów lcd i/lub one_wire, należy w ustawieniach kompilatora dodać bibliotekę libswm (opcja -lswm). Gdy używamy środowiska AVR Studio, należy z menu głównego wybrać Projekt Właściwości…, a następnie w zakładce Toolchain (AVR/GNU C Linker -> Libraries) dołączyć do projektu zarchiwizowany plik biblioteki libswm.a. Takie ustawienie wywoła wprowadzenie zmian do pliku Makefile używanego do sterowania procesem kompilacji.

W trakcie wykonywania ćwiczeń laboratoryjnych należy napisać i uruchomić programy w języku C (używając dostarczonego przez pakiet WinAVR zestawu: kompilatora avr-gcc, narzędzi avr-binutils oraz biblioteki avr-libc), realizujące zadane tematy ćwiczeń. Programy narzędziowe dostarczane przez środowisko przetwarzają kod źródłowy C, zapisany w pliku wejściowym na kod wykonawczy, zapisywany w pamięci FLASH mikroprocesora (oraz ewentualnie dane zapisywane w pamięci EEPROM).

Przebieg kompilacji projektu Na początku uruchomiony zostaje tzw. preprocesor, którego zadaniem jest wprowadzenie do kodu zmian zgodnych z dyrektywami kompilacji:

• #include – dołączanie dodatkowych plików,

• #define – wstawianie definicji i rozwijanie makroinstrukcji,

• #if, #else, #endif, #ifdef, #ifndef – dyrektywy kompilacji warunkowej. Tak spreparowany kod zostaje poddany procesowi kompilacji, czyli zamianie zapisu C na kod maszynowy. W tym etapie mogą działać procedury optymalizacji kodu. Następnym etapem jest konsolidacja (linkowanie) programu, czyli umieszczenie wszystkich części programu w odpowiednich miejscach pamięci. Jednocześnie zostają dołączone niezbędne funkcje biblioteczne, wykorzystywane w programie (jawnie lub nie). W efekcie powstaje plik obiektowy zawierający wszystkie informacje potrzebne programom

67

narzędziowym do wykonywania swych funkcji. Wszystkie te programy wywoływane są za pośrednictwem środowiska uruchomieniowego AVR Studio.

Struktura programu Na początku programu umieszczamy definicje stałych kompilacji i makr, dyrektywy dołączania plików, ewentualne deklaracje funkcji, oraz deklaracje zmiennych globalnych i definicje funkcji. Program, zgodnie z zasadami języka C, musi zawierać bezargumentową funkcję main – główną funkcję programu. W kodzie tej funkcji umieszczamy czynności, które mają być wykonane przy starcie programu oraz nieskończoną pętlę, realizującą program. Realizacja głównej funkcji programu nigdy się nie kończy, zatem niepotrzebna jest deklaracja wyjściowa return. Program dla mikrokontrolera ATMega 128 ma architekturę harwardzką, tzn. obszar danych jest oddzielony od obszaru kodu programu. Kod programu umieszczany jest w pamięci FLASH (sekcja .text programu). Po zakończeniu procesu kompilacji sekcja .text zawiera kolejno części:

• <__vectors> - wektor przerwań, zawierający skoki do procedur obsługi. Na pierwszej pozycji (adres 0x00) jest skok omijający wektor przerwań.

• <__ctors_end> - wyzerowanie rejestru SREG i ustawienie wierzchołka stosu w 16-bitowym rejestrze SP (SPL i SPH).

• <__do_copy_data> - kopiowanie do sekcji .data pamięci RAM wartości początkowych dla zmiennych inicjowanych.

• <__do_clear_bss>, <__do_clear_bss_loop> i <__do_clear_bss_start> - zerowanie zmiennych w sekcji .bss.

• <__bad_interrupt> - skok do adresu 0x00.

• <__vector_n> - procedura obsługi przerwania nr n.

• <nazwa_funkcji> - kody poszczególnych funkcji programu.

• <main> - kod głównej funkcji programu.

• <_exit> i <__stop_program> - zablokowanie przerwań i pętla (skok na siebie) - obsługa awaryjnego zakończenia programu (gdy zakończy się działanie funkcji main.

Rozmieszczenie danych Dane programu rozmieszczane są w różnych sekcjach pamięci RAM.

Schemat wykorzystania wewnętrznej pamięci RAM przedstawiono na rysunku powyżej. Pierwsze 256 bajtów w pamięci RAM zarezerwowane jest dla rejestrów procesora (SFR), a zmienne umieszczane są począwszy od adresu 0x100. Po obszarze danych (sekcje .data, .bss i .noinit) rozpoczyna się obszar sterty (heap), służący do przechowywania danych dynamicznych. Od końca pamięci (adres RAMEND) umieszczony jest stos (stack), który rozbudowywany jest w dół. W bibliotece avr-libc (moduł <stdint.h>) zdefiniowano nowe typy całkowite: int8_t, uint8_t, int16_t, uint16_t …, aby uniknąć zależności od platformy, na której uruchamiany jest kompilator.

SFR .data .bss heap stack.noinit

RAMEND0x10FF

wsk. stosu

0x100

0x00

Pamięć danych SRAM (4 kB)0x60

0x2032 rejestry

160 rejestrów Ext I/O

64 rejestry I/O

0xFF

68

Zmienne zainicjowane wartością W pierwszej kolejności w pamięci RAM umieszczone zostają zmienne zainicjowane wartością, np. po takim fragmencie programu: char data1 = 5 ; uint8_t tab1[][] = { {1, 'A' }, {2, 'B' }, {3, 'C' } }; zmienne data1 i tab1 zostaną umieszczone w segmencie .data programu.

Zmienne zerowane przy starcie W sekcji .bss zostają umieszczone zmienne niezainicjowane, którym przy starcie zostaje przypisana wartość 0, i tak po zapisie: uint8_t bss1 ; char tab2[3] ;

w segmencie .bss umieszczone zostaną zmienne bss1 oraz tab2.

Zmienne nieinicjowane Programista może spowodować utworzenie na końcu .bss dodatkowej sekcji o nazwie .noinit, w której będą umieszczane zmienne nieinicjowane, czyli posiadające wartość przypadkową przy pierwszym uruchomieniu programu. W takim przypadku można deklarować takie zmienne, np. po utworzeniu pomocniczego makra: #define NOINIT __attribute__ ((section (".noinit" ))) char noinit1 NOINIT ; int tab3[2][3] NOINIT ; Zmienne noinit1 i tab3, po włączeniu zasilania będą miały wartość przypadkową, ale po resecie spowodowanym zadziałaniem watchdog'a zachowana będzie ich poprzednia wartość (a nie będą inicjowane, jak w przypadku zmiennych w sekcji .data ani zerowane, jak w przypadku zmien-nych w sekcji .bss).

Dane inicjowane w pamięci EEPROM Aby umieścić zmienną w sekcji .eeprom można użyć makra EEMEM, przypisującego zmienną do tej sekcji, zdefiniowanego w module <avr/eeprom.h>. Przykładowa deklaracja takiej zainicjowanej zmiennej: unsigned char tab4[6] EEMEM = {'S', 'T', 'A', 'R', 'T', 0x00 }; W laboratorium sekcja .eeprom nie jest automatyczne umieszczana w pamięci EEPROM, gdyż interfejs JTAG-TWICE nie daje takiej możliwości. Po kompilacji powstaje plik binarny z rozszerzeniem .eep, który może być przesłany do pamięci EEPROM układu za pośrednictwem programatora ISP.

69

Dane inicjowane w pamięci FLASH Również pamięć FLASH można wykorzystać do przechowywania zainicjowanych stałych . W tym celu należy dołączyć moduł <avr/pgmspace.h> zawierający odpowiednie makra. Umieszczenie danych w pamięci FLASH uzyskamy za pomocą makra PROGMEM: unsigned char tab5[5] PROGMEM = {'S', 'T', 'O', 'P', 0x00 }; Można również wykorzystać zdefiniowane w module <avr/pgmspace.h> typy zmiennych: prog_void, prog_char, prog_uchar, prog_int8_t, prog_uint8_t, ..., definiowanych w obszarze programu.

Dostęp do danych w programie Dostęp do zmiennych przez bezpośrednie odwołania dotyczy wyłącznie zmiennych przechowywanych w pamięci RAM. Nazwy rejestrów obszaru wejścia/wyjścia procesora, zgodne z dokumentacją (patrz Dodatek F), są zdefiniowane w module <avr/sfr_defs.h> wraz z odpowiednimi makrami, dzięki czemu użycie w programie podstawienia np.: PORTB = 0xF5 ; uint8_t tmp = PIND ; powoduje wysłanie do portu B bajtu 0xF5 i podstawienie na zmienną tmp bajtu wczytanego z portu D. Uruchomienie programu w środowisku AVR Studio daje możliwość kontrolowania pracy procesora za pośrednictwem interfejsu JTAG-ICE i punktów kontrolnych (Breakpoint). Uwaga! Wynikowy kod programu może być optymalizowany i nie zawsze instrukcjom języka wysokiego poziomu, jakim jest C, będą odpowiadać punkty przerwań.

Dane w pamięci EEPROM Pamięć EEPROM traktowana jest jak urządzenie zewnętrzne i zapis do niej odbywa się za pośrednictwem sterownika, do którego wysyła się: adres do rejestru adresowego (EEAR), dane do rejestru danych (EEDR) i sygnał zapisu do rejestru sterującego (EECR). Przy odczycie wysyłamy: adres do rejestru EEAR i sygnał odczytu do rejestru EECR. Następnie odczytujemy dane z rejestru EEDR. W module <avr/eeprom.h> umieszczono funkcje, umożliwiające dostęp do zmiennych przechowywanych w pamięci EEPROM

// Odczyt bajtu z EEPROM uint8_t x = eeprom_read_byte (&tab4[5] ); // Zapis bajtu do EEPROM eeprom_write_byte (&tab4[4], x );

Dane w pamięci FLASH Do czytania z pamięci FLASH jest specjalny rozkaz w liście instrukcji mikroprocesora: lpm reg,

addr, przy czym adres liczony jest w słowach (a nie w bajtach). Dla ułatwienia pobierania stałych umieszczonych w pamięci FLASH, w module <avr/pgmspace.h> zdefiniowano odpowiednie makra, np.: uint8_t x = pgm_read_byte (&tab5[0] );

70

Uwaga! Próba pobrania znaku z tablicy tab5, umieszczonej w pamięci FLASH, za pomocą podstawienia: uint8_t x = tab5[0] ; zakończy się niepowodzeniem. Powyższy zapis spowoduje pobranie bajtu danych z pamięci RAM, spod programowego (wyliczonego w pamięci FLASH) adresu zmiennej tab5, traktowanego jako bajtowy(!).

Moduły biblioteki avr-libc Kompilator avr-gcc dostarczany jest wraz z dedykowaną biblioteką avr-libc, której moduły można dołączać do programu dyrektywą #include. Ścieżka dostępu do folderu include, zawierającego moduły biblioteki avr-libc jest umieszczona w zmiennej środowiskowej PATH podczas instalacji kompilatora. Poniżej przedstawiono wykaz modułów biblioteki: Folder include

<alloca.h>: Alokacja pamięci dla stosu <assert.h>: Diagnostyki <ctype.h>: Działania na zmiennych znakowych <errno.h>: Błędy systemowe <inttypes.h>: Konwersje typów całkowitych <math.h>: Funkcje matematyczne <setjmp.h>: Skoki nielokalne <stdint.h>: Standardowe typy całkowite <stdio.h>: Standardowe procedury obsługi wejścia/wyjścia <stdlib.h>: Podstawowe procedury obsługi <string.h>: Działania na łańcuchach

Podfolder avr <avr/boot.h>: Funkcje obsługi boot-loadera <avr/eeprom.h>: Obsługa pamięci EEPROM <avr/fuse.h>: Obsługa przełączników (Fuse) <avr/interrupt.h>: Przerwania <avr/io.h>: Definicje obsługi wejścia/wyjścia, specyficzne dla procesora AVR <avr/lock.h>: Obsługa bitów konfiguracyjnych (Lockbit) <avr/pgmspace.h>: Obsługa pamięci programu (FLASH) <avr/power.h>: Obsługa oszczędzania energii <avr/sfr_defs.h>: Definicje rejestrów procesora <avr/sleep.h>: Obsługa oszczędzania energii i trybów hibernacji (Sleep) <avr/version.h>: Numer wersji biblioteki <avr/wdt.h>: Obsługa watchdoga

Podfolder util <util/atomic.h>: Atomically and Non-Atomically Executed Code Blocks <util/crc16.h>: Obliczanie CRC <util/delay.h>: Funkcje czasowego wstrzymywania programu <util/delay_basic.h>: Podstawowe pętle opóźniające <util/parity.h>: Generowanie bitów kontroli parzystości <util/setbaud.h>: Makra do obliczania prędkości transmisji <util/twi.h>: Definicje masek dla transmisji I2C (TWI)

71

Podfolder compat <compat/deprecated.h>: Elementy przestarzałe, wycofane z biblioteki <compat/ina90.h>: Kompatybilność z IAR EWB 3.x

Obsługa przerwań Procedurę obsługi przerwania budujemy za pomocą makra ISR(vect), gdzie vect jest nazwą przerwania, zgodnie z poniższą tabelą.

Uruchomienie obsługi przerwań odbywa się za pomocą makra sei( ) i ustawienia odpowiednich bitów masek we właściwych rejestrach, natomiast globalne zablokowanie systemu obsługi przerwań zapewnia makro cli( ). Dla obsługi przerwań należy włączyć do programu moduł biblioteczny <avr/interrupt.h>.

72

Moduły dedykowane do laboratorium W programach pisanych w Laboratorium można używać modułów opracowanych dla wykorzystywanego w ćwiczeniach sprzętu (wyświetlacz LCD oraz komunikacja 1-Wire). Aby użyć modułów lcd i/lub one_wire, należy w ustawieniach kompilatora dodać bibliotekę libswm (opcja -lswm). Gdy używamy środowiska AVR Studio, należy z menu głównego wybrać Project.Configuration Options, a następnie w zakładce Libraries dołączyć do projektu zarchiwizowany plik biblioteki libswm.a. Takie ustawienie wywoła wprowadzenie zmian do pliku Makefile używanego do sterowania procesem kompilacji.

Moduł <lcd.h> Moduł dołączamy dyrektywą #include <lcd.h>. Zawartość pliku nagłówkowego lcd.h: //Procedury obsługi wy świetlacza LCD: #ifndef _LCD_H_ # define _LCD_H_ "lcd.h" #else # error "Attempt to include more than one <lcd.h> file." #endif #ifndef _AVR_IO_H_ # include <avr/io.h> #endif /* Dla obsługi wy świetlacza nale Ŝy uaktywni ć dost ęp do zewn ętrznej pami ęci RAM. W tym celu ustawiamy bity SRE i SRW10 w rej . MCUCR oraz bity SRW00, SRW01 i SRW11 w rejestrze XMCRA. Przykładowo moŜe to by ć zrealizowane w postaci kodu: MCUCR = _BV(SRE) |_BV(SRW10); XMCRA = _BV(SRW00) |_BV(SRW01) |_BV(SRW11); Rejestry wy świetlacza dost ępne s ą pod adresami: - rejestr steruj ący IR - 0x1F90 (COMM_LCD) - rejestr danych DR - 0x1F91 (DATA_LCD) */ #define EXT_MEM8(mem_addr) (* (volatile uint8_t * )(mem_addr)) #define COMM_LCD EXT_MEM8(0x1F90 ) #define DATA_LCD EXT_MEM8(0x1F91 ) // Bit zaj ęto ści wy świetlacza #define BF 7 /* Sprawdzanie zaj ęto ści wy świetlacza Procedura czeka na wyzerowanie flagi BF */ void test_bf (void ); /* Wysłanie bajtu do IR Wysłanie rozkazu lub adresu */ void pisz_com (uint8_t _cmd ); /* Wysłanie bajtu do DR W zale Ŝności od adresu bajt b ędzie wysłany do DD RAM lub CG RAM */ void pisz_ws (uint8_t _data ); /* Czytanie bajtu z DR Wczytanie bajtu danych spod aktualnego adresu w DD RAM lub CG RAM */ uint8_t czyt_ws (void ); /* Czytanie bajtu z IR Wczytanie aktualnego adresu DD RAM lub CG RAM i flagi BF na najstarszym bicie */ uint8_t czyt_ad (void );

73

Plik źródłowy lcd.c: // Implementacja procedur obsługi wy świetlacza LCD #include <lcd.h> #ifndef _UTIL_DELAY_H_ # define F_CPU 6000000UL // Cz ęstotliwo ść zegara 6MHz # include <util\delay.h> #endif void test_bf (void ) { __asm__ __ volatile __ ( "1: lds __tmp_reg__, %0" "\n\t" " sbrc __tmp_reg__, %1" "\n\t" " rjmp 1b" "\n\t" : : "m" (COMM_LCD), "I" (BF) ); } void pisz_com (uint8_t _cmd ) { COMM_LCD = _cmd; test_bf (); } void pisz_ws (uint8_t _data ) { DATA_LCD = _data ; test_bf (); } uint8_t czyt_ws (void ) { volatile uint8_t _data ; _data = DATA_LCD ; test_bf (); return(_data ); } uint8_t czyt_ad (void ) { volatile uint8_t _data ; _data = COMM_LCD ; test_bf (); return(_data ); }

74

Moduł <one_wire.h>

Moduł dołączamy dyrektywą #include <one_wire.h>. Zawartość plik nagłówkowego one_wire.h: // Procedury obsługi układu iButton #ifndef _ONE_WIRE_H_ # define _ONE_WIRE_H_ "one_wire.h" #else # error "Attempt to include more than one <one_wire.h> fil e." #endif #ifndef _AVR_IO_H_ # include <avr/io.h> #endif /* Szyna sygnałowa: iB_LINE w porcie _IB_ Domy ślnie: linia 0 w porcie E*/ #ifndef _IB_ # define _IB_ E # define iB_tx DDRE # define iB_wy PORTE # define iB_rx PINE #else # define iB_tx DDR (_IB_ ) # define iB_wy PORT (_IB_ ) # define iB_rx PIN (_IB_ ) #endif #ifndef iB_LINE # define iB_LINE 0 #endif /* Nadanie bitu "0" lub "1" w linii We: bit.0 = nadawany bit */ void iB_send_bit (char _bit ); /* Odbiór bitu z linii Wy: return.0 = odebrany bit */ char iB_recv (void ); /* Rozkaz Reset 1-Wire Wy: 0x00 - jest pastylka 0x01 - brak pastylki 0xFF - zwarcie w linii */ char iB_reset (void );

75

Plik źródłowy one_wire.c: // Implementacja procedur obsługi iButton // Wymaga doł ączenia modułu <util\delay.h> #include <one_wire.h> #ifndef _UTIL_DELAY_H_ # define F_CPU 6000000UL // Cz ęstotliwo ść zegara 6MHz # include <util\delay.h> #endif #define TX_0 iB_tx |= _BV (iB_LINE ) // kierunek WY #define TX_1 iB_tx &=~_BV (iB_LINE ) // kierunek WE #define RX_n iB_rx & _BV (iB_LINE ) // czytanie void iB_send_bit (char _bit ) { if (_bit == 0 ) { TX_0 ; _delay_us (100); TX_1 ; _delay_us (15); } else { TX_0 ; _delay_us (5); TX_1 ; _delay_us (110); } } char iB_recv (void ) { volatile char _bit ; TX_0 ; _delay_us (1); TX_1 ; _delay_us (15); _bit = RX_n ; _delay_us (105); return(_bit ); } char iB_reset (void ) { volatile char _bit ; TX_0 ; _delay_ms (0.5 ); TX_1 ; _delay_us (66); _bit = RX_n ; _delay_ms (0.2 ); if (! (RX_n)) _bit = 0xFF ; // Zwarcie na linii _delay_ms (0.3 ); return(_bit ); }

76

Przykłady funkcji przydatnych przy realizacji programu /* Dodatkowe procedury obsługi wy świetlacza LCD, wymagaj ą doł ączenia modułu <lcd.h>. Rejestry wy świetlacza dost ępne s ą pod adresami: - rejestr steruj ący 0x1F90 (COMM_LCD) char *COMM_LCD = 0x1F90; - rejestr danych 0x1F91 (DATA_LCD) char *DATA_LCD = 0x1F91; */ #ifndef __PGMSPACE_H_ # include <avr/pgmspace.h> #endif // Zerowanie wy świetlacza void lcd_clear( void ); // Przesuni ęcie kursora void lcd_home( void ); // Inicjalizacja wy świetlacza 5x7, 2 wiersze void init_lcd( void ); // Przepisanie tekstu (koniec = 0xFF) z pami ęci programu na wy świetlacz // Funkcja dopuszcza wykorzystanie znaku o kodzie 0 x00 // _adres - adres tekstu w pam. FLASH void disp_txt_P( const char * _adres); // Przepisanie tekstu (koniec = 0x00) z pami ęci danych na wy świetlacz // _adres - adres tekstu w pam. RAM void disp_txt_D( char * _adres); //Implementacja void lcd_clear( void ) { pisz_com( 0x01 ); } void lcd_home(void) { pisz_com( 0x02 ); } void init_lcd( void ) { _delay_ms( 15); COMM_LCD = 0x30 ; _delay_ms( 5); COMM_LCD = 0x30 ; _delay_ms( 0.2 ); COMM_LCD = 0x30 ; _delay_ms( 30); COMM_LCD = 0x38 ; //Słowo danych 8-bitów, dwa wiersze, znak 7x5

//pikseli

77

test_bf(); pisz_com( 0x0C); //Wł ączenie wy świetlacza, bez kursora, bez

//migotania lcd_clear(); pisz_com( 0x06 ); //Wpisywanie znaków od lewej, autoinkrementacja lcd_home(); } void disp_txt_P( const char * _adres) { volatile uint8_t al; for ( int i = 0; i< 16; i++) { al = pgm_read_byte(&_adres[i]); if (al == 0xFF) break; pisz_ws(al); } } void disp_txt_D( char * _adres) { volatile uint8_t al; for ( int i = 0; i< 16; i++) { al = _adres[i]; if (al == 0x00 ) break; pisz_ws(al); } } /* Procedury obsługi iButton w protokole 1-Wire Wymagaj ą doł ączenia modułu <one_wire.h> */ // Wysłanie rozkazu w linii 1-Wire void iB_send_cmd( char cmd); // Inicjacja 1-Wire // Diody zgaszone // Linia w stanie wysokim (WE) void iB_init( void ); // Rozkaz 33H (Read Rom) // Odebrane dane w tablicy Tab // Wy: CRC8 (0 - OK) char iB_33h( char * Tab); // Obsługa LED-ów #define iB_RED 1 #define iB_GREEN 2 void iB_zapal( char led); void iB_zgas( char led);

78

// Implementacja #ifndef _UTIL_CRC16_H_ # include <util\crc16.h> #endif void iB_send_cmd( char cmd) { for ( int i = 0; i < 8; i++) { iB_send_bit(cmd & 0x01 ); cmd >>= 1; } } void iB_init( void ) { // Diody: kier. WY iB_tx |=_BV(iB_RED) |_BV(iB_GREEN); // Linia 1-Wire: kier. WE (stan HIGH) iB_tx &=~_BV(iB_LINE); // Gasi diody iB_zgas(iB_RED); iB_zgas(iB_GREEN); // Linia 1-Wire: przygotowanie stanu LOW dla nadaw ania iB_wy &=~_BV(iB_LINE); } // READ ROM char iB_33h( char * Tab) { volatile char al; iB_send_cmd( 0x33 ); char crc = 0; for ( int i = 7; i > -1 ; i--) // 8 bajtów, od LSB { al = 0; for ( int k = 0; k < 8; k++) // 8 bitów, od najmłodszego { al >>= 1; al |= iB_recv() << 7; // Bit na pozycji 7 } crc = _crc_ibutton_update(crc, al); Tab[i] = al; } return(crc); } void iB_zgas( char led) { iB_wy &=~_BV(led); } void iB_zapal( char led) { iB_wy |=_BV(led); }

79

Przykładowy program Przykładowy program, używający układu czasowego TIMER0 dla uzyskania przerwań co 10 ms. W programie zdefiniowano funkcję opóźnienia wait_xx, wykonującą opóźnienie o zadaną ilość przerwań. Dla porównania w programie została również użyta funkcja biblioteczna _delay_ms z modułu delay.h. Program wywołuje cykliczne zapalanie i gaszenie co 0.5 s diody LED4, dołączonej do linii 4 portu B. Jeśli przy starcie programu naciśnięte będą przyciski SW0..SW7, to zapalone na stałe zostaną odpowiadające im diody LED0..LED7. Główna funkcja programu (main) musi zawierać nieskończoną pętlę. Uwaga: instrukcja return w funkcji main nie jest konieczna (kompilator nie wykaże jej braku jako błędu). Po założeniu nowego projektu o nazwie ProjC wprowadzamy do pliku źródłowego test.c poniższy program: // Program test.c // Definicje // Cz ęstotliwo ść zegara 6MHz, potrzebna dla modułu delay.h #define F_CPU 6000000UL // Parametry dla inicjalizacji układu czasowego TI MER0 #define TIMER0_INIT _BV (WGM01)|_BV (CS02)|_BV (CS01) /* CS02 CS01 CS00 = 110 - dzielenie przez 256 WGM01 WGM00 = 10 - tryb CTC Okres zegara TIMER0 = (1 / 6MHz ) * 256 = 0.0427 ms Licznik TIMERa liczy od 0 do warto ści OCR0 Gdy osi ągnie warto ść OCR0 jest kasowany na 00 Dzieli cz ęstotliwo ść zegara przez liczb ę N wpisan ą do OCR0 */ #define TIMER0_N 234 /* Dla N = 234 licznik TIMER0 b ędzie liczył od 0 do 233 Okres przerwa ń zegarowych = 0.0427 * 234 = 9.984 ms */ // Moduły doł ączane #include <avr/interrupt.h> #include <util/delay.h> // Deklaracje zmiennych globalnych volatile uint8_t timel ; /* typ uint8_t jest definiowany w stdint.h volatile jest konieczne ze wzgl ędu na sprawdzanie zmiennej timel poza procedur ą obsługi przerwania */ // Deklaracje funkcji void wait_xx (uint8_t _delta ); // Deklaracja funkcji wait_xx // Definicje funkcji // Obsługa przerwania porównania w TIMER0 ISR (TIMER0_COMP_vect) { timel++ ; // inkrementuj licznik 'timel' co 10 ms } // Procedura opó źnienia o delta * 10 ms // Maksymalne opó źnienie 2.55 s void wait_xx (uint8_t _delta ) { _delta += timel ; while (_delta != timel ); }

80

int main (void ) // Główna funkcja programu { // Inicjalizacja // Definicje portów WE/WY DDRD = 0x00 ; // Wszystkie linie portu D b ędą wej ściami PORTD = 0xFF ; // Linie portu D podci ągni ęte do 5V DDRB = 0xFF ; // Wszystkie linie portu B b ędą wyj ściami PORTB = PIND ; // Zapalenie wybranych diod // Inicjalizacja TIMER0 TCCR0 = TIMER0_INIT ; TCNT0 = 0 ; OCR0 = TIMER0_N ; /* Rejestr maski przerwa ń TIMER0 zezwolenie na przerwanie porównania dla TIMER0 */ TIMSK |= _BV (OCIE0); sei (); // Globalna flaga zezwolenia na przerwania // P ętla niesko ńczona programu while(1) { PORTB ^=_BV (PB4); // Przeł ącza stan bitu 4 wait_xx (50); // Opó źnienie sprz ętowe PORTB ^=_BV (PB4); // Przeł ącza stan bitu 4 _delay_ms (500); // Opó źnienie programowe } return (0); // Ta instrukcja nie jest konieczna }

W programie użyte zostało makro _BV(bit), generujące bajt, w którym na pozycji bit

występuje jedynka, a na pozostałych są zera. Makra tego można użyć np. dla zastąpienia rozkazów: sbi port, bit -> port |=_BV (bit); cbi port, bit -> port &=~(_BV(bit)); Po skompilowaniu i uruchomieniu programu, w folderze projektu, w podfolderze default zostają umieszczone pliki wygenerowane w procesie kompilacji:

• Makefile – konfiguracja uruchomienia programów narzędziowych

• test.o – wynik pracy preprocesora, kompilatora i assemblera

• ProjC.hex – wynikowy plik z kodem maszynowym programu

• ProjC.elf – plik obiektowy po dodaniu funkcji bibliotecznych,

• ProjC.map – mapa wykorzystania pamięci

• ProjC.lss – tekstowy zapis postaci maszynowej programu. W podfolderze default\dep umieszczony został plik test.o.d, zawierający informację które moduły zostały dołączone w trakcie kompilacji (na liście podkreślone zostały moduły dołączone jawnie w programie): interrupt.h, io.h, sfr_defs.h, inttypes.h, stdint.h, iom128.h, portpins.h, common.h, version.h, fuse.h, lock.h, delay.h, delay_basic.h.

81

Dodatek H. Tworzenie projektu, kompilacja oraz uruchamianie programów w środowisku AVR Studio

Nowy projekt • Uruchamiamy program AVR Studio

• Z okna głównego po lewej stronie wybrać New Project … (lub z menu Plik wybrać

New a następnie Project)

• Jako bieżący szablon wybrać C Executable Project z zakładki AVR GCC

• Nadać nazwę projektowi oraz wskazać jego lokalizację da dysku

82

• Po zatwierdzeniu wyboru w kolejnym oknie wybrać mikrokontroler ATmega128

• Po zatwierdzeniu wyboru można przystąpić so pisania kodu programu

Kompilacja, programowanie i uruchamianie projektu • Kompilacja projektu wykonywana jest poprzez wciśnięcie Kompiluj… na pasku

narzędzi

• W okienku dane wyjściowe można sprawdzić wynik kompilacji, natomiast w

przypadku kompilacji zakończonej niepowodzeniem w zakładce lista błędów pojawią się komunikaty o błędach

• Upewnić się, że zasilanie w układzie jest włączone i prawidłowo został podłączony programator

• Programowanie układu może odbywać się na dwa sposoby: o Z możliwością debugowania programu

Z menu Debuguj wybrać Start Debugging and Break

83

Wskazać właściwe narzędzie (JTAGICE mkII) w przypadku pierwszego programowania

84

Wykonywanie programu po wgraniu do układu jest zatrzymane w oczekiwaniu na decyzje programisty. Przyciski do debugowania programu znajdują się na pasku narzędzi.

o Bez możliwości debugowania programu Z menu Debuguj należy wybrać Start Without Debugging

Wskazać właściwe narzędzie (JTAGICE mkII) w przypadku pierwszego programowania

Program wystartuje automatycznie po zaprogramowaniu układu

85

Dodatek I. Układy czasowe 8-bitowe (Timer0)

Opis układu Uproszczony schemat blokowy zespołu 8-bitowego timera przedstawiono na rysunku poniżej.

Źródłem sygnału taktującego może być zegar systemowy (clkI/O – praca synchroniczna) lub zegar zewnętrzny (kwarc między TOSC1 i TOSC2 – praca asynchroniczna). Sygnał ten, za pośrednictwem 10-bitowego preskalera podawany jest na wejście dwukierunkowego licznika 8-bitowego, którego stan jest kontrolowany za pomocą rejestru TCNT0 (0x32). Stan rejestru TCNT0 może być na bieżąco porównywany ze stanem rejestru OCR0 (0x31). Komparator może generować przerwanie i ustawiać flagę OCF0 oraz sterować pracą układu wytwarzania sygnału wyjściowego na nóżce OC0 (PB4) procesora. Flagi przerwań genero-wanych przez układ: OCF0 i TOV0 umieszczone są w rejestrze TIFR (0x36), natomiast maski przerwań: OCIE0 i TOIE0 występują w rejestrze TIMSK (0x37). Tryby pracy timera sterowane są za pomocą bitów w rejestrze TCCR0 (0x33) i ewentualnie

ASSR (0x30).

86

Tryby pracy układu

Tryb podstawowy (Normal Mode) W tym trybie pracy zawartość licznika TCNT0 jest z każdym taktem zwiększana o 1 (od 0x00 do wartości 0xFF), po przepełnieniu ustawiana jest flaga TOV0 i licznik zlicza dalej od zera. Flaga TOV0 zachowuje się więc jak dziewiąty bit licznika (z tą różnicą, że nie jest kasowana sprzętowo). W procedurze obsługi przerwania (adres 0x20) flaga TOV0 jest kasowana automatycznie i jest możliwość wprowadzenia bieżących zmian w ustawieniach timera. Układ komparatora wyjściowego może być wykorzystany do generowania przerwań w wybranych momentach (generowanie przebiegu na wyjściu w trybie normalnym nie jest zalecane). Tryb CTC (Clear Timer on Compare – CTC Mode) W tym trybie pracy rejestr OCR0 ustala wartość maksymalną zliczania. Stan licznika jest zwiększany o jeden w każdym takcie, a po osiągnięciu wartości równej OCR0 licznik jest zerowany. Przykładowy przebieg czasowy pracy w trybie CTC przedstawiono na rysunku poniżej.

W każdym cyklu stan rejestru OCR0 może być zmieniony, co daje możliwość generowania impulsów o różnej długości. Po zaprogramowaniu generatora przebiegu wyjściowego na zmianę stanu wyjścia OC0 przy każdym zrównaniu, uzyskamy przebieg o częstotliwości:

2 (1 )clk_I / O

OC0

ff

N OCR0=

× × +

Zmienna N we wzorze oznacza współczynnik podziału częstotliwości w układzie preskalera (1, 8, 32, 64, 128, 256 lub 1024). Po zrównaniu licznika z rejestrem OCR0 ustawiana jest flaga OCF0 i może być generowane przerwanie, którego obsługa umożliwi np. modyfikację zawartości rejestru OCR0. Tak jak w trybie podstawowym, flaga TOV0 jest ustawiana po ewentualnym osiągnięciu przez licznik stanu 0xFF. Zdarzenie wymuszenia zmiany stanu na wyjściu OC0 można wywołać w dowolnym momencie, bez przerwania, wysyłając sygnał stanu wysokiego na bit FOC0 w rejestrze TCCR0.

87

Tryb modulacji szerokości impulsów (Fast PWM Mode) Praca licznika jest jednokierunkowa. W tym trybie licznik zlicza od wartości minimalnej (0x00) w górę, do wartości maksymalnej (0xFF), po czym znów rozpoczyna zliczanie od wartości minimalnej. Przykładowy przebieg czasowy przedstawiono na rysunku poniżej.

Zaprogramowanie generatora przebiegu wyjściowego w tryb nieodwracający powoduje wysyłanie na wyjście stanu niskiego po wykryciu zrównania z rejestrem OCR0, a stanu wysokiego po osiągnięciu wartości minimalnej. Częstotliwość przebiegu wyjściowego może być określona na podstawie zależności:

256clk_I / O

OC0

ff

N=

×

gdzie N oznacza współczynnik podziału częstotliwości w układzie preskalera. Ustawienie w OCR0 wartości minimalnej spowoduje generowanie na wyjściu wąskich szpilek w momentach osiągnięcia stanu maksymalnego, natomiast w przypadku ustawienia wartości maksymalnej, na wyjściu utrzymywany będzie cały czas stan wysoki (bądź niski – w trybie odwracającym). Flaga TOV0 jest ustawiana każdorazowo, po osiągnięciu przez licznik wartości maksymalnej.

88

Tryb PWM z korekcją fazy (Phase Correct PWM Mode) Praca licznika jest dwukierunkowa. W tym trybie licznik zlicza od wartości minimalnej (0x00) w górę, do wartości maksymalnej (0xFF), po czym przełączany jest kierunek i następuje zliczanie w dół, do wartości minimalnej. Proces ten powtarza się okresowo. Przykładowy przebieg czasowy przedstawiono na rysunku poniżej.

Flaga TOV0 jest ustawiana każdorazowo, po osiągnięciu przez licznik wartości minimalnej, natomiast flaga OCF0 – po zrównaniu z rejestrem OCR0. Poziome kreski zaznaczone na przebiegu wartości TCNT0 oznaczają momenty, w których stan licznika zrównał się z zawartością rejestru OCR0. Przy zaprogramowaniu generatora przebiegu wyjściowego w tryb nieodwracający, po wykryciu zrównania z rejestrem OCR0 podczas zliczania w górę na wyjście OC0 wysyłany jest stan niski, a podczas zliczania w dół - stan wysoki. Częstotliwość generowanego przebiegu PWM określona jest wzorem

510clk_I / O

OC0

ff

N=

×

gdzie N oznacza współczynnik podziału częstotliwości w układzie preskalera.

89

Rejestry związane z pracą układu TIMER0

Rejestr TCCR0

Ustawianie trybu pracy timera Tryb pracy timera WGM01 WGM00

Normal 0 0

PWM, Phase Correct 0 1

CTC 1 0

Fast PWM 1 1

Programowanie wyjścia w trybie Normal lub CTC Tryb wyjścia COM01 COM00

Wyłączone 0 0

Przełączanie przy zrównaniu 0 1

Zerowanie przy zrównaniu 1 0

Ustawianie przy zrównaniu 1 1

Programowanie wyjścia w trybie Fast PWM Tryb wyjścia COM01 COM00

Wyłączone 0 0

- 0 1

Zerowanie przy zrównaniu, ustawianie przy maksimum 1 0

Ustawianie przy zrównaniu, zerowanie przy maksimum 1 1

90

Programowanie wyjścia w trybie Phase Correct PWM Tryb wyjścia COM01 COM00

Wyłączone 0 0

- 0 1

Zerowanie przy zrównaniu podczas zliczania w górę,

ustawianie przy zrównaniu podczas zliczania w dół 1 0

Ustawianie przy zrównaniu podczas zliczania w górę,

zerowanie przy zrównaniu podczas zliczania w dół 1 1

Wybór dzielnika sygnału zegarowego Tryb wyjścia CS02 CS01 CS00

Timer zatrzymany 0 0 0

Bez preskalera (N=1) 0 0 1

N=8 0 1 0

N=32 0 1 1

N=64 1 0 0

N=128 1 0 1

N=256 1 1 0

N=1024 1 1 1

Rejestr TCNT0 Rejestr licznika timera.

Rejestr OCR0 Rejestr komparatora.

TCNT0(7:0)

7 6 5 4 3 2 1 0

R/W R/W R/W R/W R/W R/W R/W R/W

0 0 0 0 0 0 0 0Wartość

początkowa

Nr bitu

91

Rejestr ASSR Rejestr trybu asynchronicznego.

Gdy bit AS0 ma wartość 0, do sterowania timerem wykorzystywany jest sygnał zegara systemowego. W przeciwnym przypadku wykorzystywany jest sygnał z generatora kwarcowego, którego rezonator włączony jest między nóżkami TOSC1 (PG4) i TOSC2 (PG3) procesora. Rejestr TIMSK Rejestr masek przerwań.

Maska OCIE0 związana jest z przerwaniem komparatora (adres 0x001E), natomiast maska TOIE0 służy do sterowania przerwaniem przepełnienia licznika (adres 0x0020). Rejestr TIFR Rejestr flag przerwań.

TOV0 jest flagą przepełnienia licznika, natomiast OCF0 jest flagą przerwania komparatora. Flagi ustawiane są sprzętowo. Kasowanie flagi odbywa się w procedurze obsługi przerwania, lub przez wysłanie stanu wysokiego na odpowiedni bit rejestru.

- - - - AS0 TCN0UB OCR0UB TCR0UB

7 6 5 4 3 2 1 0

R R R R R/W R R R

0 0 0 0 0 0 0 0Wartość

początkowa

Nr bitu

OCF2 TOV2 ICF1 OCF1A OCF1B TOV1 OCF0 TOV0

7 6 5 4 3 2 1 0

R/W R/W R/W R/W R/W R/W R/W R/W

0 0 0 0 0 0 0 0Wartość

początkowa

Nr bitu

92

Dodatek J. Wyświetlacz LCD

Przeznaczenie i ogólna charakterystyka Wyświetlacz ciekłokrystaliczny HY-1602F4 zastosowany w ćwiczeniu jest wyświetlaczem matrycowym zawierającym moduł kontrolera i układ wykonawczy wykonany w technologii LSI (HD44780), pozwalający wyświetlać znaki alfanumeryczne i symbole graficzne. Wyświetlacz może współpracować z mikrokomputerem jednoukładowym lub mikroprocesorem z szyną danych cztero- lub ośmiobitową. Wyświetlacz wyposażony jest również w wewnętrzną pamięć RAM (80 bajtów) i ROM (która zawiera matryce 5×7 punktów lub 5×10 punktów dekodowanych znaków).

Schemat blokowy oraz opis sygnałów wejściowych i wyjściowych Rys. A.1 przedstawia schemat blokowy wyświetlacza LCD. Jego zasadniczymi blokami funkcjonalnymi są:

Bufor WE/WY

DB0..DB3 DB4..DB7 E RS R/W

Flaga zajętości (BF)

Rejestr danych (DR)

Rejestr instrukcji (IR)

ROM generatora znaków

(CG ROM)

RAM generatora znaków

(CG RAM) RAM danych

(DD RAM)

Układ sterowania kursorem

Układ konwersji danychrównoległe szeregowe

40 bitowy rejestr przesuwny

40 bitowy rejestr zatrzaskowy

Sterowanie segmentami

Sterowanie sygnałami wspólnymi

16 bitowy rejestr przesuwny

Dekoder instrukcji

Licznik adresów (AC)

Sterowanie wyświetlaczem

LCD

CL1

CL2

M

COM1..COM6SEG1..SEG6D

93

Tabela poniżej przedstawia opis sygnałów wejściowych i wyjściowych.

Nr styku Nazwa Poziom Opis Sygnału

1 VSS - Masa

2 VDD - +5V

3 V0 - Ustawianie kontrastu

4 RS 0/1 0-kod instrukcji

1-dana

5 R/W 0/1 0-wpis danej

1-czytanie danej

6 E 1→0 impuls zapisu/odczytu

7 DB0 0/1

Linie danych

8 DB1 0/1

9 DB2 0/1

10 DB3 0/1

11 DB4 0/1

12 DB5 0/1

13 DB6 0/1

14 DB7 0/1

15 VLED - Podświetlenie

16 NC - -

Rejestr instrukcji IR: rejestr ośmiobitowy przechowujący instrukcje sterujące, informację o adresach wewnętrznej pamięci danych RAM (DD RAM) oraz pamięci RAM generatora znaków (CG RAM). Uwaga: do rejestru IR można jedynie zapisać informację. Rejestr danych DR: rejestr ośmiobitowy chwilowo przechowujący dane zapisywane lub odczytywane do/z DD RAM lub CG RAM. Dane wpisywane do rejestru DR są automatycznie przepisywane do pamięci danych DD RAM lub pamięci znaków CG RAM przez operację wewnętrzną. Rejestr DR jest także wykorzystywany do przechowywania danej podczas operacji czytania danych z pamięci DD RAM lub CG RAM. Po zapisaniu adresu do rejestru IR

94

dana jest przepisywana do rejestru DR z pamięci DD lub CG przez operację wewnętrzną. Po odczycie przez MPU danej z rejestru DR, do rejestru DR przesyłana jest dana z komórki pamięci DD lub CG o adresie zwiększonym o 1. Przy pomocy sygnału RS dokonywany jest wybór między rejestrem IR i DR. Flaga zajętości (BF): kiedy przyjmuje ona wartość "1", wyświetlacz znajduje się w trybie wykonywania operacji wewnętrznej i następna instrukcja nie będzie zaakceptowana. Jak pokazuje tabela poniżej, flaga zajętości jest wystawiana jako bit DB7 (dla RS = "0", R/W = "1").

Następna instrukcja może być wpisana po stwierdzeniu, że BF = "0". Na rysunku poniżej przedstawiono przebiegi czasowe sygnałów sterujących i odpowiedzią układów wyświetlacza dla przypadku zapisu instrukcji (przypadek dla szyny 8 bitowej).

B - trwa operacja wewnętrzna NB - zezwolenie na wpis następnej instrukcji DBi - wpisywane odczytywane dane R, R/W, E - sygnały sterujące wyświetlaczem

Pamięć wyświetlanych danych (DD RAM): Pamięć wyświetlanych danych przechowuje dane w postaci 8-mio bitowych kodów. Jej pojemność wynosi 80×8 bitów (80 znaków). Ta część pamięci, która nie jest wykorzystywana do wyświetlania może być użyta jako RAM ogólnego przeznaczenia. Zależność między adresami DD RAM i położeniem znaku na wyświetlaczu LCD pokazana jest poniżej. Adres DD RAM (ADD) jest wytwarzany w liczniku adresów (AC) i ma postać binarną. Pamięć znaków ROM (CG ROM): generator ten wytwarza wzory 5×7 lub 5×10 pikseli odpowiadające wyświetlanym 8-mio bitowym danym. Wzory znaków dla obydwu typów reprezentacji podano w tabelach przedstawiających zestawy znaków. Pamięć znaków RAM (CG RAM): pamięć ta pozwala na zdefiniowanie własnego zestawu znaków, poprzez wpisanie odpowiednich wzorów 5×7 lub 5×10 pikseli.

95

Blok sterowania wyświetlaczem LCD: blok ten zawiera 16 wzmacniaczy sterujących liniami wspólnymi i 40 wzmacniaczy sterujących segmentami. Po wybraniu przez program generatora znaków i liczby linii znakowych następuje automatyczna selekcja wzmacniaczy sterujących liniami wspólnymi. Matryce znaków są przesyłane szeregowo przez rejestr 40- bitowy i zatrzaskiwane po przesłaniu wszystkich znaków. Zatrzaśnięte dane sterują wzmacniaczem wyjściowym wytwarzającym odpowiedni kształt sygnału. Blok sterowania kursorem: blok ten wytwarza kursor lub powoduje jego migotanie. Kursor pojawia się na pozycji wyznaczonej stanem licznika adresów DD RAM. Poniżej pokazano przykładowe położenie kursora dla stanu licznika 7 heksadecymalnie: (AC7 = 1, AC6 = nr wiersza, AC5..AC0 = położenie znaku – 1)

W wyświetlaczu zastosowanym w Laboratorium dostępne są dwa wiersze po 16 znaków. Sterownik wyświetlacza zajmuje dwa słowa w pamięci RAM: 0x1F90 COMM_LCD Przy zapisie - adres rejestru instrukcji (IR), przy odczycie

zwraca bajt, zawierający bit flagi zajętości (BF – bit 7) oraz siedmiobitowy adres pozycji znaku (bity 6..0)

0x1F91 DATA_LCD Adres rejestru danych (DR)

Programowanie układu wyświetlacza LCD

Inicjalizacja wyświetlacza

Układ wyświetlacza jest automatycznie zerowany po włączeniu zasilania. Poniżej przedstawiono proces inicjalizacji wyświetlacza:

1) Zerowanie wyświetlacza po włączeniu zasilania (flaga zajętości jest ustawiana w stan BF=‘1’ i może być testowana dopiero po wysłaniu pierwszego słowa operacyjnego).

96

Wpisywanie sekwencji instrukcji wg powyższego schematu jest konieczne w przypadku szybkiego wysyłania instrukcji programujących (np. w momencie inicjalizacji systemu mikroprocesorowego).

2) Wysłanie słowa operacyjnego, ustawiającego parametry wyświetlacza

Uwaga: 1. W przypadku pracy w trybie wyświetlania dwóch linii znakowych,

matryca znaków może składać się tylko z 5×7 punktów. 2. Przed wysłaniem każdego kolejnego słowa (danej lub instrukcji) należy

sprawdzać flagę gotowości BF.

97

3) Wyświetlacz „włączony / wyłączony”

4) Zerowanie wyświetlacza

5) Ustawienie trybu pracy wyświetlacza

Wysłanie tej instrukcji kończy proces inicjalizacji wyświetlacza i umożliwia wpisywanie wyświetlanych znaków.

Zestaw instrukcji sterujących

MPU ma bezpośredni dostęp do Rejestru Instrukcji (IR) oraz Rejestru Danych (DR). Wewnętrzne operacje w wyświetlaczu LCD określane są sygnałami generowanymi przez MPU:

- sygnał wyboru rejestrów RS - sygnał czytaj/pisz R/W - sygnały szyny danych DB7 - DB6

98

Sygnały wysyłane do rejestru IR tworzą zestaw instrukcji który został podany w tabeli A.3. Podano tam znaczenie poszczególnych bitów:

Uwaga: 1. Zmiana trybu w trakcie pracy nie powoduje zmiany zawartości DDRAM i CGRAM.

2. Zmiana liczby wierszy wyświetlanych znaków musi być przeprowadzona poprzez

realizację procedury inicjalizacji wyświetlacza.

99

Definiowanie znaku (dla matrycy 5×7) w tablicy CG RAM

Wyświetlacz LCD umożliwia zdefiniowanie do 8 własnych wzorów znaków dla matrycy 5×7 pikseli i do 4 znaków dla matrycy 5×10 pikseli. Adresy początków definicji znaków dla matrycy 5×7 są wielokrotnością ośmiu (np. 00H, 08H, 10H, ...), a dla matrycy 5×10 są wielokrotnością szesnastu (np. 00H, 10H, 20H...). Wpisywanie informacji może nastąpić w dowolnym momencie po wykonaniu procedury inicjalizacji wyświetlacza. Po zakończeniu definiowania własnych znaków należy wykonać operację ustawienia adresu DD RAM. Poniżej przedstawiono przykładowy ciąg poleceń dla zdefiniowania znaku litery 'ą' w formacie 5×7 pikseli, jako znaku o kodzie 1 (adres 8 w pamięci CG RAM)..

1) Wpisanie adresu CG RAM (D7 = 0, D6 = 1, D5..D0 = adres) do rejestru IR wyświetlacza

2) Wpisanie kolejno danych definiujących symbol do rejestru DR wyświetlacza

Uwaga: Wpisanie danej do CG RAM inkrementuje licznik adresów. Od tej pory zdefiniowany znak 'ą' jest dostępny jako znak o kodzie 01H i umieszczenie go na wyświetlaczu wymaga wykonania kolejnych czynności:

3) Wpisanie adresu DD RAM (pozycji na wyświetlaczu) do rejestru IR. 4) Wysłanie kodu 01H do rejestru DR wyświetlacza.

Tablica znaków CG ROM

W tabeli A.4. przedstawiono zestaw znaków generatora znaków, zawarty w pamięci CG ROM.

100

W tabeli A.4. przedstawiono zestaw znaków generatora znaków, zawarty w pamięci CG W tabeli A.4. przedstawiono zestaw znaków generatora znaków, zawarty w pamięci CG

101

Dodatek K. Przetwornik analogowo cyfrowy

Schemat blokowy Uproszczony schemat blokowy konwertera analogowo-cyfrowego przedstawiony został na rysunku poniżej.

Przetwornik posiada rozdzielczość 10 bitów, przy całkowitej dokładności ±2 LSB.

102

Opis działania

Przetwornik realizuje 10-bitową konwersję sygnału wejściowego, pochodzącego z wyjścia 8-kanałowego multipleksera podłączonego do Portu F mikrokontrolera. Sygnał wejściowy może być niesymetryczny (podawany bezpośrednio z linii portu F) lub różnicowy, wykorzystujący jedną z 16 kombinacji par linii portu F. Dla dwu takich kombinacji (ADC1/ADC0 i ADC3/ADC2) możliwe jest zastosowanie dodatkowego wzmacniacza wejściowego o regulowanym wzmocnieniu 0 dB, 20 dB lub 46 dB. W przetworniku zastosowano układ próbkująco-pamiętający, który zapewnia niezmienność sygnału podczas przetwarzania. Przetwornik może wykorzystywać zewnętrzne napięcie odniesienia (równe napięciu zasilania) lub wewnętrzne: 2,56 V. Dla sygnału niesymetrycznego minimalna wartość napięcia wejściowego wynosi 0 V, a maksymalna jest równa napięciu odniesienia pomniejszonemu o wartość LSB. Linie wejściowe wybierane są za pomocą odpowiednich bitów w rejestrze ADMUX. Aktywacja układu przetwornika obywa się przez ustawienie bitu ADEN w rejestrze ADCSRA w stan wysoki. 10-bitowy wynik przetwarzania pojawia się w 16-bitowym rejestrze ADC, dostępnym jako 8-bitowe rejestry ADCL (odczytywany jako pierwszy!) i ADCH. W zależności od ustawienia bitu ADLAR w rejestrze ADMUX, wynik może być przesunięty w lewo (ADLAR = 1) lub w prawo (ustawienie domyślne). Jeżeli wynik jest przesunięty w lewo i interesuje nas jedynie jego 8 starszych bitów, wystarczy odczytywać rejestr ADCH. Proces przetwarzania może zostać uruchomiony przez ustawienie bitu ADSC w rejestrze ADCSRA (normalny tryb pracy), lub może być powtarzany automatycznie, po ustawieniu bitu ADFR w tym rejestrze. Zakończenie procesu przetwarzania sygnalizowane jest za pomocą ustawienia flagi ADIF (rejestr ADCSRA) i ewentualnie wywołania przerwania wewnętrznego (maskowanego bitem ADIE w rejestrze ADCSRA). Przy normalnym trybie pracy jednocześnie zerowany jest bit ADSC. Takt przetwarzania (dzielnik sygnału zegara systemowego sterowany jest bitami ADPS0 .. ADPS2 rejestru ADCSRA) powinien być w granicach 50 .. 200 kHz. Pierwsze przetwarzanie wymaga 25 cykli, natomiast kolejne wymagają jedynie 13 cykli sygnału taktującego. Sygnał wejściowy jest zatrzaskiwany po 1,5 cyklu (przy pierwszym przetwarzaniu po 13,5 cyklu). Przebiegi występujące w procesie przetwarzania przedstawiono na rysunkach poniżej.

103

Wynik przetwarzania dla wejścia niesymetrycznego można określić na podstawie wzoru: 1024IN

REF

VADC

V

×=

gdzie VIN jest napięciem na wybranym wejściu, a VREF jest napięciem odniesienia. Wynik jest liczbą całkowitą dodatnią, w zakresie 0x000 (0) do 0x3FF (1023).

W przypadku, gdy napięcie wejściowe podawane jest różnicowo między parę końcówek, wynik przetwarzania określony jest wzorem:

( ) 512POS NEG

REF

V V GAINADC

V

− × ⋅=

gdzie VPOS i VNEG są napięciami na końcówkach wejściowych, a GAIN jest wybranym współczynnikiem wzmocnienia. Wynik jest liczbą zapisaną w postaci uzupełnionej do 2, w zakresie od 0x200 (-512) do 0x1FF (511).

Rejestry Rejestr multipleksera ADMUX

Wybór źródła napięcia odniesienia:

REFS1 REFS0 Źródło napięcia

0 0 AREF, źródło wewnętrzne wyłączone

0 1 AVCC, na AREF kondensator odsprzęgający

1 0 -

1 1 Wewnętrzne 2,56 V, na AREF kondensator odsprzęgający

104

Wybór źródła sygnału wejściowego:

MUX4..0 VIN VPOS VNEG GAIN

00000 ADC0

00001 ADC1

00010 ADC2

00011 ADC3

00100 ADC4

00101 ADC5

00110 ADC6

00111 ADC7

01000 ADC0 ADC0 20 dB

01001 ADC1 ADC0 20 dB

01010 ADC0 ADC0 46 dB

01011 ADC1 ADC0 46 dB

01100 ADC2 ADC2 20 dB

01101 ADC3 ADC2 20 dB

01110 ADC2 ADC2 46 dB

01111 ADC3 ADC2 46 dB

10000 ADC0 ADC1 0 dB














11110 1,23 V (VBG)

11111 0 V (GND)

105

Rejestr sterowania i statusu ADCSRA

Wybór dzielnika preskalera: Znaczenie pozostałych bitów rejestru ADCSRA:

ADPS2 ADPS1 ADPS0 Dzielnik

0 0 0 2 ADEN - włączenie układu przetwornika

0 0 1 2 ADSC - start przetwarzania

0 1 0 4 ADFR - praca ciągła przetwornika

0 1 1 8 ADIF - flaga zajętości przetwornika

1 0 0 16 ADIE - zezwolenie na przerwanie od

przetwornika

1 0 1 32

1 1 0 64

1 1 1 128

Rejestr danych ADCH i ADCL W zależności od bitu ADLAR z rejestru ADMUX, dane ADC9..ADC0 są przesunięte do początku lub końca rejestru:

Dostęp do 16-bitowego rejestru ADC jest 8-bitowy, za pośrednictwem rejestru pomocniczego. Zawartość rejestru ADC jest odświeżana po odczytaniu starszej części (ADCH), a zatem należy odczytać najpierw część młodszą (ADCL).

106

Dodatek L. Magistrala 1-Wire

Przeznaczenie i ogólna charakterystyka Ciągle rosnąca liczba układów peryferyjnych podłączanych do mikroprocesorów zmusza konstruktorów do opracowywania nowych interfejsów. Drugą przyczyną powstawania nowych rozwiązań są ograniczenia patentowe obowiązujące dla już istniejących. Jednym z takich przykładów jest magistrala 1-Wire opracowana przez firmę Dallas Semiconductors (obecnie Maxim-Dallas). Oryginalność tego rozwiązania polega na wykorzystaniu jedynie dwóch przewodów. Jeden z nich to dwukierunkowa linia transmisyjna, drugi zaś to przewód odniesienia (masa). Większość układów peryferyjnych opracowanych również przez firmę Dallas zwanych układami iButton, nie wymaga zasilania, czerpiąc całą energię z transmitowanych sygnałów. Przykładem takich układów mogą być „pastylki identyfikujące” DS1992.

Zasadniczą częścią układu DS1992 jest pamięć ROM, w której na etapie produkcji zapisano niepowtarzalny, 48-bitowy numer seryjny. W drugiej części układ posiada zapisywalną pamięć typu NVRAM, umożliwiającą przechowywanie krótkich informacji. Pojemność tej pamięci wynosi 1024 bity i podzielona jest na strony po 256 bitów każda. Właściwości układów z serii DS199x sprawiają, że nadają się one np. do identyfikowania posiadacza. Oczywiście numer seryjny zapisany w ROM każdego układu jest jawny, co jest widoczne na fot. 1. i zmusza posiadacza do zabezpieczenia układu przed dostaniem się w niepowołane ręce.

Protokół komunikacyjny magistrali 1-Wire. Współpraca układów podłączonych do magistrali 1-Wire przebiega na zasadzie „master-

slave”, czyli jest zawsze jeden układ nadrzędny (master) i co najmniej jeden układ podrzędny (slave). Transmisja odbywa się poprzez odpowiednio określone szczeliny czasowe (slots). Wyróżnić można cztery rodzaje szczelin czasowych: inicjująca, zapisu bitu "1", zapisu bitu "0" oraz odczytu bitu.

107

Szczelina inicjująca Pierwszą z nich jest szczelina inicjująca. W pierwszej fazie tej szczeliny, zwanej impulsem zerującym, układ nadrzędny wystawia niski stan na linii transmisyjnej na czas nie krótszy niż 480µs. Następnie układ nadrzędny zwalnia linię poprzez ustawienie stanu wysokiego. Po upływie kolejnych 60µs układy podrzędne powinny zgłosić swoją obecność przez wystawienie stanu niskiego na linii. Stan ten powinien być utrzymywany przez co najmniej 15µs lecz nie więcej niż 240µs. Tę fazę nazywamy impulsem obecności i może ona trwać maksymalnie 480µs. Odpowiednie przebiegi czasowe przedstawia rysunek poniżej.

Szczelina zapisu „1” Ten typ szczeliny rozpoczyna się wystawieniem stanu niskiego na linię transmisyjną przez układ nadrzędny. Czas trwania tego stanu musi wynosić co najmniej 1µs lecz mniej niż 15µs. Następnie układ nadrzędny zwalnia linię dzięki czemu na linii pojawia się stan wysoki. Począwszy od piętnastej mikrosekundy do sześćdziesiątej mikrosekundy układy podrzędne mają czas na odczyt stanu linii (okno próbkowania - ang. sampling window). W tym czasie stan linii nie powinien się zmieniać. Odpowiednie przebiegi przedstawia rysunek poniżej.

108

Szczelina zapisu „0” Podczas trwania tego typu szczeliny układ nadrzędny wystawia stan niski na linii transmisyjnej i utrzymuje go przez co najmniej 60µs lecz krócej niż 120µs. Układy podrzędne mogą odczytywać stan linii między piętnastą a sześćdziesiąta mikrosekundą trwania szczeliny. Odpowiednie przebiegi przedstawia rysunek poniżej.

Szczelina odczytu Szczelina czasowa tego typu rozpoczyna się wystawieniem przez układ nadrzędny stanu niskiego na czas co najwyżej 1µs. Następnie układ nadrzędny zwalnia linię i przechodzi w stan odczytu. Okno próbkowania stanu linii przez układ nadrzędny trwa do piętnastej mikrosekundy trwania szczeliny. Układ podrzędny może utrzymywać stan linii nie dłużej niż przez 45µs od momentu zakończenia okna próbkowania. Odpowiednie przebiegi przedstawia rysunek poniżej.

Zapis lub odczyt danych po magistrali 1-Wire odbywa się przez złożenie odpowiednich szczelin czasowych. Przykładowo aby odczytać numer seryjny układu DS199x należy postępować zgodnie z następującym algorytmem:

• Układ nadrzędny wysyła szczelinę inicjującą.

109

• Jeżeli podczas szczeliny inicjującej układ podrzędny potwierdzi swoją obecność, to układ nadrzędny przystępuje do wysłania rozkazu np. „czytaj ROM” (33h).

• Następnie układ nadrzędny przechodzi do odczytywania danych z układu podrzędnego, który wystawia kolejno 64 bity (począwszy od najmniej znaczącego). Ich znaczenie obrazuje rysunek poniżej.

Rozkazy obsługi pamięci ROM Pierwszym etapem komunikacji systemu mikroprocesorowego (master) z układami iButton (slave) jest wysłanie sygnału RESET i sprawdzenie, czy jakieś układy iButton są podłączone do linii (wstawione do czytników). Jeżeli jakieś układy zasygnalizują swoją obecność, master wysyła jeden z czterech rozkazów obsługi ROM. Każdy rozkaz składa się z 8 bitów, wysyła-nych w linię kolejno, począwszy od najmłodszego. Układy DS1990 zawierają wyłącznie pamięć ROM, a zatem nie wykorzystują rozkazów 55h ani CCh. Czytaj ROM [33h] Po wysłaniu tego rozkazu master powinien wykonać operacje odczytu kolejnych 64 bitów (zawartość pamięci ROM układu iButton) wysyłanych przez slave'a kolejno, począwszy od najmłodszego. W układach DS199x będą to kolejno:

• 8 bitowy kod rodziny urządzeń

• unikalny 48 bitowy numer urządzenia

• 8 bitowe słowo sumy kontrolnej (CRC). Rozkazu tego można użyć wyłącznie w przypadku, gdy do linii dołączone jest tylko jedno urządzenie – w przeciwnym wypadku wszystkie urządzenia będą się zgłaszać jednocześnie, a na linii sygnałowej pojawi się iloczyn logiczny (wired-AND) stanów wyjściowych poszczególnych urządzeń. Taką sytuację można wykryć przez porównanie odebranej i wyliczonej sumy kontrolnej. Wybierz układ [55h] Po wysłaniu tego rozkazu, a następnie sekwencji 64 bitów zgodnej z zawartością pamięci ROM, mamy możliwość wyboru określonego urządzenia spośród kilku dołączonych jednocześnie do linii. Tylko to urządzenie, którego zawartość ROM jest zgodna z wysłaną sekwencją, będzie odpowiadać na następne rozkazy. Wszystkie pozostałe układy przechodzą w stan oczekiwania na sygnał RESET. Pomiń identyfikację [CCh] W przypadku pojedynczego urządzenia dołączonego do linii można użyć tego rozkazu zamiast sekwencji odbioru zawartości pamięci ROM (po rozkazie 33h) lub jej wysyłania (po rozkazie 55h).

110

Zidentyfikuj układy [F0h] Po uruchomieniu systemu master nie ma informacji ile urządzeń jest dołączonych do linii, ani jakie są ich kody identyfikacyjne. Rozkaz F0h umożliwia przeprowadzenie procesu identyfikacji wszystkich urządzeń dołączonych do linii. Proces ten polega na powtarzaniu przez master sekwencji trzech kolejnych kroków:

• wczytanie wartości bitu (wire-AND stanów wywołanych przez wszystkie dołączone i aktywne urządzenia),

• wczytanie wartości komplementarnej tego bitu,

• wysłanie odpowiedniej wartości bitu. Urządzenia, dla których bit ten nie jest zgodny z ich aktualnym bitem w pamięci ROM, przechodzą w stan WAIT. (czekania na RESET).

Master wykonuje tę sekwencję dla wszystkich 64 bitów kodu identyfikacyjnego, uzyskując w ten sposób kod jednego urządzenia. Następne przebiegi ( RESET + F0h) pozwalają na identyfikację kolejnych urządzeń przez odpowiedni dobór wysyłanych bitów.

Realizacja interfejsu 1-Wire z wykorzystaniem mikroprocesora ATMega128 Do zapewnienia poprawnej transmisji potrzebny jest jedynie jeden port dwukierunkowy z wyjściem „open drain”. Te wymagania spełnia większość portów procesora ATMega128. Sposób dołączenia układów iButton do portu mikroprocesora zostało przedstawione na rysunku poniżej.

Obsługa linii transmisyjnej jest troszeczkę nietypowa, co wynika ze specyfiki interfejsu. Wykorzystywana linia portu musi być skonfigurowana jako „wejście” bez wewnętrznego „podciągania”. Odpowiedni bit portu PORTx musi być ustawiony na stałe na zero (linia Tx na rys. B.5). Realizacja stanu wysokiego na linii transmisyjnej odbywa się poprzez ustawienie linii portu mikroprocesora jako wejście (odpowiedni bit rejestru DDRx ustawiony na zero), dzięki czemu zewnętrzny rezystor podciągający wymusi stan wysoki. Natomiast stan niski jest realizowany poprzez przełączenie linii portu na wyjście (odpowiedni bit rejestru DDRx ustawiony na jeden), dzięki czemu uprzednio ustawione zero na odpowiednim bicie rejestru PORTx wymusi stan niski na linii interfejsu. W przypadku odczytu stanu linii transmisyjnej interfejsu 1-Wire przez mikroprocesor należy ustawić linię portu jako wejście i odczytać odpowiedni bit rejestru PINx.

Documents

Systemy Wbudowane i Mikroprocesory - eti.pg.edu.pl · PDF file• Kompilator języka C – MPLAB_C18_Libraries_ , MPLAB_C18_Getting_Started.pdf, MPLAB_C18_User_Guide_51288j.pdf •