Płytki testowe do mikrokontrolerów

|



Płytki stykowe to bardzo dobry i wygodny wynalazek, służący do szybkiego budowania prototypów bez użycia lutownicy i wielokrotnego montowania elementów bez ich niszczenia. W praktyce często stosuje się typowe układy jak wyświetlacz multipleksowany czy klawiatura matrycowa, które wprawdzie nie są skomplikowane, ale ich zmontowanie na płytce jest czasochłonne. Ponadto, takie układy występują bardzo często. Dlaczego by nie zrobić osobnych płytek na których na stałe będą moduły gotowe do zastosowania?

Spis treści:
Pliki do pobrania:

Materiały z tej strony można wykorzystać wyłącznie do celów niekomercyjnych. Wykorzystanie komercyjne całości lub części, na przykład sprzedaż, jest zabroniona! Zabronione jest także wykorzystanie komercyjne urządzeń opracowanych w oparciu o zamieszczone tutaj materiały.

ATmega128 TestBoard


ATmega128 jest bardzo zaawansowanym procesorem i warto poznać jego działanie. Niestety w sprzedaży dostępna jest wyłącznie wersja SMD, której nie można umieścić w płytce stykowej, tak jak prostsze ATmegi. Wiele firm oferuje płytki prototypowe z ATmega128, ale cena ich jest absurdalna. Np. w pewnym sklepie sprzedają trywialnie prostą płytkę za 109zł!!! Wobec tego zmuszony byłem zaprojektować własny moduł, a jego koszt wyniósł mnie niecałe 40zł!

Płytka jest wyposażona w złącza programujące ISP oraz JTAG z wtykami IDC-10. Oprócz tego jest mały potencjometr przeznaczony do zabawy z ADC albo do sterowania kontrastem wyświetlacza LCD. W dwóch rogach płytki umieściłem złącza zasilające. Można nimi zasilać inne moduły lub wyświetlacze. Są połączone bezpośrednio do zasilania złącz programujących. Płytka nie jest wyposażona we własny stabilizator. Pamiętać należy, aby nie podłączyć równolegle dwóch źródeł zasilania - np. programatora i baterii. Obecność napięcia na szynach zasilających sygnalizuje czerwona dioda. Na płytce są także dwa rezystory 4,7k przeznaczone jako pull-up do I2C. Wystarczy założyć zworki na piny przy porcie D.

Mikrokontrolery XMEGA

Złącze XTAL służy do podłączenia kwarcu taktującego CPU. Należy zastosować kawałek listwy precyzyjnej do goldpinów. Przy zastosowaniu listwy zwykłej, kwarc przesuwa się i rozłącza, co zawiesza procesor. TOSC to miejsce na kwarc 32kHz do wewnętrznego zegara RTC. Kiedy nie używamy RTC, to złącze można wykorzystać jako zwykłe wyjścia portu G.


Karta pamięci RAM 64KB


ATmega128 umożliwia współpracę z pamięcią zewnętrzną RAM (a dokładniej SRAM) o maksymalnym rozmiarze 64KB bez stronicowania. Interfejs jest tak prosty w obsłudze, że podczas pracy zapominam, że działam na zewnętrznym RAM-ie. W module zastosowałem dwa układy scalone 62256. Są to tanie pamięci RAM o rozmiarze 32KB (256kbit). Najlepiej było by zastosować jedną 62512 zamiast dwóch 62256, ale te pierwsze są bardzo trudno dostępne (ciekawe czemu?). W nazwie 62256-50 druga liczba oznacza czas dostępu - w tym przypadku 50ns. Układy scalone 7404 i 74573 muszą być w wersji HC, czyli 74HC04 i 74HC573.

ATmega128 ma 4KB wewnętrznej pamięci RAM. Nie można podłączyć 64KB by uzyskać 68KB ze względu na 16-bitową szynę adresową. Po prostu więcej niż 64KB nie da się zaadresować. W związku z tym, pierwsze 4KB zewnętrznej pamięci RAM się marnuje, a dostępne jest tylko 60KB. W przypadku podłączanie mniejszych pamięci, np 32KB, możliwe jest oczywiście wykorzystanie całej pojemności.

Elementy elektroniczne, zestawy prototypowe, Arduino

Karta pamięci RAM jest przystosowana do współpracy z płytką ATmega128. Wystarczy wetknąć RAM w odpowiednie miejsce i do programu trzeba dopisać kilka linijek kodu. W poniższym przykładzie, pamięć RAM służy jako wielka tablica zmiennych.

#define XRAM_START     0x1100
#define XRAM_END 0xffff


// ATmega128 extermal ram
MCUCR = (1<<SRE); // wlaczenie interfajsu XRAM
XMCRA = 0; // bez podzialu na sektory, bez czekania
XMCRB = 0; // bez busskeepera, dostepne 60kB

// ustalenie tablicy pod pierwszym adresem pamięci RAM
char *tablica = (char*)XRAM_START;

// czyszczenie tablicy programu
for(i=0; i<=(XRAM_END-XRAM_START); ++i) {
tablica[i] = 0;
}



ATmega128 DIL64


ATmega128 występuje wyłącznie w obudowach SMD, więc trzeba ją lutować albo stosować drobie podstawki. Mam w planach kilka konstrukcji z ATmega128, które mają być rozebrane kiedy przestaną być potrzebne. Tak więc powstał moduł ATmega128 w obudowie DIL64 - dzięki temu można ją bez problemu wyciągnąć. Pasuje też do płytek stykowych, w przeciwieństwie do typowych "kwadratowych" przejściówek z TQFP.

Poniżej widać też kartę pamięci RAM - piny karty pamięci odpowiadają pinom ATmegi. Dzięki temu można ją wetknąć do płytki stykowej obok ATmega128 DIL64 i wystarczy jeszcze tylko wetknąć dwa kabelki zasilania.

Płytki są bardzo precyzyjne. Ścieżki 12mils, odstęp 10mils. Należy zastosować laminat 1,5mm bo cieńszy się połamie przy wyciąganiu. Nie warto inwestować w precyzyjne szpilki i oryginalną podstawkę DIL64 - zwykłe tanie szpilasy i dziurasy są wystarczająco dobre i tanie. Dostępne są różne wzory :) gdyby ktoś chciał taką to zapraszam na kontakt. Mam też płytki z pierwszego postu. Zawsze robię kilka na zapas.



Real Time Clock DS1307


DS1307 to zegar czasu rzeczywistego z własnym oscylatorem i zasilaniem bateryjnym. Działa zawsze, niezależnie od innych układów. Komunikuje się z procesorem przez magistralę I2C. Na płytce są wbudowane rezystory podciągające 4,7k, które można podłączyć odpowiednimi zworkami. W przypadku, jeżeli układ ma działać bez baterii, należy nałożyć zworkę NOBAT.


void ds1307_write(uint8_t h, uint8_t m, uint8_t dd, uint8_t mm, uint8_t yy, uint8_t dt) { // poprawic!!!!!!!!!!! uart -> in
// dt to dzień tygodnia (poniedziałek=2)

i2c_init(100);
i2c_start();
i2c_write(208); // adres zapisu DS1307
if(TWSR != 0x18) { // sprawdzanie czy DS1307 odpowiada
t("zegar nie odpowiada");
return;
}
i2c_write(0); // zapis od poczatku pamieci
i2c_write(0); // sekundy
i2c_write(((m/10)<<4)+(m%10)); // minuty
i2c_write(((h/10)<<4)+(h%10)); // godziny
i2c_write(dt); // dzień tygodnia
i2c_write(((dd/10)<<4)+(dd%10)); // dzień
i2c_write(((mm/10)<<4)+(mm%10)); // miesiąc
i2c_write(((yy/10)<<4)+(yy%10)); // rok
i2c_stop();
return;

// DS1307 przechowuje liczby w kodzie BCD!
}

void ds1307_read(void) {
uint8_t sek, min, godz, dztyg, dzien, mies, rok;
i2c_init(100);
i2c_start();
i2c_write(208); // adres zapisu DS1307
if(TWSR != 0x18) { // sprawdzanie czy DS1307 odpowiada
t("zegar nie odpowiada");
return;
}
i2c_write(0);
i2c_start();
i2c_write(209); // adres odczytu DS1307
sek = i2c_read();
min = i2c_read();
godz = i2c_read();
dztyg = i2c_read();
dzien = i2c_read();
mies = i2c_read();
rok = i2c_read_nack();
i2c_stop();

out_hex(godz); // wyświetlanie liczby szesnastkowej
t(":");
out_hex(min);
t(":");
out_hex(sek);
t(" ");
out_hex(dzien);
t(".");
out_hex(mies);
t(".20");
out_hex(rok);
t(" ");
switch(dztyg) {
case 1:
t("nd");
break;
case 2:
t("pn");
break;
case 3:
t("wt");
break;
case 4:
t("sr");
break;
case 5:
t("cz");
break;
case 6:
t("pt");
break;
case 7:
t("sb");
break;
}
return;
}




Pamięć EEPROM 24C


Podstawka umożliwia podłączenie trzech pamięci 24Cxxx (xxx oznacza pojemność pamięci w kilobotach). Pamięci EEPROM tego typu komunikują się przez magistralę I2C. Dodatkowo jest możliwość (konieczność?) zmiany adresów pamięci przy pomocy zworek - założona zworka oznacza 1, brak zworki to 0. Dla przykładu, pamięć AT24C128 bez żadnych zworek na liniach adresowych, ma adres 160 dla zapisu oraz 161 dla odczytu. Więcej szczegółów w dokumentacji pamięci. Płytka ma także możliwość zabezpieczenia write-protect dla każdego scalaka. Jest także możliwość skorzystania z rezystorów 4,7k jako pull-up na liniach SDA oraz SCL - wystarczy założyć zworki na odpowiednie piny. Myślę, że wszystkie istotne informacje na temat tej płytki można wyczytać ze schematu, a na temat funkcjonowania pamięci 24C napiszę kiedyś osobny artykuł.




Wyświetlacz LED trójkolowy


Zawiera diody zielone i czerwone, a przy jednoczesnym świeceniu dają światło żółte. Są one w obudowie pojedynczej ze wspólną anodą. Zwykły, jednokolorowy wyświetlacz posiada dwie anody (pin 3 i 8). W tym wynalazku jest anoda diod zielonych i druga anoda diod czerwonych. Zastosowałem połączenie multipleksowe, co daje nam osiem wyprowadzeń segmentów i osiem wyprowadzeń anod - w sam raz do mikrokontrolera ośmiobitowego :)

Ze względu na nietypowe wyświetlacze, schemat również jest trochę nietypowy. Doświadczonemu elektronikowi rzucą się w oczy nietypowe wartości rezystorów - wszystko dlatego, aby diody zielone i czerwone równocześnie świeciły tak samo jasno. Poza tym, chciałem oszczędzić rezystorów na segmenty i dlatego ich tam nie ma. Wyświetlacz jest z założenia przystosowany do połączenia multipleksowego, aczkolwiek można go także używać bez multipleksowania - należy wtedy wybrać jedną anodę lub ewentualnie dwie anody tego samego wyświetlacza, aby świecił na żółto. Przy multipleksowaniu świeci trochę słabiej niż bez.

Segmenty są zapalane zerami, cyfry też są zapalane zerami. Wyświetlacze tego typu można kupić w sklepie AVT za 2zł sztuka. Można również stosować wyświetlacze jednokolorowe, byle ze wspólną anodą.



Klawiatura matrycowa 4x4


Połączenie matrycowe pozwala dołączyć aż 16 klawiszy do 8-bitowego portu mikrokontrolera. Zasada odczytu jest bardzo prosta - kolumny podłączamy do pinów 0123 i w rejestrze DDR ustawiamy je jako wyjścia (=1) o stanie początkowym 0, a wiersze łączymy z pinami 4567, które ustawiamy na wejścia (=0) z podciągnięciem do zasilania. W pierwszej fazie skanowania, przypisujemy pierwszej kolumnie wartość 0 i sprawdzamy czy w rejestrze PIN kolejnych wierszy przypadkiem nie pojawiło się 0, co oznacza wciśnięcie klawisza. Później 0 ustawiane jest na kolejnej kolumnie i skanowanie wierszy przebiega tak samo. Procedura jest bardzo prosta. Przykładowy kod programu, chyba najprostszy z możliwych, bez żadnych pętli i przesunięć, zamieszczam poniżej.

Funkcja read_keypad zwraca wartość typu unsigned char, czyli po prostu klawisz. Niekoniecznie musi to być wartość 1-16. Równie dobrze można wpisać 'a' 'b' 'c' pamiętając o 'apostrofach'. Jeżeli funkcja nie stwierdzi wciśnięcia żadnego klawisza, zwróci wartość zero.

Jeszcze słowo na temat co to jest asm volatile("nop") - bez tego funkcja nie działa, ponieważ ustawiamy rejestr PORT i od razu odczytujemy rejestr PIN. Dzieje się to za szybko. PIN nie zdąży odczytać zera ustawionego w kolumnie i dlatego funkcja nie zauważy wciśnięcia przycisku. Komenda nop każe procesorowi odczekać jeden cykl zegarowy, aby w rejestrze PIN znalazła się "aktualne zero" kolumny, która ma być przeskanowana.



void init(void) { // 1 wyjscie, 0 wejscie

DDRB = 0b00001111; // klawiatura matrycowa
PORTB = 0b11110000;
}

unsigned char read_keypad(void) {

// kolumny - piny 0123
// wiersze - piny 4567

PORTB = 0b11111110; // 1 wiersz
asm volatile("nop");
if(!(PINB & _BV(4))) return 1; // 1 kolumna
if(!(PINB & _BV(5))) return 2; // 2 kolumna
if(!(PINB & _BV(6))) return 3; // 3 kolumna
if(!(PINB & _BV(7))) return 4; // 4 kolumna
PORTB = 0b11111101; // 2 wiersz
asm volatile("nop");
if(!(PINB & _BV(4))) return 5;
if(!(PINB & _BV(5))) return 6;
if(!(PINB & _BV(6))) return 7;
if(!(PINB & _BV(7))) return 8;
PORTB = 0b11111011; // 3 wiersz
asm volatile("nop");
if(!(PINB & _BV(4))) return 9;
if(!(PINB & _BV(5))) return 10;
if(!(PINB & _BV(6))) return 11;
if(!(PINB & _BV(7))) return 12;
PORTB = 0b11110111; // 4 wiersz
asm volatile("nop");
if(!(PINB & _BV(4))) return 13;
if(!(PINB & _BV(5))) return 14;
if(!(PINB & _BV(6))) return 15;
if(!(PINB & _BV(7))) return 16;
return 0;
}





Klawisze


Tutaj nie ma nic do gadania :) Zwykłe, zwyczajne klawisze. Nie mają wbudowanych rezystorów podciągających, więc należy pamiętać o wpisaniu jedynek do rejestru PORT. Linię wspólną należy podłączyć do masy. Do sprawdzenia czy przycisk na linii PB0 został wciśnięty, stosuje się jedno z poniższych poleceń:



if(bit_is_clear(PINB,0)) {...}
if(!(PINB & 0b00000001)) {...}
if(!(PINB & _BV(0))) {...}




DIPswitch


Dokładnie to samo co klawisze powyżej, ale nie trzeba ich cały czas wciskać, a jedynie przesunąć suwak. Bardzo wygodne jeżeli nie trzeba tego robić zbyt często ;) Polecam DIPswitch umieścić w podstawce DIL16, ponieważ przełączniki po pewnym czasie odmawiają posłuszeństwa i łatwiej je wtedy wymienić.



Linijka LED (LEDBAR)


LEDBAR jest bardzo fajnym elementem. Zamiast podłączać 10 diod osobno, mamy już wszystko w formie scalonej. Jeszcze by tego brakowało aby i rezystory scalić do środka :) W zależności od tego, którą stroną włożymy LEDBAR w podstawkę, uzyskujemy linijkę ze wspólną anodą połączoną z zasilaniem (zapalanie zerami) lub ze wspólną katodą połączoną z masą (zapalanie jedynkami). Rezystory 220R zostały dobrane dla diod żółtych. Dla innych kolorów należy je dobrać w sposób właściwy ;)



Kabelki i taśmy


Przykładowy wyświetlacz ma 8 segmentów i 8 anod, co daje 16 połączeń. Celem tego wszystkiego jest maksymalne zaoszczędzenie czasu przy zachowaniu dużej elastyczności. Dobrym pomysłem było kupienie metra taśmy 10-żyłowej i wykonanie z niej kabelków oraz taśm 4-żyłowych.

Wykonałem je bardzo szykbo przylutowując kabelki do niepociętego rzędu goldpinów. Całość zalałem klejem kropleką, aby piny się nie wysuwały. Z drugiej strony przylutowałem drugi rząd goldpinów i również je przykleiłem. Tak powstało coś w rodzaju 40-żyłowej taśmy, którą następnie pociąłem na pojedyncze kabelki. Aby wszystko było eleganckie, nałożyłem koszulki termokurczliwe (termokurczak).


Sklep Leon Instruments