Handheld Shortcut Controller (para sa Photoshop + Higit Pa) [Arduino]: 4 na Hakbang

2024 May -akda: John Day | [email protected]. Huling binago: 2024-01-30 13:13

Huling oras na lumikha ako ng isang maliit na control pad upang magamit sa Photoshop. Gumana ito ng mga kababalaghan, at ginagamit ko pa rin ito! Ngunit limitado rin ito, na may limang mga pindutan lamang at ang kapaki-pakinabang na laki at mga opacity dial. Natagpuan ko pa rin ang aking sarili na umaabot sa maraming keyboard …

Kaya't nagsimula akong magtrabaho sa susunod na pag-ulit ng control pad, isa na may higit na mga pindutan at pag-andar. Isang control pad upang mamuno sa kanilang lahat.

Hindi ito ang control pad. PERO sa paraang mas mabuti ito.

Paano kung maaari kang magkaroon ng isang toneladang mga shortcut, ngunit sa isang sobrang masikip at magaan na package na maaari mong hawakan gamit ang iyong libreng kamay habang gumuhit ka ng hindi nagagambala? … Ok, sapat na sa infomercial.

Ang controller na ito ay na-program sa isang paraan na, sa pamamagitan lamang ng 4 na mga pindutan, maaari itong ma-map hanggang sa 32 posibleng mga shortcut! Ang karagdagang ika-5 na pindutan ay naroroon upang payagan akong gumamit ng mga modifier key sa anumang kombinasyon, na kapaki-pakinabang para sa maraming mga programa (nasubukan mo ba ang Alt-RMB combo sa PS? Kung hindi mo pa, mangyaring gawin. Ito ay isang tagapagligtas). Ipinapaliwanag ko ang sistema sa paglaon.

Upang magawa ang lahat ng ito kakailanganin mo:

• 1 Microcontroller (Gumamit ako ng isang Adafruit ItsyBitsy 32u4 ngunit ang anumang dapat gawin hangga't mayroon itong chip na atmega32u4)
• 1 micro-USB adapter (data, hindi lamang kapangyarihan)
• 5 push button (Gumamit ako ng malambot, tulad nito)
• 10k Ohm resistors (1 bawat pindutan)
• Mga wire, breadboard, solder material, atbp.
• Isang bagay upang makagawa ng isang pambalot (3D printer, atbp.)

Ito ay isang intermediate-level na proyekto ng Arduino, at iminumungkahi ko na tingnan ang aking nakaraang tutorial upang mas maunawaan kung ano ang nangyayari, dahil ang karamihan sa ito ay isang pag-uulit ng mga bagay na ipinaliwanag ko doon.

Ok, magsimula na tayo!

Hakbang 1: Pagpaplano

Ito ay isang pangunahing eskematiko na iginuhit ko ng taga-kontrol. Ang circuit ay talagang simple kapag ihinahambing mo ito sa aking nakaraang proyekto! Ngunit magagawa natin ang higit pa sa ilang mga pindutan na mayroon ito, na may lakas ng pinagsamang mga pagpindot!

Ang ideya sa likod ng control scheme ay ang bawat pindutan ay maaaring maging libre, pinindot at palabasin, o pinindot at hawakan. Ang pagpindot at paglabas ay kung ano ang aktwal na magpapagana ng shortcut, habang ang pagpindot ng mga pindutan ay magbibigay sa amin ng pag-access sa iba't ibang mga shortcut. Kaya't kung pipindutin mo lang ang pindutan A, i-aaktibo mo ang shortcut A, ngunit kung pipigilin mo ang B kapag pinindot ang A, makakakuha ka ng ibang shortcut. Maaari kang humawak ng hanggang sa 3 mga pindutan nang sabay-sabay habang pinindot, kaya kapag naglapat ka ng ilang pangunahing mga kombinatoriko, makikita mo kung gaano karaming mga kumbinasyon ang posible sa sistemang ito!

Ang labis na ikalimang pindutan ay nadama na isang natural na karagdagan, na ibinigay sa hugis ng handhand na naisip ko. Napagpasyahan kong gamitin ito upang ma-access ang mga key ng modifier sa photoshop. Ang paraan ng paggana nito ay bahagyang naiiba mula sa iba pang mga pindutan: tuwing hinahawakan ang pindutan ng hinlalaki, mga modifier lamang ang gagamitin. Ang mga ito ay buhayin kapag sila ay gaganapin at maramihang maaaring pinindot. Kaya't kung ang pindutan A ay Shift, at ang pindutang B ay Ctrl, kapag pinipigilan mo ang A at B ito ay magiging tulad ng pagpindot sa parehong Shift at Ctrl, ngunit hanggang sa gaganapin ang pindutan ng hinlalaki!

Ang shell ay dinisenyo upang maging parehong ergonomic at ambidextrous. Pinag-alagaan kong mabuti upang magkasya ito nang maayos upang ang paggamit ng maliit na daliri ay hindi masyadong nakakapagod, at dapat itong gumana para sa mga may mga kamay na mas malaki kaysa sa akin din.

Hakbang 2: Prototype + Code

Mahusay na kasanayan upang subukan ang mga pindutan sa isang breadboard. Ito ay medyo simple, ikonekta lamang ang mga pindutan at resistors tulad ng ipinakita. Maaari mong subukan ito gamit ang code dito (alternatibong link ng pastebin):

# isama

// use vthisv options for MacOS:

// char ctrlKey = KEY_LEFT_GUI;

// use vthisv options for Windows and Linux:

char ctrlKey = KEY_LEFT_CTRL; char shiftKey = KEY_LEFT_SHIFT; char altKey = KEY_LEFT_ALT;

// Function Keys dito

char Fn1Key = KEY_F2; char Fn2Key = KEY_F3; char Fn3Key = KEY_F4; char Fn4Key = KEY_F5;

const int pins = {9, 10, 11, 12, 13}; // array ng lahat ng mga pindutan ng pindutan

// Sensitidad

Const int THRESH_0 = 10; const int THRESH_1 = 20; const int THRESH_2 = 25; const int THRESH_3 = 50; const int THRESH_4 = 100; const int THRESH_5 = 200;

const int BUTTON_NUM = 5;

// Freeze frame

const int PANAHON = 0;

enum States {napalaya, pinindot, hinawakan, pinakawalan};

pindutan ng struct {

int pin; Estado ng estado; int timeHeld; }; // thumb, index, mid, ring, maliit;

mga pindutan ng pindutan [BUTTON_NUM] = {};

button init Button (int p) {

pindutan b; pinMode (p, INPUT); b.pin = p; b.state = States:: napalaya; b.timeHeld = 0; bumalik b; }

walang bisa ang pag-setup () {

// ilagay ang iyong setup code dito, upang tumakbo nang isang beses: Serial.begin (9600); Keyboard.begin ();

habang (! Serial) {};

// Buttons for (int i = 0; i <(BUTTON_NUM); ++ i) {Serial.print ("set button"); Serial.print (i); Serial.print ("at pin:"); Serial.println (mga pin ); //buttons[iiwan.pin = 1; mga pindutan = init Button (mga pin ); Serial.println (mga pindutan .pin); }

}

bool read Button (int pin) {

// check and debounce pindutan kung (digitalRead (pin) == TAAS) {pagkaantala (10); kung (digitalRead (pin) == MATAAS) {return true; }} bumalik na hindi totoo; }

int pintobin (int pin) {

kung (pin == pin [0]) ibalik ang 1; kung (pin == pin [1]) ibalik ang 10; kung (pin == pin [2]) ibalik ang 100; kung (pin == pin [3]) ibalik ang 1000; kung (pin == pin [4]) ibalik ang 10000; } button buttonStateUpdate (button b) {

bool press = read Button (b.pin);

switch (b.state) {case States:: freed: b.timeHeld = 0; kung (pindutin) b.state = States:: pinindot; pahinga; pinindot ang kaso: b.timeHeld + = 1; kung (pindutin) {kung (b.timeHeld> (THRESH_1 / (1 + TANGGOL))) {b.state = States:: gaganapin; }} iba pa {// kung (b.timeHeld

int get ButtonStateCode (pindutan b)

{return b.state * pintobin (b.pin); }

int getCodeBy Button (int code, int index) {

int r1, r2, r3, r4, r5; int opStep = BUTTON_NUM - (1 + index);

// unang operasyon

kung (opStep == 0) ibalik ang code / 10000; r1 = code% 10000;

kung (opStep == 1)

ibalik ang r1 / 1000; r2 = r1% 1000; kung (opStep == 2) ibalik ang r2 / 100; r3 = r2% 100; kung (opStep == 3) ibalik ang r3 / 10; r4 = r3% 10; kung (opStep == 4) ibalik ang r4 / 1; r5 = r4% 1; }

void completePress (int pin) {

// Serial.print ("input"); // Serial.println (pin); antala (THRESH_3); Keyboard.releaseAll (); }

void doAction (int code) {

// Modifiers if (getCodeBy Button (code, 0) == 2) {// Serial.println ("--- modifiers ----"); kung (getCodeBy Button (code, 1)> 0) {Keyboard.press (altKey); // Serial.println ("------- alt ---------"); } iba pa Keyboard.release (altKey); kung (getCodeBy Button (code, 2)> 0) {Keyboard.press (ctrlKey); // Serial.println ("-------- ctrl ----------"); } iba pa Keyboard.release (ctrlKey); kung (getCodeBy Button (code, 3)> 0) {Keyboard.press (''); } iba pa Keyboard.release (''); kung (getCodeBy Button (code, 4)> 0) {Keyboard.press (shiftKey); // Serial.println ("------ shift ------"); } iba pa Keyboard.release (shiftKey); } iba pa {

// gampanan ang mga gawain

switch (code) {case 30: // --- | Brush Keyboard.press (shiftKey); Keyboard.print ('b'); completePress (code); pahinga; kaso 300: // --- | Eraser Keyboard.press (shiftKey); Keyboard.print ('e'); completePress (code); pahinga; kaso 3000: // --- | Bucket Keyboard.press (shiftKey); Keyboard.print ('g'); completePress (code); pahinga; kaso 30000: // --- | Lasso Keyboard.press (shiftKey); Keyboard.print ('l'); completePress (code); pahinga; kaso 320: // - | o I-undo ang Keyboard.press (ctrlKey); Keyboard.print ('z'); completePress (code); pahinga; kaso 3020: // - | -o Redo Keyboard.press (ctrlKey); Keyboard.print ('y'); completePress (code); pahinga; kaso 30020: // | --o History Keyboard.press (shiftKey); Keyboard.print ('y'); completePress (code); pahinga; kaso 230: // - o | I-save ang Keyboard.press (ctrlKey); Keyboard.print ('s'); completePress (code); pahinga; kaso 3200: // - | o- Mabilis na-p.webp

int buttonCode = 0;

para sa (int i = 0; i <BUTTON_NUM; ++ i) {mga pindutan = buttonStateUpdate (mga pindutan ); buttonCode + = getButtonStateCode (mga pindutan ); }

kung (buttonCode! = 0) {

Serial.print ("button code:"); Serial.println (buttonCode); }

doAction (buttonCode);

// ilagay ang iyong pangunahing code dito, upang tumakbo nang paulit-ulit: // para (int i = mga pindutan [0]; i <sizeof (mga pindutan) / sizeof (mga pindutan [0]) + mga pindutan [0]; ++ i) {/ / // kung (read Button (i)) {// doAction (i); //} //}

kung (getCodeBy Button (buttonCode, 0)! = 2)

Keyboard.releaseAll ();

antala (PANAHIMAN);

}

Walang masasabi tungkol sa lohika dahil katulad ito sa aking huling tagakontrol, na may dalawang kapansin-pansin na pagkakaiba:

1. Ang mga pindutan ay struct gamit ang kanilang sariling mga machine ng estado
2. Ang mga estado ay pinagsama-sama upang makagawa ng isang code na tumutukoy sa pagkilos

Ang prinsipyo ay katulad ng bit-shifting, ngunit dahil ang mga pindutan ay may maraming mga estado at hindi maaaring kumatawan sa isang binary, pinarami ng mga kapangyarihan na sampu sa halip. Pagkatapos ay idinagdag ko ang lahat ng mga estado ng pindutan sa isang solong numero, at ipinapasa ito sa doAction () switch statement, kung saan ko inilagay ang lahat ng mga code ng shortcuts.

Tulad ng nakikita mo, hindi ko na-map ang bawat posibleng pagsasama. Nagdagdag lamang ako ng ilan sa aking mga paboritong mga shortcut, ipinauubaya ko sa iyo upang punan ang natitirang kung paano mo nakikita na akma;)

Hakbang 3: Ang Casing

Gumamit ako ng isang 3D printer para sa pambalot. Tulad ng nakikita mo, ang disenyo ay may ilang mga pagkukulang at kailangan kong MacGyver isang paraan upang isara lamang ito. Kaya hindi ko pa mai-post ang modelo ng file.

Ang mga pindutan ay mainit na nakadikit sa "mga bangko" upang mapanatili ang mga takip sa lugar. Ang mga malambot na pushbutton ay lalong mabuti sa mga iyon, kaya siguraduhing makakuha ng ilan sa mga iyon kung balak mong gumawa ng kaso na katulad sa minahan.

Gayundin, iminumungkahi ko na magdagdag ng isang maliit na timbang sa loob ng kaso, dahil ito ay napakagaan. Ang sobrang gramo ay gagawing mas natural ang paghawak nito.

Maghinang ng lahat ng tulad ng ipinakita at ikonekta ang usb cable, at lahat ay dapat magkasya sa lugar (sa tulong ng ilang pandikit)!

Hakbang 4: Resulta at Posibleng Mga Pagpapabuti

Ayan! Ang isang handheld controller na maaari mong gamitin upang ma-access ang lahat ng iyong mahahalagang mga shortcut sa isang kamay lamang!

Tumatagal ang ilang memorya ng kalamnan upang magamit, ngunit talagang maraming nalalaman!

Siyempre hindi ito perpekto, at sa ngayon ay iniisip ko ang ilang mga paraan upang mapabuti ito. Bukod sa pagpapabuti ng pambalot at pagdaragdag ng mga shortcut, sa palagay ko magiging kawili-wili akong suportahan ang maraming mga application na may iba't ibang mga shortcut. Iniisip kong magkaroon ng isang kumbinasyon ng pindutan upang lumipat sa pagitan ng mga scheme ng kontrol, tulad ng pagpindot sa 4 na mga pindutan nang sabay-sabay upang lumipat sa pagitan ng isang library ng shortcut sa Photoshop sa isang-pinasadya na ginawa para sa Maya.

Ilang ideya lang.

Salamat sa pagbabasa, hanggang sa susunod!