Szybkie sprawdzenie falownika

Twój falownik pokazuje błąd, wybija zabezpieczenia, nie rusza silnika ? Masz ochotę odesłać go do serwisu ? Zanim to zrobisz, warto wykonać kilka pomiarów aby uzyskać wstępną diagnozę.

falownik Goodrive
falownik Goodrive

Poniżej przedstawię bardzo prostą i szybką metodę pomiarów diagnostycznych falownika w celu ustalenia jego niedomagań. Zanim jednak przystąpisz do pracy, przeczytaj cały artykuł i zastanów się, czy jesteś w stanie wykonać wszystko co tu opisałem, zachowując przy tym warunki bezpieczeństwa ludzi i sprzętu.

Artykuł dotyczy większości falowników / inwerterów / przemienników częstotliwości / serwoinwerterów / serwowzmacniaczy / serwodriwerów o konstrukcji zawierającej układ zasilania jedno- lub trójfazowy oraz układ wyjściowy mocy oparty na tranzystorach lub modułach IGBT w standardowej konfiguracji. Może się jednak zdarzyć, że będziesz miał do czynienia z nietypowymi rozwiązaniami układowymi wykluczającymi wykonanie opisanych przeze mnie pomiarów.

Narzędzia

Przed przystąpieniem do prac przygotuj podstawowe narzędzia, jak na przykład wkrętak (rozmiarem przystosowany do śrub na zaciskach mierzonego falownika). Najważniejszym jednak jest przyrząd pomiarowy. Do naszych celów wystarczy zwykły cyfrowy lub analogowy miernik uniwersalny z opcją pomiaru złącz półprzewodnikowych (zwykle jest to zakres pomiarowy oznaczony symbolem diody). Miernik powinien być wyposażony w sondy pomiarowe i co ważne, w źródło zasilania (baterię) o dobrej kondycji.

Przygotowania


Przed przystąpieniem do prac odłącz zasilanie falownika wyłącznikiem sieciowym (głównym) maszyny oraz upewnij się, używając posiadanego miernika lub specjalnego testera, czy na przyłączach falownika nie występuje prąd elektryczny.


Odczekaj koniecznie czas potrzebny na rozładowanie się kondensatorów wysokonapięciowych ! Czas ten jest zwykle określony przez producenta i oznaczony na obudowie falownika lub zamieszczony w jego dokumentacji. Niektóre urządzenia posiadają też odpowiednio oznaczoną, zazwyczaj czerwoną, kontrolkę informującą o obecności napięcia na kondensatorach falownika.

Jeśli nie wiesz ile czasu powinieneś odczekać przed przystąpieniem do dalszych prac, załóż bezpieczny czas np. 30 minut. Dla falowników dużej mocy, czas powinien być odpowiednio dłuższy.
Możesz również zmierzyć napięcie pomiędzy zaciskami falownika oznaczanymi zwykle P+ i P- (jeśli Twój falownik takie posiada), jest to napięcie występujące na baterii kondensatorów wysokonapięciowych. Jeśli napięcie to jest większe niż kilka voltów, odczekaj do momentu jego bezpiecznego samoczynnego obniżenia (rozładowania się kondensatorów).
Uwaga: Całkowity brak mierzonego napięcia może być również efektem niesprawności falownika, w takim przypadku zaleca się specjalną ostrożność.


Pamiętaj: Dalsze prace możesz prowadzić jedynie przy stanie beznapięciowym na wszystkich zaciskach falownika !


Teraz odłącz wszystkie przewody elektryczne od strony zasilania oraz od strony przyłączy silnika (również te podłączone do rezystora hamującego, jeśli został zaimplementowany). Przewody PE oraz te, podłączone do zacisków niskonapięciowych sterowania mogą pozostać podłączone.
Sprawdź czy na pewno dobrze wykonałeś powyższe zadanie, w przeciwnym wypadku wyniki pomiarów mogą być błędne a Twój przyrząd pomiarowy będzie narażony na uszkodzenie.

Dla pewności braku napięcia na obwodach mocy falownika i ochrony Twojego przyrządu pomiarowego, na zaciski P+ i P- falownika możesz założyć tymczasowo zworkę z odcinka przewodu lub rezystora rozładowczego o rezystancji kilka kiloomów i mocy kilku watów.
Zworkę tę należy usunąć bezpośrednio przed wykonywaniem pomiarów.

Konstrukcja falownika

W naszych pomiarach traktujemy falownik jako “czarną skrzynkę”, jednak dobrze jest zapoznać się z jego ogólną konstrukcją, aby lepiej zinterpretować otrzymane wyniki.

Schemat blokowy falownika
Schemat blokowy falownika (wariant uproszczony)

W znakomitej większości falowników, zwłaszcza małych i średnich mocy, możemy wyróżnić 2 główne bloki, które opiszemy w dalszej treści:

  1. Blok wejściowy – zasilania
  2. Blok wyjściowy – mocy

ad.1. BLOK ZASILANIA

Blok zasilania składa się zazwyczaj z filtra przeciwzakłóceniowego (czasami filtr taki stanowi oddzielony mechanicznie i elektrycznie moduł, zamontowany często pod radiatorem falownika lub obok niego), oraz obwodu prostownika 1 lub 3 fazowego i baterii kondensatorów.
Prostownik w falownikach małej i średniej mocy zrealizowany jest (szczególnie w tańszych i prostszych modelach) w oparciu o standardowy diodowy, pasywny mostek Graetz’a, czasami zaś jest to mostek sterowany (prostownik aktywny) zrealizowany w oparciu o diody sterowane (tyrystory).
Niezależnie od przyjętego rozwiązania, zadaniem prostownika jest zamiana przemiennego napięcia sieci dostarczonego do falownika, na napięcie stałe służące do zasilenia jego obwodów mocy.

Powstałe za prostownikiem tętnienia prądu są wygładzane za pomocą baterii kondensatorów, która to składa się z jednego lub wielu wysokonapięciowych kondensatorów elektrolitycznych. Pełni ona również bardzo ważną rolę w magazynowaniu i oddawaniu energii w trakcie normalnej pracy falownika.

W przypadku zasilania falownika z jednofazowego napięcia sieci elektroenergetycznej 230VAC, na zaciskach baterii kondensatorów filtrujących pojawia się napięcie ok. 325VDC. W przypadku zaś, kiedy urządzenie zasilane jest trójfazowo z sieci o napięciu międzyfazowym 400VAC, napięcie na kondensatorach wynosi ok. 565VDC.
W praktyce, ze względu na wahania napięcia sieci, jej brak symetrii oraz jakość samych kondensatorów, powyższe napięcia mogą się różnić od wyżej podanych.
Czasami falownik przystosowany jest do zasilania innymi napięciami, lecz nie ma to większego znaczenia dla naszych pomiarów.

Napięcie na baterii kondensatorów jest wyprowadzane zazwyczaj na zaciski falownika oznaczane zwykle jako P+ i P-. Niestety nie wszystkie falowniki mają je dostępne, zwłaszcza urządzenia małej mocy posiadają wyprowadzony jedynie zacisk P+. W takim przypadku nie wykonamy pełnych pomiarów chyba, że zapewnimy sobie dostęp do brakującego zacisku wewnątrz urządzenia.

W skład układu zasilania wchodzi także rezystor startowy. Szerzej o tym rezystorze można przeczytać tutaj.

Rezystor startowy jest umieszczany zwykle szeregowo pomiędzy wyjściem prostownika a baterią kondensatorów filtrujących. Ma on za zadanie ograniczenie prądu ładowania kondensatorów w fazie po włączeniu zasilania. Dzieje się tak, gdyż jego rezystancja wraz z pojemnością kondensatorów tworzą pewną stałą czasową opóźniającą ich ładowanie zmniejszonym prądem.
Procesor falownika sterujący fazą rozruchu urządzenia, po określonym czasie, zwiera (zazwyczaj za pomocą stycznika) zaciski rezystora startowego eliminując tym samym jego wpływ na obwód zasilania falownika w dalszej fazie pracy.
Należy pamiętać, że w konstrukcjach opartych o aktywne zespoły prostownicze (mostki tyrystorowe) rezystor startowy nie jest zwykle stosowany, gdyż sterownik prostownika odpowiednio reguluje prąd ładowania baterii kondensatorów.

Uwaga
W trakcie wykonywania naszych pomiarów, warto uwzględnić obecność rezystora startowego, który podczas pomiarów obwodów zasilania stanowi rezystancję szeregową.

ad.2. BLOK WYJŚCIOWY

Blok wyjściowy falowników jest zwykle zrealizowany w oparciu o moduł lub moduły zwierające tranzystory IGBT. W mniejszych falownikach spotkać można pojedyncze tranzystory IGBT, lecz jest to już coraz rzadszy przypadek. Niezależnie od konstrukcji, z punktu widzenia jego działania, blok wyjściowy ma za zadanie zamienić prąd stały dostarczony z bloku zasilania a konkretnie z jego baterii kondensatorów, na przebieg zmienny (przemienny trójfazowy).
Istnieją również falowniki posiadające wyjścia jednofazowe, jednak nimi nie będziemy się tutaj zajmować, gdyż stanowią mniejszość i obejmują jedynie falowniki małych mocy. Ich pomiar jest identyczny, jak dla falowników o wyjściach trójfazowych z wyłączeniem zacisku brakującej fazy.
Należy również dodać, że niektóre konstrukcje wyposażone są od strony zacisków wyjściowych we wbudowane obciążenia o niewielkiej rezystancji, w takich konstrukcjach wykonanie poprawnych pomiarów jest bardzo utrudnione i wymaga użycia zaawansowanych przyrządów pomiarowych (np. mostka do pomiaru małych rezystancji).

Goodrive
Goodrive

Pomiary

Przed przystąpieniem do pomiarów i po upewnieniu się o braku napięcia na zaciskach falownika, zapewnij sobie swobodny dostęp do punktów pomiarowych, które stanowią zespoły zacisków:

  • Zasilania (przyłącze sieci) – R, S, T (opisywane również jako L1, L2, L3) lub L1, L2 (albo N) w falownikach z zasilaniem jednofazowym
  • Wyjściowe (przyłącze silnika) – U, V, W (opisywane również jako M1, M2, M3 albo T1, T2, T3)
  • Napięcia stałego (na baterii kondensatorów) oznaczane zwykle jako
    P+, P- (opisy ich jednak mogą być różnorakie, należy sprawdzić to w dokumentacji fabrycznej urządzenia)
Zaciski falownika (przykład)

Uwaga
Pomiary należy wykonywać przyrządem ustawionym na zakres pomiaru elementów półprzewodnikowych (zazwyczaj zakres ten jest oznaczony symbolem diody).

Poniżej zamieszczam tabelkę, która obrazuje poszczególne pomiary wraz z ich prawidłowym wynikiem. Niektóre wyniki liczbowe (wartości spadków napięć na złączach półprzewodnikowych) mogą się różnić od wartości przedstawionych w tabeli.

Tabela pomiarów falowników

Tabela do pobrania w formie pliku pdf jest dostępna Tutaj.

Uwaga
Pamiętaj, że wykonane pomiary, o których mówi niniejszy artykuł, mają jedynie charakter orientacyjny i mogą być tylko jednym z wielu czynników pozwalających postawić trafną diagnozę uszkodzeń falownika.

Przykład 1. Jeśli podczas jednego z pomiarów bloku zasilania wykryjesz całkowite zwarcie a dodatkowo falownik przyłączony do zasilania uszkadza, “wybija” zabezpieczenia, możesz być prawie pewny, że falownik ten jest definitywnie uszkodzony.

Przykład 2. Jeśli podczas pomiaru bloku wyjściowego jeden z pomiarów wykazuje odchylenie od podanej wartości a pomiary odłączonego silnika nie wykazują anomalii, nie możesz zdiagnozować w 100% uszkodzenia falownika.


Nie próbuj wykonywać samodzielnie napraw, jeśli nie jesteś pewien tego co robisz. W celu zaoszczędzenia czasu i obniżenia mogących powstać w ten sposób dodatkowych kosztów, skorzystaj z wiedzy i doświadczenia wykwalifikowanego serwisu naprawczego.


ZAPRASZAMY

Firma Elektronika Serwis ani autor tego artykułu nie ponoszą w żadnym wypadku jakiejkolwiek odpowiedzialności za powstałe w wyniku działań inspirowanych niniejszym artykułem straty materialne i/lub uszczerbek na zdrowiu.

Interfejs klawiatury PS/2 dla CA80

Projekt interfejsu komunikacyjnego umożliwiającego współpracę klawiatury PC posiadającej interfejs PS/2 z mikrokomputerem retro CA80.

Autor: Sławomir Jurkiewicz

Mikrokomputer CA80 z interfejsem i klawiaturą PS/2

Korzystając z zimnej i deszczowej w tym roku majówki, chciałbym zaprezentować projekt interfejsu mojego autorstwa. Od niedawna stałem się bowiem szczęśliwym posiadaczem i użytkownikiem mikrokomputera retro o nazwie “CA80”, zaprojektowanego przez polskiego inżyniera Stanisława Gardynika i wylansowanego w latach 80tych ubiegłego wieku przez jego firmę MIK.

Więcej o moich perypetiach z CA80 można przeczytać TUTAJ.

Założenia projektu

  1. Interfejs ma na celu zastąpienie oryginalnej klawiatury matrycowej standardową klawiaturą dla komputerów PC posiadającą interfejs PS/2 i złącze mini-DIN.
  2. Zarówno klawiatura PC, jak i mikrokomputer CA80 pozostają oryginalne, brak w nich w zasadzie jakichkolwiek modyfikacji (z wyjątkiem wyprowadzenia zasilania oraz sygnału resetu na złącze klawiatury [ZK] mikrokomputera CA80 – patrz schemat ideowy interfejsu).
  3. Interfejs wykonany jest na bazie ARDUINO w wersji NANO w formie dosyć kompaktowej płytki i zawiera ogólnodostępne części elektroniczne.
  4. Wszystkie sygnały interfejsu są pobierane ze złącza klawiatury (ZK) mikrokomputera CA80.
  5. Oprogramowanie ARDUINO jest uproszczone w maksymalnym stopniu a ilość zajętych obsługą interfejsu linii danych ARDUINO ograniczona do niezbędnego minimum.

Schemat ideowy i opis działania

Interfejs PS/2 CA80 - schemat
Interfejs – schemat ideowy

LINK do schematu w formacie PDF.

Idea działania interfejsu może być opisana w następujących krokach prostego algorytmu:

  1. Oczekiwanie mikrokontrolera Arduino na przyciśnięcie klawisza na klawiaturze PC.
  2. Pobranie danych (kodu naciśniętego klawisza) z interfejsu PS/2 klawiatury.
  3. Zdekodowanie kodu klawiatury PC.
  4. Odczekanie aż na wyjściu przeczesywania matrycy przycisków CA80 pojawi się właściwy sygnał. Wyjścia KA, KB, KC, KD złącza klawiatury CA80 (ZK) są, poprzez koder sprzętowy IC2, sprawdzane w pętli programu Arduino i na bieżąco porównywane z odczytanym i zdekodowanym kodem uprzednio pobranym z klawiatury PC.
  5. Pojawienie się poprawnego sygnału j.w. powoduje wygenerowanie przez interfejs odpowiedzi logicznej, która po zdekodowaniu sprzętowym (IC1) przekazywana jest do CA80 symulując zwarcie styków przycisku symulowanej klawiatury matrycowej.

Analizując schemat, możemy wyróżnić na nim 3 współpracujące ze sobą bloki funkcjonalne: koder (IC2), dekoder (IC1), sterownik (Arduino Nano).

  • Podstawowym zadaniem kodera opartego o układ cyfrowy 74147 jest zamiana sygnałów przeczesywania matrycy CA80 z postaci 1z4 na postać liczby z przedziału 0x03 do 0x07 (patrz tablica prawdy kodera 74147). Takie rozwiązanie prócz zaoszczędzenia jednego wejścia Arduino, daje również możliwość elektrycznego buforowania sygnałów z interfejsu klawiatury CA80 zmniejszając jego obciążenie.
Tablica prawdy kodera 74147

Zgodnie z tablicą prawdy układu kodera 74147 zarówno sygnały na wejściu jak wyjściu tego układu są zanegowane, czyli stanem aktywnym jest poziom niski “L”.

Jest możliwe pominięcie układu kodera 74147, w takim przypadku sygnały wyjściowe przeczesywania klawiatury (KA do KD) należy podłączyć bezpośrednio na wejścia modułu kontrolera Arduino.
W takim przypadku konieczna jest m.in. zmiana tablicy kodowania zawartej w programie interfejsu (funkcja getKeyString() ).

  • Dekoder IC1 oparty na układzie 74137 zamienia sygnały sterujące z modułu Arduino na postać 1z6. Rozwiązanie takie upraszcza sterowanie i redukuje ilość zajętych wyjść Arduino z 6 do 3.
Tablica prawdy dekodera 74137

Tablica prawdy kodera 74137 pokazuje, że jego sygnały wejściowe nie są zanegowane (aktywny jest tutaj stan wysoki “H”), w przeciwieństwie do sygnałów wyjściowych, gdzie aktywny jest niski stan sygnału – “L”.

Program dla Arduino

Sketch dla Arduino w spakowanym pliku *.INO jest do pobrania TUTAJ.

//------------------------------------------------------------------------------------------------------------------------
//      CA80 PS2 Keyboard Transcoder v2.3P (wersja produkcyjna z polskimi komentami
//       PCB v1.0 (Arduino NANO)
//------------------------------------------------------------------------------------------------------------------------
//  Autor: Sławomir Jurkiewicz (elserw@elserw.com)
//  Na podstawie: "Podłączamy stara klawiaturę do Arduino" by Kamil (https://starter-kit.nettigo.pl/author/kamil/feed/)
//    oraz "Zdalne sterowanie klawiaturą" by Natasza Biecek (http://bienata.waw.pl/ca808.php)
//------------------------------------------------------------------------------------------------------------------------

//Definicja funkcji pinów Arduino
#define CLK 2 //inp
#define DAT 8 //inp

#define QA 10 //inp
#define QB 11 //inp
#define QC 12 //inp

#define LED 13 //out
#define KA 5  //out
#define KB 6  //out
#define KC 7  //out

//Deklaracja i zerowanie bufora obsługi danych z klawiatury PC PS/2
const int BUF_SIZE = 11;
bool buffer[BUF_SIZE] = {0};
//Pozostałe zmienne dla procedur PS/2
int pos = 0;
bool ignoreNext = false;
unsigned long lastRead = 0;

int caCode = 0; //Bieżący kod naciśniętego klawisza wysyłany do CA80

void setup() {
  //Komunikacja monitora portu szeregowego Arduino do celów debugowania programu
  //Wszystkie linijki kodu zaczynające się od "Serial." można usunąć w gotowym programie 
  Serial.begin(9600);
  Serial.println("CA80 PS2 Keyboard Transcoder v2.3P");
  Serial.println("Ready...");

  //Ustawienie funkcji zdefiniowanych pinów w Arduino
  //Wejścia
  pinMode(CLK, INPUT);
  pinMode(DAT, INPUT);
  pinMode(QA, INPUT);
  pinMode(QB, INPUT);
  pinMode(QC, INPUT);
  //Wyjścia
  pinMode(LED, OUTPUT);
  pinMode(KA, OUTPUT);
  pinMode(KB, OUTPUT);
  pinMode(KC, OUTPUT);

  digitalWrite(LED, LOW); //Wygaszenie LEDa na płytce Arduino.
  PORTD = 0xE0;  //Ustawienie "1" na pinach D5,D6,D7 (KA, KB, KC). Dekoder IC1 ma wszystkie wyjścia Y0 do Y7 ustawione na "1"

  delay(1000); //Oczekiwanie na zadziałanie klawiatury PS/2 po włączeniu zasilania
  attachInterrupt(digitalPinToInterrupt(CLK), readData, FALLING); //Ustawienie przerwania od wyjścia zegarowego CLK klawiatury PS/2 (reakcja na zbocze dodatnie sygnału CLK) 
}

//Główna pętla programu - wczytanie, dekodowanie klawisza z PS/2 oraz zakodowanie go i wysłanie do CA80 (poprzez ustawienie w odpowiednim momencie wyjść dekodera IC1)
void loop() {
  if(pos != 0 && millis() - lastRead > 1000) {  //oczekiwanie na zapełnienie bufora klawiatury, którego zawartość jest kompletowana w przerwaniu (procedura "readData").
    pos = 0;
  }
  if(pos == 11) { //bufor PS/2 kompletny, wczytano kod klawisza z klawiatury PS/2
    pos = 0;
    int keyCode = getKeyCode(buffer); //Obróbka danych z bufora. W zmiennej "keyCode" jest kod klawisza z PS/2
    if(ignoreNext) {
      ignoreNext = false;
      return;
    }
    if(keyCode == 0xF0) { //Ignoruj kody puszczenia klawisza na PS/2
      ignoreNext = true;
      return;
    }
    //Wysłanie na port szeregowy terminala Arduino informacji o kodzie i nazwie wciśniętego przycisku
    Serial.print("PS/2=0x");
    Serial.print (String(keyCode, HEX));
    Serial.print (" ");
    String keyString=getKeyString(keyCode); //Zdekodowanie kodu klawisza PS/2 na jego nazwę (przy okazji w zmiennej "caCode" znajduje się kod klawisza dla CA80)
    Serial.print(keyString);
    
    if(caCode>0) {
      //Wysłanie na terminal Arduino informacji o kodzie dla CA80 wciśniętego klawisza na klawiaturze PS/2
      Serial.print (" CA80=0x");
      Serial.print (String(caCode, HEX));
      noInterrupts(); //zatrzymanie przwań
      sendKey(caCode); //wysłanie do CA80 kodu naciśniętego klawisza 
      interrupts(); //wznowienie obsługi przerwań
      digitalWrite(LED, !digitalRead(LED)); //zmiana świecenia LED - sygnalizuje wczytanie z klawiatury i wysłanie do CA jednego kodu
      Serial.print (" "); 
      pos = 0; //po włączeniu przerwań bufor klawiatury PS/2 będzie czytany od nowa   
    }
    Serial.println ("");
  }
}

void sendKey(int caCode) {
  //wysłanie kodu naciśniętego klawisza do CA80 (kod  znajduje się w zmiennej "caCode")
  //https://www.arduino.cc/en/Reference/PortManipulation

  int caCodeT = (caCode & 0xF0) >> 4; //modyfikacja zdekodowanego kodu klawisza
  
  for (int i = 0; i <= 20; i++) { //powtórz 20 razy wysłanie klawisza do CA80, aby przechytrzyć debouncing
    while (caCodeT!=(PINB & 0x1C) >> 2) { //czytaj porty 10,11,12 (QA, QB, QC) aby ustalić moment kiedy należy ustawić sygnały KA,KB,KC 
      //pętla oczekiwania na właściwy moment, czyli wystawienie przez CA80 odpowiednich sygnałów KA, KB, KC, KD 
    }  
    PORTD = (caCode & 0x07)<<5; //ustaw porty D5,D6,D7 (KA, KB, KC) w celu wysłania kodu do CA80
    delayMicroseconds(12); //podtrzymaj ustawienia do czasu kiedy CA80 skończy dekodowanie wysłanych mu danych - czas 12us jest krytyczny dla całego procesu
    PORTD = 0xE0;  //zapisz "111" do portów D5,D6,D7 w celu wyzerowania (KA, KB, KC)
  }
}


void readData() {
  //Sczytanie danych z klawiatury PS/2
  lastRead = millis();
  buffer[pos++ % 11] = digitalRead(DAT);
}

int getKeyCode(bool * buf) {
  //Na podstawie danych z bufora funkcja zwraca kod naciśniętego klawisza.
  bool parity = 1;
  int result = 0;
  if(buf[0] != 0) return -1;
  if(buf[10] != 1) return -2;
  for(int x = 0; x < 8; x++) {
    result |= buf[1+x] << x;
    if(buf[1+x]) parity = !parity;
  }
  if(buf[9] != parity) return -3;
  return result;
}

String getKeyString(int keyCode) {
  //Dekodowanie naciśniętego klawisza na podstawie jego kodu
  //  przy okazji w zmiennej "caCode" jest ustawiany kod dla CA80
  caCode=0; 
  switch(keyCode) {
    case 0x1C: caCode=0x52; return "A";
    case 0x32: caCode=0x51; return "B";
    case 0x21: caCode=0x64; return "C";
    case 0x23: caCode=0x63; return "D";
    case 0x24: caCode=0x62; return "E";
    case 0x2B: caCode=0x61; return "F";
    case 0x34: caCode=0x50; return "G";
    //case 0x33: return "H";
    //case 0x43: return "I";
    //case 0x3B: return "J";
    //case 0x42: return "K";
    //case 0x4B: return "L";
    case 0x3A: caCode=0x60; return "M";  //
    //case 0x31: return "N";
    //case 0x44: return "O";
    //case 0x4D: return "P";
    //case 0x15: return "Q";
    //case 0x2D: return "R";
    //case 0x1B: return "S";
    //case 0x2C: return "T";
    //case 0x3C: return "U";
    //case 0x2A: return "V";
    //case 0x1D: return "W";
    //case 0x22: return "X";
    //case 0x35: return "Y";
    //case 0x1A: return "Z";
    case 0x45: caCode=0x34; return "0";
    case 0x16: caCode=0x33; return "1";
    case 0x1E: caCode=0x32; return "2";
    case 0x26: caCode=0x31; return "3";
    case 0x25: caCode=0x44; return "4";
    case 0x2E: caCode=0x43; return "5";
    case 0x36: caCode=0x42; return "6";
    case 0x3D: caCode=0x41; return "7";
    case 0x3E: caCode=0x54; return "8";
    case 0x46: caCode=0x53; return "9";
    case 0x5A: caCode=0x30; return "ENT"; //"=" <ENTER>
    case 0x55: caCode=0x30; return "="; //"=" <ENTER>
    case 0x29: caCode=0x40; return "SPC"; //"." <SPACE>
    case 0x49: caCode=0x40; return "."; //"."
    case 0x05: caCode=0x65; return "F1";  //
    case 0x06: caCode=0x55; return "F2";  //
    case 0x04: caCode=0x45; return "F3";  //
    case 0x0c: caCode=0x35; return "F4";  //
    case 0x76: caCode=0x60; return "ESC";  //"M" <ESC>       
  }
  return "";
}

Płytka drukowana

Strona elementów (TOP)
Strona połączeń (BOTTOM)

Interfejs w trakcie uruchamiania.

Interfejs w trakcie uruchamiania (strona wierzchnia).
Interfejs w trakcie uruchamiania (strona spodnia).

W czasie tworzenia projektu wykorzystano następujące źródła:

  1. “Podłączamy starą klawiaturę do Arduino” by Kamil
  2. “Zdalne sterowanie klawiaturą” by Natasza Biecek
  3. “The PS/2 Mouse/Keyboard Protocol” (Link)