Kursy • Poradniki • Inspirujące DIY • Forum

Premiera: Raspberry Pi
Debug Probe

Historia tranzystora w skrócie.
Wynalezienie czy odkrycie?

3 podstawowe rodzaje
akumulatorów, które warto znać

Co ciekawego w DIY?
10 projektów naszych czytelników #33

Piezoelektryki – czym
są materiały piezoelektryczne?

Tranzystory

Poznaj w praktyce

NE555

Kurs elektroniki

Kursy Artykuły

DIY Forum

Klawiatura skrótów z Arduino, która ułatwia codzienną pracę

Projekty z Arduino Piotr Adamczyk

Czy pamiętacie niedawny artykuł o własnej klawiaturze rozwiązującej problem nieporęcznych skrótów klawiszowych w programie Eagle? Dzięki niej do jednego przycisku można było przypisać nawet bardzo długą sekwencję kliknięć.

W tym artykule przedstawiam moją klawiaturę, która ułatwia pracę z różnymi programami komputerowymi!

Jakiś czas temu pisałem o ciekawym projekcie klawiatury do programu Eagle, która ułatwiała używanie nieporęcznych skrótów klawiszowych. Projekt bardzo mi się spodobał, gdyż program Corel Draw X5, którego codziennie używam do tworzenia ilustracji, posiada wiele narzędzi z przypisanymi iście "pianistycznymi" skrótami klawiszowymi, np. Shift+Alt+P. Po chwili namysłu zdecydowałem się na wykonanie swojej wersji klawiatury!

Na początek zakupiłem niezbędne elementy:

klawiaturę numeryczną posiadającą 18 przycisków,
płytkę Arduino Pro Micro z interfejsem USB 2.0 HID.

Zdecydowałem się na taką klawiaturę, gdyż posiada wygodne przyciski oraz gotową matrycę połączeń, więc w teorii wystarczy podłączyć się do gotowego złącza z sygnałami od klawiszy.

Matrycowanie przycisków jest wygodnym rozwiązaniem, ponieważ zmniejsza liczbę potrzebnych połączeń. Dla przykładu klawiatura 16 przyciskowa (4x4) wymaga jedynie 8 przewodów, zaś 20 przyciskowa (4x5) wymaga 9 przewodów. Tak jest w teorii...

W praktyce okazało się, że złącze zakupionej klawiatury posiada 12 wyprowadzeń...

Używając multimetru nastawionego na pomiar najniższego zakresu rezystancji, spisałem wszystkie połączenia pomiędzy stykami gniazda. Następnie zebrane informacje rozrysowałem do postaci matrycy połączeń, gdzie w miejscach węzłów są przyciski.

W tym miejscu wyjaśniła się zagadka dlaczego jest aż 12 linii. Niektóre linie (patrz komórka F-1) odpowiadają za matrycowanie tylko 1 przycisku! Najwyraźniej w procesie technologicznym bardziej opłacalne było dodanie większej liczby linii - jeśli jest jakieś inne "łatwiejsze" wyjaśnienie tej zagadki, to zwyczajnie go wcześniej nie zauważyłem i przyjąłem poniższy schemat połączeń.

Matryca połączeń przycisków i opis złącza.

Na podstawie schematu połączeń w matrycy podzieliłem sygnały na te które mają być wejściami i te które będą wyjściami. Następnie przylutowałem odpowiednie przewody poprzez rezystory ograniczające prąd do Arduino.

Obudowa z drukarki 3D

Następnie zabrałem się za obudowę. Do schowania sterownika konieczna była dodatkowa podstawka. Model stworzyłem w Autodesk Fusion 360 i wydrukowałem na drukarce 3D.

Model dostawki do klawiatury z gniazdem na Arduino.

Dostawka posiada gniazdo na Arduino Pro Micro w miejscu dobrym do podłączenia kabla USB. Dzięki temu nie ma potrzeby montowania w obudowie dodatkowego złącza USB.

Na tym etapie projekt jest w fazie prototypu, więc w środku nie mogło zabraknąć
plątaniny przewodów oraz kleju na gorąco...

Klawiatura jest zaokrąglona i ciężko było ją zwymiarować. Mimo to, podstawka pasuje dość dobrze zarówno kształtem jak i kolorem.

Ostatnim etapem było wykonanie ikonek klawiszy (oczywiście w Corelu używając nowiutkiej klawiatury). Wydruk zalaminowałem i przykleiłem taśmą dwustronną do przycisków.

Nie będę tłumaczył, co robią poszczególne ikonki, bo każdy i tak może dostosować klawiaturę do własnych potrzeb. W moim przypadku przyspiesza ona wykonywanie wielu operacji w Corelu!

Oczywiście klawiatura może również generować dłuższe ciągi znaków:

Program w Arduino - dla dociekliwych

W programie fizyczne połączenia tworzone są stosując funkcję setSymbol, która za argumenty przyjmuje numer linii wejściowej, numer linii wyjściowej oraz unikatowy symbol. Funkcja posługuje się przy tym wcześniej zdefiniowanymi tablicami:

OUTPUTS - tablica 6 linii wyjściowych zdefiniowana na stałe,
INPUTS - tablica 6 linii wejściowych zdefiniowana na stałe,
symbols - tablica 36 możliwych konfiguracji linii (przy czym używamy tylko 18) wiążących ze sobą wejście, wyjście oraz symbol jako przechowywaną wartość.

void setSymbol(int lineOutput, int lineInput, char symbol){
  // zmienne odpowiedajace indeksom w tablicy dla fizycznych linii
  // wpisanych przez użytkownika.
  int iRow, iColumn;
  
  // odszukaj indeks wiersza czyli lini wyjsc w macierzy
  for(iRow = 0; iRow < MATRIX_SIZE; ++iRow){
    if(OUTPUTS[iRow] == lineOutput)
      break;
  }
  
  // odszukaj indeks kolumny czyli lini wejsc w maciery
  for(iColumn = 0; iColumn < MATRIX_SIZE; ++iColumn){
    if(INPUTS[iColumn] == lineInput)
      break;
  }

  // zapisz symbol w komorce macierzy 1-wymiarowej
  // przy pomocy 2 współrzędnych
  symbols[iRow * MATRIX_SIZE + iColumn] = symbol;
}

void setSymbol(int lineOutput, int lineInput, char symbol){

// zmienne odpowiedajace indeksom w tablicy dla fizycznych linii

// wpisanych przez użytkownika.

int iRow, iColumn;

// odszukaj indeks wiersza czyli lini wyjsc w macierzy

for(iRow = 0; iRow < MATRIX_SIZE; ++iRow){

if(OUTPUTS[iRow] == lineOutput)

break;

}

// odszukaj indeks kolumny czyli lini wejsc w maciery

for(iColumn = 0; iColumn < MATRIX_SIZE; ++iColumn){

if(INPUTS[iColumn] == lineInput)

break;

}

// zapisz symbol w komorce macierzy 1-wymiarowej

// przy pomocy 2 współrzędnych

symbols[iRow * MATRIX_SIZE + iColumn] = symbol;

}

Pierwsze 2 pętle odszukują wpisany numer linii tak,
aby użytkownik funkcji nie musiał posługiwać się indeksami w tablicach.

Następnie tak odszukane indeksy w tablicach są zamieniane na indeks w tablicy 36 możliwych symboli. Jak to się dzieje? Numer wiersza iRow wymnożony przez rozmiar macierzy połączeń (MATRIX_SIZE) niejako przenosi indeks pomiędzy wierszami. Zaś dodanie numeru kolumny przesuwa go o zadaną wartość w obrębie kolumn.

Następnie do tak wybranego indeksu wpisywany jest symbol:

symbols[iRow * MATRIX_SIZE + iColumn] = symbol;

1	symbols[iRow * MATRIX_SIZE + iColumn] = symbol;

Zasada działania sterownika matrycy jest prosta i została omówiona w kursie Arduino poziom 2. W danej chwili tylko jedna linia wyjściowa przyjmuje stan niski, a wszystkie linie wejściowe są sprawdzane. Przełączanie pomiędzy wyjściami jest na tyle szybkie, że efekt matrycowania jest niezauważalny.

void loop() {
  for(int iOutput = 0; iOutput < MATRIX_SIZE; ++iOutput){
    // aktywuj sprawdzanie wiersza o indeksie iOutput
    digitalWrite(OUTPUTS[iOutput], LOW);
    for(int iInput = 0; iInput < MATRIX_SIZE; ++iInput){
      // oblicz numer indeksu w macierzy wszystkich przycisków
      index = iOutput * MATRIX_SIZE + iInput;
      
      // jeżeli obecny stan jest LOW (przycisk wciśnięty)
      if((digitalRead(INPUTS[iInput]) == LOW)){
        if(states[index] == KEY_RELESED){
          // to wywołaj kliknięcie
          onPress(index);
        }
        // ustaw flagę żeby zadziałał zatrzask
        states[index] = KEY_PRESSED;
      } else if(states[index] == KEY_PRESSED)
        // zresetuj zatrzask w momencie puszczenia przycisku
        states[index] = KEY_RELESED;
    }
    // opuść linię aby przejść do następnej
    digitalWrite(OUTPUTS[iOutput], HIGH);
  }
}

void loop() {

for(int iOutput = 0; iOutput < MATRIX_SIZE; ++iOutput){

// aktywuj sprawdzanie wiersza o indeksie iOutput

digitalWrite(OUTPUTS[iOutput], LOW);

for(int iInput = 0; iInput < MATRIX_SIZE; ++iInput){

// oblicz numer indeksu w macierzy wszystkich przycisków

index = iOutput * MATRIX_SIZE + iInput;

// jeżeli obecny stan jest LOW (przycisk wciśnięty)

if((digitalRead(INPUTS[iInput]) == LOW)){

if(states[index] == KEY_RELESED){

// to wywołaj kliknięcie

onPress(index);

}

// ustaw flagę żeby zadziałał zatrzask

states[index] = KEY_PRESSED;

} else if(states[index] == KEY_PRESSED)

// zresetuj zatrzask w momencie puszczenia przycisku

states[index] = KEY_RELESED;

}

// opuść linię aby przejść do następnej

digitalWrite(OUTPUTS[iOutput], HIGH);

}

Istotnym elementem kodu jest stosowanie "zatrzasku" na każdym z klawiszy. Jest to potrzebne, gdyż skrót klawiszowy ma być wyzwolony tylko raz w momencie wciśnięcia przycisku.

W programie zatrzask reprezentuje tablica flag o nazwie states. Jeżeli w danym momencie przycisk jest wciśnięty (przyjmuje stan LOW) i wiemy, że ostatni stan był puszczony (KEY_RELEASE) to wywołaj metodę onPress(index), gdzie index odpowiada znakowi w tablicy symbols lub ostatniemu stanowi w tablicy states.

void onPress(int index){
  //załącz diodę umieszczoną na przodzie klawiatury
  digitalWrite(LED_PIN, HIGH);
  // pobierz symbol spod konkretnego indeksu
  switch(symbols[index]){
    //wierz 1
    case KEY_NUM:
      Keyboard.write(KEY_ESC);
      break;
    case KEY_DOT:
      Keyboard.press(KEY_LEFT_CTRL);
      Keyboard.write('u');
      Keyboard.releaseAll();
      break;
  }
  delay(200);
  digitalWrite(LED_PIN, LOW);
}

void onPress(int index){

//załącz diodę umieszczoną na przodzie klawiatury

digitalWrite(LED_PIN, HIGH);

// pobierz symbol spod konkretnego indeksu

switch(symbols[index]){

//wierz 1

case KEY_NUM:

Keyboard.write(KEY_ESC);

break;

case KEY_DOT:

Keyboard.press(KEY_LEFT_CTRL);

Keyboard.write('u');

Keyboard.releaseAll();

break;

}

delay(200);

digitalWrite(LED_PIN, LOW);

}

Metoda onPress łączy w sobie fizyczne kliknięcia klawiatury z komendą wysłaną do podłączonego urządzenia. Stosując blok switch-case sprawdzany jest symbol klikniętego przycisku i wysyłany zostaje zdefiniowany tekst. W powyższym przypadku są to:

Wciśnięcie samego klawisza Escape,
Wciśnięcie kombinacji Ctrl+U.

Każde wysłani instrukcji potwierdzone jest mignięciem
diody umieszczonej na przodzie klawiatury.

Dla zainteresowanych pełny kod programu. Program jest napisany na tyle elastycznie, że można go dostosować do własnych potrzeb:

ustalić rozmiar matrycy MATRIX_SIZE,
zmienić piny reprezentujące połączenia w blokach #define,
zdefiniować własne symbole w metodzie mapKeys,
napisać co klawiatura ma wypisywać w metodzie onPress.

#include "Keyboard.h"

// led
#define LED_PIN A2

// liczby
#define MATRIX_SIZE 6

// stany
#define KEY_RELESED 0
#define KEY_PRESSED 1

// klawisze
#define KEY_NONE 'x'
#define KEY_ENTER 'e'
#define KEY_NUM 'n'
#define KEY_BACK 'B'
#define KEY_0 '0'
#define KEY_1 '1'
#define KEY_2 '2'
#define KEY_3 '3'
#define KEY_4 '4'
#define KEY_5 '5'
#define KEY_6 '6'
#define KEY_7 '7'
#define KEY_8 '8'
#define KEY_9 '9'
#define KEY_DOT '.'
#define KEY_PLUS '+'
#define KEY_MINUS '-'
#define KEY_MUL '*'
#define KEY_DIV '/'

// wyjscia - wiersze
#define OUT_LINE_1 15
#define OUT_LINE_2 14
#define OUT_LINE_6 8
#define OUT_LINE_A 7
#define OUT_LINE_B 6
#define OUT_LINE_C 5
const int OUTPUTS[] = {OUT_LINE_1, OUT_LINE_2, OUT_LINE_6, OUT_LINE_A, OUT_LINE_B, OUT_LINE_C};

// wejscia - kolumny
#define IN_LINE_3 16
#define IN_LINE_4 10
#define IN_LINE_5 9
#define IN_LINE_D 4
#define IN_LINE_E 3
#define IN_LINE_F 2
const int INPUTS[] = {IN_LINE_3, IN_LINE_4, IN_LINE_5, IN_LINE_D, IN_LINE_E, IN_LINE_F};

// macierze reprezentujące fizyczne symbole i stan zatrzasku
char symbols[MATRIX_SIZE * MATRIX_SIZE];
int states[MATRIX_SIZE * MATRIX_SIZE];
int index = 0;

// funkcja wewnatrz której definiujemy fizyczne połączenia klawiszy i ich symbole
void mapKeys(){
  setSymbol(OUT_LINE_1, IN_LINE_3, KEY_9);
  setSymbol(OUT_LINE_1, IN_LINE_4, KEY_3);
  setSymbol(OUT_LINE_1, IN_LINE_5, KEY_MUL);
  setSymbol(OUT_LINE_1, IN_LINE_D, KEY_6);
  setSymbol(OUT_LINE_1, IN_LINE_E, KEY_DOT);
  setSymbol(OUT_LINE_1, IN_LINE_F, KEY_MINUS);

  setSymbol(OUT_LINE_2, IN_LINE_3, KEY_7);
  setSymbol(OUT_LINE_2, IN_LINE_4, KEY_1);
  setSymbol(OUT_LINE_2, IN_LINE_D, KEY_4);
  
  setSymbol(OUT_LINE_6, IN_LINE_5, KEY_NUM);
  
  setSymbol(OUT_LINE_A, IN_LINE_3, KEY_PLUS);
  setSymbol(OUT_LINE_A, IN_LINE_4, KEY_ENTER);
  
  setSymbol(OUT_LINE_B, IN_LINE_3, KEY_8);
  setSymbol(OUT_LINE_B, IN_LINE_4, KEY_2);
  setSymbol(OUT_LINE_B, IN_LINE_5, KEY_DIV);
  setSymbol(OUT_LINE_B, IN_LINE_D, KEY_5);
  setSymbol(OUT_LINE_B, IN_LINE_E, KEY_0);
  
  setSymbol(OUT_LINE_C, IN_LINE_D, KEY_BACK);
}

// funckja w której wyzwalane są zdarzenia od kliknięć fizycznych przycisków
void onPress(int index){
  //załącz diodę umieszczoną na przodzie klawiatury
  digitalWrite(LED_PIN, HIGH);
  // pobierz symbol spod konkretnego indeksu
  switch(symbols[index]){
    //wierz 1
    case KEY_NUM:
      Keyboard.write(KEY_ESC);
      break;
    case KEY_DIV:
      Keyboard.write(KEY_PAGE_UP);
      break;
    case KEY_MUL:
      Keyboard.write(KEY_PAGE_DOWN);
      break;
    case KEY_MINUS:
      Keyboard.press(KEY_LEFT_CTRL);
      Keyboard.write(' ');
      Keyboard.releaseAll();
      break;

    //wiersz 2
    case KEY_7:
      Keyboard.write(KEY_F10);
      break;
    case KEY_8:
      Keyboard.write(KEY_F5);
      break;
    case KEY_9:
      Keyboard.press(KEY_LEFT_SHIFT);
      Keyboard.press(KEY_LEFT_ALT);
      Keyboard.write('q');
      Keyboard.releaseAll();
      break;
    case KEY_PLUS:
      Keyboard.press(KEY_LEFT_SHIFT);
      Keyboard.press(KEY_LEFT_ALT);
      Keyboard.write('o');
      Keyboard.releaseAll();
      break;

    //wiersz 3
    case KEY_4:
      Keyboard.write(KEY_F8);
      break;
    case KEY_5:
      Keyboard.press(KEY_LEFT_CTRL);
      Keyboard.write(KEY_PAGE_UP);
      Keyboard.releaseAll();
      break;
    case KEY_6:
      Keyboard.press(KEY_LEFT_SHIFT);
      Keyboard.write(KEY_PAGE_UP);
      Keyboard.releaseAll();
      break;
    case KEY_BACK:
      Keyboard.write(KEY_F9);
      break;

    //wiersz 4,5
    case KEY_1:
      Keyboard.press(KEY_LEFT_CTRL);
      Keyboard.write('q');
      Keyboard.releaseAll();
      break;
    case KEY_2:
      Keyboard.press(KEY_LEFT_CTRL);
      Keyboard.write(KEY_PAGE_DOWN);
      Keyboard.releaseAll();
      break;
    case KEY_3:
      Keyboard.press(KEY_LEFT_SHIFT);
      Keyboard.write(KEY_PAGE_DOWN);
      Keyboard.releaseAll();
      break;
    case KEY_0:
      Keyboard.print(":)");
      break;
    case KEY_DOT:
      Keyboard.press(KEY_LEFT_CTRL);
      Keyboard.write('u');
      Keyboard.releaseAll();
      break;
    case KEY_ENTER:
      Keyboard.write(KEY_ENTER);
      break;
  }

  delay(200);
  digitalWrite(LED_PIN, LOW);
}

// funckja wiążąca symbol z numerami (indeksami w tablicach)
// linii wejścia i wyjścia
void setSymbol(int lineOutput, int lineInput, char symbol){
  // zmienne odpowiedajace indeksom w tablicy dla fizycznych linii
  // wpisanych przez użytkownika.
  int iRow, iColumn;
  
  // odszukaj indeks wiersza czyli lini wyjsc w macierzy
  for(iRow = 0; iRow < MATRIX_SIZE; ++iRow){
    if(OUTPUTS[iRow] == lineOutput)
      break;
  }
  
  // odszukaj indeks kolumny czyli lini wejsc w maciery
  for(iColumn = 0; iColumn < MATRIX_SIZE; ++iColumn){
    if(INPUTS[iColumn] == lineInput)
      break;
  }

  // zapisz symbol w komorce macierzy 1-wymiarowej
  // przy pomocy 2 współrzędnych
  symbols[iRow * MATRIX_SIZE + iColumn] = symbol;
}

// wstępne ustawienia peryferiów i mapowanie przycisków
void setup() {
  //LED
  pinMode(LED_PIN, OUTPUT);
  digitalWrite(LED_PIN, LOW);
  
  for(int i = 0; i < MATRIX_SIZE; ++i){
    pinMode(OUTPUTS[i], OUTPUT);
    digitalWrite(OUTPUTS[i], HIGH);

    //WEJSCIA 
    pinMode(INPUTS[i], INPUT);
    digitalWrite(INPUTS[i], HIGH);
  }

  // domyślnie nie ma żadnych połączeń w klawiaturze
  for(int i = 0; i < MATRIX_SIZE * MATRIX_SIZE; ++i){
    symbols[i] = KEY_NONE;
    states[i] = KEY_RELESED;
  }
  
  // użyj połączeń zdefiniownaych przez użytkownika
  mapKeys();
  Keyboard.begin();
}

// główna pętla w której sprawdzane są kliknięcia
void loop() {
  for(int iOutput = 0; iOutput < MATRIX_SIZE; ++iOutput){
    // aktywuj sprawdzanie wiersza o indeksie iOutput
    digitalWrite(OUTPUTS[iOutput], LOW);
    for(int iInput = 0; iInput < MATRIX_SIZE; ++iInput){
      // oblicz numer indeksu w macierzy wszystkich przycisków
      index = iOutput * MATRIX_SIZE + iInput;
      
      // jeżeli obecny stan jest LOW (przycisk wciśnięty)
      if((digitalRead(INPUTS[iInput]) == LOW)){
        if(states[index] == KEY_RELESED){
          // to wywołaj kliknięcie
          onPress(index);
        }
        // ustaw flagę żeby zadziałał zatrzask
        states[index] = KEY_PRESSED;
      } else if(states[index] == KEY_PRESSED)
        // zresetuj zatrzask w momencie puszczenia przycisku
        states[index] = KEY_RELESED;
    }
    // opuść linię aby przejść do następnej
    digitalWrite(OUTPUTS[iOutput], HIGH);
  }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

#include "Keyboard.h"

// led

#define LED_PIN A2

// liczby

#define MATRIX_SIZE 6

// stany

#define KEY_RELESED 0

#define KEY_PRESSED 1

// klawisze

#define KEY_NONE 'x'

#define KEY_ENTER 'e'

#define KEY_NUM 'n'

#define KEY_BACK 'B'

#define KEY_0 '0'

#define KEY_1 '1'

#define KEY_2 '2'

#define KEY_3 '3'

#define KEY_4 '4'

#define KEY_5 '5'

#define KEY_6 '6'

#define KEY_7 '7'

#define KEY_8 '8'

#define KEY_9 '9'

#define KEY_DOT '.'

#define KEY_PLUS '+'

#define KEY_MINUS '-'

#define KEY_MUL '*'

#define KEY_DIV '/'

// wyjscia - wiersze

#define OUT_LINE_1 15

#define OUT_LINE_2 14

#define OUT_LINE_6 8

#define OUT_LINE_A 7

#define OUT_LINE_B 6

#define OUT_LINE_C 5

const int OUTPUTS[] = {OUT_LINE_1, OUT_LINE_2, OUT_LINE_6, OUT_LINE_A, OUT_LINE_B, OUT_LINE_C};

// wejscia - kolumny

#define IN_LINE_3 16

#define IN_LINE_4 10

#define IN_LINE_5 9

#define IN_LINE_D 4

#define IN_LINE_E 3

#define IN_LINE_F 2

const int INPUTS[] = {IN_LINE_3, IN_LINE_4, IN_LINE_5, IN_LINE_D, IN_LINE_E, IN_LINE_F};

// macierze reprezentujące fizyczne symbole i stan zatrzasku

char symbols[MATRIX_SIZE * MATRIX_SIZE];

int states[MATRIX_SIZE * MATRIX_SIZE];

int index = 0;

// funkcja wewnatrz której definiujemy fizyczne połączenia klawiszy i ich symbole

void mapKeys(){

setSymbol(OUT_LINE_1, IN_LINE_3, KEY_9);

setSymbol(OUT_LINE_1, IN_LINE_4, KEY_3);

setSymbol(OUT_LINE_1, IN_LINE_5, KEY_MUL);

setSymbol(OUT_LINE_1, IN_LINE_D, KEY_6);

setSymbol(OUT_LINE_1, IN_LINE_E, KEY_DOT);

setSymbol(OUT_LINE_1, IN_LINE_F, KEY_MINUS);

setSymbol(OUT_LINE_2, IN_LINE_3, KEY_7);

setSymbol(OUT_LINE_2, IN_LINE_4, KEY_1);

setSymbol(OUT_LINE_2, IN_LINE_D, KEY_4);

setSymbol(OUT_LINE_6, IN_LINE_5, KEY_NUM);

setSymbol(OUT_LINE_A, IN_LINE_3, KEY_PLUS);

setSymbol(OUT_LINE_A, IN_LINE_4, KEY_ENTER);

setSymbol(OUT_LINE_B, IN_LINE_3, KEY_8);

setSymbol(OUT_LINE_B, IN_LINE_4, KEY_2);

setSymbol(OUT_LINE_B, IN_LINE_5, KEY_DIV);

setSymbol(OUT_LINE_B, IN_LINE_D, KEY_5);

setSymbol(OUT_LINE_B, IN_LINE_E, KEY_0);

setSymbol(OUT_LINE_C, IN_LINE_D, KEY_BACK);

}

// funckja w której wyzwalane są zdarzenia od kliknięć fizycznych przycisków

void onPress(int index){

//załącz diodę umieszczoną na przodzie klawiatury

digitalWrite(LED_PIN, HIGH);

// pobierz symbol spod konkretnego indeksu

switch(symbols[index]){

//wierz 1

case KEY_NUM:

Keyboard.write(KEY_ESC);

break;

case KEY_DIV:

Keyboard.write(KEY_PAGE_UP);

break;

case KEY_MUL:

Keyboard.write(KEY_PAGE_DOWN);

break;

case KEY_MINUS:

Keyboard.press(KEY_LEFT_CTRL);

Keyboard.write(' ');

Keyboard.releaseAll();

break;

//wiersz 2

case KEY_7:

Keyboard.write(KEY_F10);

break;

case KEY_8:

Keyboard.write(KEY_F5);

break;

case KEY_9:

Keyboard.press(KEY_LEFT_SHIFT);

Keyboard.press(KEY_LEFT_ALT);

Keyboard.write('q');

Keyboard.releaseAll();

break;

case KEY_PLUS:

Keyboard.press(KEY_LEFT_SHIFT);

Keyboard.press(KEY_LEFT_ALT);

Keyboard.write('o');

Keyboard.releaseAll();

break;

//wiersz 3

case KEY_4:

Keyboard.write(KEY_F8);

break;

case KEY_5:

Keyboard.press(KEY_LEFT_CTRL);

Keyboard.write(KEY_PAGE_UP);

Keyboard.releaseAll();

break;

case KEY_6:

Keyboard.press(KEY_LEFT_SHIFT);

Keyboard.write(KEY_PAGE_UP);

Keyboard.releaseAll();

break;

case KEY_BACK:

Keyboard.write(KEY_F9);

break;

//wiersz 4,5

case KEY_1:

Keyboard.press(KEY_LEFT_CTRL);

Keyboard.write('q');

Keyboard.releaseAll();

break;

case KEY_2:

Keyboard.press(KEY_LEFT_CTRL);

Keyboard.write(KEY_PAGE_DOWN);

Keyboard.releaseAll();

break;

case KEY_3:

Keyboard.press(KEY_LEFT_SHIFT);

Keyboard.write(KEY_PAGE_DOWN);

Keyboard.releaseAll();

break;

case KEY_0:

Keyboard.print(":)");

break;

case KEY_DOT:

Keyboard.press(KEY_LEFT_CTRL);

Keyboard.write('u');

Keyboard.releaseAll();

break;

case KEY_ENTER:

Keyboard.write(KEY_ENTER);

break;

}

delay(200);

digitalWrite(LED_PIN, LOW);

}

// funckja wiążąca symbol z numerami (indeksami w tablicach)

// linii wejścia i wyjścia

void setSymbol(int lineOutput, int lineInput, char symbol){

// zmienne odpowiedajace indeksom w tablicy dla fizycznych linii

// wpisanych przez użytkownika.

int iRow, iColumn;

// odszukaj indeks wiersza czyli lini wyjsc w macierzy

for(iRow = 0; iRow < MATRIX_SIZE; ++iRow){

if(OUTPUTS[iRow] == lineOutput)

break;

}

// odszukaj indeks kolumny czyli lini wejsc w maciery

for(iColumn = 0; iColumn < MATRIX_SIZE; ++iColumn){

if(INPUTS[iColumn] == lineInput)

break;

}

// zapisz symbol w komorce macierzy 1-wymiarowej

// przy pomocy 2 współrzędnych

symbols[iRow * MATRIX_SIZE + iColumn] = symbol;

}

// wstępne ustawienia peryferiów i mapowanie przycisków

void setup() {

//LED

pinMode(LED_PIN, OUTPUT);

digitalWrite(LED_PIN, LOW);

for(int i = 0; i < MATRIX_SIZE; ++i){

pinMode(OUTPUTS[i], OUTPUT);

digitalWrite(OUTPUTS[i], HIGH);

//WEJSCIA

pinMode(INPUTS[i], INPUT);

digitalWrite(INPUTS[i], HIGH);

}

// domyślnie nie ma żadnych połączeń w klawiaturze

for(int i = 0; i < MATRIX_SIZE * MATRIX_SIZE; ++i){

symbols[i] = KEY_NONE;

states[i] = KEY_RELESED;

}

// użyj połączeń zdefiniownaych przez użytkownika

mapKeys();

Keyboard.begin();

}

// główna pętla w której sprawdzane są kliknięcia

void loop() {

for(int iOutput = 0; iOutput < MATRIX_SIZE; ++iOutput){

// aktywuj sprawdzanie wiersza o indeksie iOutput

digitalWrite(OUTPUTS[iOutput], LOW);

for(int iInput = 0; iInput < MATRIX_SIZE; ++iInput){

// oblicz numer indeksu w macierzy wszystkich przycisków

index = iOutput * MATRIX_SIZE + iInput;

// jeżeli obecny stan jest LOW (przycisk wciśnięty)

if((digitalRead(INPUTS[iInput]) == LOW)){

if(states[index] == KEY_RELESED){

// to wywołaj kliknięcie

onPress(index);

}

// ustaw flagę żeby zadziałał zatrzask

states[index] = KEY_PRESSED;

} else if(states[index] == KEY_PRESSED)

// zresetuj zatrzask w momencie puszczenia przycisku

states[index] = KEY_RELESED;

}

// opuść linię aby przejść do następnej

digitalWrite(OUTPUTS[iOutput], HIGH);

}

Podsumowanie

Projekt bardzo praktyczny i ciekawy - polecam każdemu zrobić swoją wersję klawiatury. Warto jednak zastanowić się, czy jest sens przerabiać gotową klawiaturę numeryczną. Zdecydowanie łatwiej byłoby odtworzyć projekt z własnymi, "łatwiej" podłączonymi przyciskami!

Artykuł był ciekawy?

Dołącz do 20 tysięcy osób, które otrzymują powiadomienia o nowych artykułach! Zapisz się, a otrzymasz PDF-y ze ściągami (m.in. na temat mocy, tranzystorów, diod i schematów) oraz listę inspirujących DIY na bazie Arduino i Raspberry Pi.