Handheld Shortcut Controller (pentru Photoshop + Mai multe) [Arduino]: 4 pași

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:44

Ultima dată am creat un mic control pad pentru a-l folosi în Photoshop. A făcut minuni și încă îl folosesc! Dar este, de asemenea, destul de limitat, cu doar cinci butoane și cadrele utile de dimensiuni și opacitate. Încă m-am trezit că mă apuc de tastatură mult …

Așa că am început să lucrez la următoarea iterație a plăcii de control, una cu mai multe butoane și funcționalitate. Un singur pad de control pentru a le conduce pe toate.

Acesta nu este acel pad de control. DAR într-un fel ar putea fi mai bine.

Ce se întâmplă dacă ai putea avea o grămadă de comenzi rapide, dar într-un pachet foarte comod și ușor poți ține cu mâna liberă în timp ce desenezi neîntrerupt? … ok, suficient cu reclamă publicitară.

Acest controler este programat într-un mod care, cu doar 4 butoane, poate fi mapat la până la 32 de comenzi rapide posibile! Al 5-lea buton suplimentar este acolo pentru a-mi permite să folosesc tastele modificatoare în orice combinație, ceea ce este util pentru multe programe (ați încercat vreodată combo-ul Alt-RMB în PS? Dacă nu ați făcut-o, vă rog. Faceți un salvator). Explic sistemul mai târziu.

Pentru a face toate acestea, veți avea nevoie de:

• 1 microcontroler (am folosit un Adafruit ItsyBitsy 32u4 dar oricare ar trebui să facă atâta timp cât are cipul atmega32u4)
• 1 adaptor micro-USB (date, nu numai alimentare)
• 5 butoane (am folosit butoane moi, ca acestea)
• Rezistențe de 10 k Ohm (1 pe buton)
• Sârme, panouri, material de lipit etc.
• Ceva cu care să faci o carcasă (imprimantă 3D etc.)

Acesta este un proiect Arduino de nivel intermediar și vă sugerez să vă uitați la tutorialul meu din trecut pentru a înțelege mai bine ce se întâmplă, întrucât o mare parte din acestea reprezintă o repetare a lucrurilor pe care le-am explicat acolo.

Ok, să începem!

Pasul 1: Planificare

Aceasta este o schemă de bază pe care am desenat-o asupra controlerului. Circuitul este foarte simplu atunci când îl comparați cu proiectul meu anterior! Dar vom putea face mult mai mult cu puținele butoane pe care le are, cu puterea presei combinate!

Ideea din spatele schemei de control este că fiecare buton poate fi liber, apăsat și eliberat, sau apăsat și menținut. Apăsarea și eliberarea este ceea ce va activa de fapt comanda rapidă, în timp ce țineți apăsate butoanele ne va oferi acces la diferite comenzi rapide. Deci, dacă doar apăsați butonul A, veți activa comanda rapidă A, dar dacă țineți apăsat B când apăsați A, veți primi o comandă rapidă diferită. Puteți ține până la 3 butoane simultan în timp ce apăsați, astfel încât atunci când aplicați câteva combinatorii de bază, veți vedea câte combinații sunt posibile cu acest sistem!

Al cincilea buton suplimentar s-a simțit ca un plus natural, având în vedere forma dispozitivului portabil cu care am venit. Am decis să-l folosesc pentru a accesa tastele modificatoare în Photoshop. Modul în care funcționează este ușor diferit de celelalte butoane: ori de câte ori este apăsat butonul degetul mare, vor fi folosiți doar modificatorii. Acestea se vor activa atunci când sunt ținute și mai multe pot fi apăsate. Deci, dacă butonul A este Shift și butonul B este Ctrl, atunci când țineți apăsate A și B, va fi ca și cum ați apăsa Shift și Ctrl, dar numai atât timp cât butonul degetului mare este ținut!

Carcasa este concepută pentru a fi atât ergonomică, cât și ambidextră. Am avut mare grijă să-l încadrez perfect, astfel încât utilizarea degetului mic să nu fie prea obositoare și ar trebui să funcționeze și pentru cei cu mâini mai mari decât ale mele.

Pasul 2: Prototip + Cod

Este o bună practică să testați butoanele de pe o panou de testare. Este destul de simplu, conectați doar butoanele și rezistențele așa cum se arată. Puteți să-l testați cu codul aici (alternativa pastebin link):

#include

// utilizați opțiunea vthisv pentru MacOS:

// char ctrlKey = KEY_LEFT_GUI;

// utilizați opțiunea vthisv pentru Windows și Linux:

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

// Taste funcționale aici

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

const int pins = {9, 10, 11, 12, 13}; // matricea tuturor pinilor butoanelor

//Sensibilitate

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;

// Înghețați cadrele

const int DELAY = 0;

enum State {eliberat, presat, deținut, eliberat};

buton struct {

int pin; State de stat; int timeHeld; }; // thumb, index, mid, ring, little;

butoane butoane [BUTTON_NUM] = {};

buton initButton (int p) {

butonul b; pinMode (p, INPUT); b.pin = p; b.state = State:: eliberat; b.timeHeld = 0; retur b; }

configurare nulă () {

// puneți codul de configurare aici, pentru a rula o dată: Serial.begin (9600); Keyboard.begin ();

while (! Serial) {};

// Butoane pentru (int i = 0; i <(BUTTON_NUM); ++ i) {Serial.print ("buton set"); Serial.print (i); Serial.print ("la pin:"); Serial.println (pinii ); //buttons.pin = 1; butoane = initButton (pinii ); Serial.println (butoane .pin); }

}

bool readButton (pin int) {

// verificați și debonați butoanele dacă (digitalRead (pin) == HIGH) {delay (10); if (digitalRead (pin) == HIGH) {return true; }} returnează fals; }

int pintobin (pin int) {

if (pin == pins [0]) returnează 1; if (pin == pins [1]) returnează 10; if (pin == pins [2]) returnează 100; if (pin == pins [3]) returnează 1000; if (pin == pins [4]) returnează 10000; } buton buttonStateUpdate (butonul b) {

bool press = readButton (b.pin);

switch (b.state) {case State:: eliberat: b.timeHeld = 0; if (apăsați) b.state = State:: apăsat; pauză; majusculă apăsată: b.timeHeld + = 1; if (apăsați) {if (b.timeHeld> (THRESH_1 / (1 + DELAY))) {b.state = States:: held; }} else {// if (b.timeHeld

int getButtonStateCode (butonul b)

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

int getCodeByButton (cod int, index int) {

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

// prima operație

if (opStep == 0) return code / 10000; r1 = cod% 10000;

if (opStep == 1)

retur r1 / 1000; r2 = r1% 1000; if (opStep == 2) returnează r2 / 100; r3 = r2% 100; if (opStep == 3) returnează r3 / 10; r4 = r3% 10; if (opStep == 4) returnează r4 / 1; r5 = r4% 1; }

void completePress (pin int) {

// Serial.print ("intrare"); // Serial.println (pin); întârziere (THRESH_3); Keyboard.releaseAll (); }

void doAction (cod int) {

// Modificatori if (getCodeByButton (code, 0) == 2) {// Serial.println ("--- modificatori ----"); if (getCodeByButton (cod, 1)> 0) {Keyboard.press (altKey); // Serial.println ("------- alt ---------"); } else Keyboard.release (altKey); if (getCodeByButton (code, 2)> 0) {Keyboard.press (ctrlKey); // Serial.println ("-------- ctrl ----------"); } else Keyboard.release (ctrlKey); if (getCodeByButton (cod, 3)> 0) {Keyboard.press (''); } else Keyboard.release (''); if (getCodeByButton (code, 4)> 0) {Keyboard.press (shiftKey); // Serial.println ("------ shift ------"); } else Keyboard.release (shiftKey); } altceva {

// efectua sarcini

comutator (cod) {caz 30: // --- | Brush Keyboard.press (shiftKey); Keyboard.print ('b'); completePress (cod); pauză; cazul 300: // --- | Eraser Keyboard.press (shiftKey); Keyboard.print („e”); completePress (cod); pauză; caz 3000: // --- | Bucket Keyboard.press (shiftKey); Keyboard.print ('g'); completePress (cod); pauză; cazul 30000: // --- | Lasso Keyboard.press (shiftKey); Keyboard.print („l”); completePress (cod); pauză; caz 320: // - | o Undo Keyboard.press (ctrlKey); Keyboard.print ('z'); completePress (cod); pauză; case 3020: // - | -o Redo Keyboard.press (ctrlKey); Keyboard.print („y”); completePress (cod); pauză; case 30020: // | --o History Keyboard.press (shiftKey); Keyboard.print („y”); completePress (cod); pauză; cazul 230: // - o | Salvați Keyboard.press (ctrlKey); Keyboard.print („s”); completePress (cod); pauză; case 3200: // - | o- Quick-p.webp

int buttonCode = 0;

for (int i = 0; i <BUTTON_NUM; ++ i) {buttons = buttonStateUpdate (butoane ); buttonCode + = getButtonStateCode (butoane ); }

if (ButtonCode! = 0) {

Serial.print ("cod buton:"); Serial.println (buttonCode); }

doAction (buttonCode);

// puneți codul principal aici, pentru a rula în mod repetat: // pentru (int i = butoane [0]; i <sizeof (butoane) / sizeof (butoane [0]) + butoane [0]; ++ i) {/ / // if (readButton (i)) {// doAction (i); //} //}

if (getCodeByButton (buttonCode, 0)! = 2)

Keyboard.releaseAll ();

întârziere (întârziere);

}

Nu există multe de spus despre logică, deoarece este similară cu cea a ultimului meu controler, cu două diferențe notabile:

1. Butoanele sunt structuri cu propriile mașini de stare
2. Statele sunt însumate împreună pentru a crea un cod care determină acțiunea

Principiul este similar cu schimbarea de biți, dar deoarece butoanele au mai multe stări și nu pot fi reprezentate pur și simplu cu un binar, ele sunt înmulțite cu puteri de zece. Apoi adun toate stările butoanelor într-un singur număr și îl transmit instrucțiunii de comutare doAction (), unde am pus toate codurile de comenzi rapide.

După cum puteți vedea, nu am cartografiat fiecare combinație posibilă. Am adăugat doar câteva dintre scurtăturile mele preferate, vă las pe voi să completați restul cum vedeți cel mai bine;)

Pasul 3: Carcasa

Am folosit o imprimantă 3D pentru carcasă. După cum puteți vedea, designul are câteva defecte și am avut MacGyver o modalitate de a-l închide. Deci, nu voi posta încă fișierul model încă.

Butoanele sunt lipite la cald pe „bănci”, astfel încât să păstreze capacele la locul lor. Butoanele moi sunt deosebit de bune la acest lucru, așa că asigurați-vă că obțineți unele dintre acestea dacă intenționați să creați o carcasă similară cu a mea.

De asemenea, vă sugerez să adăugați puțină greutate în interiorul carcasei, deoarece este foarte ușor. Gramele suplimentare vor face ca menținerea să se simtă mai naturală.

Lipiți totul așa cum se arată și conectați cablul USB și totul ar trebui să se potrivească la loc (cu ajutorul unui lipici)!

Pasul 4: Rezultat și îmbunătățiri posibile

Iată-l! Un controler portabil pe care îl puteți utiliza pentru a accesa toate comenzile rapide importante cu o singură mână!

Este nevoie de memorie musculară, dar este foarte versatil!

Bineînțeles că nu este perfect și chiar acum mă gândesc la câteva moduri de a-l îmbunătăți. Pe lângă îmbunătățirea carcasei și adăugarea comenzilor rapide, cred că aș fi interesant să susțin mai multe aplicații cu comenzi rapide diferite. Mă gândesc să am o combinație de butoane pentru a comuta între schemele de control, cum ar fi apăsarea a 4 butoane în același timp pentru a comuta între o bibliotecă de comenzi rapide Photoshop la o singură comandă pentru Maya.

Doar câteva idei.

Mulțumesc pentru lectură, până data viitoare!