Mini Control Pad pentru Photoshop (Arduino): 6 pași

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

Iată, vă voi arăta cum să creați un mic instrument pentru a vă ajuta să lucrați mai rapid în Photoshop!

Tastaturile special create pentru PS nu sunt noi, dar nu oferă exact ceea ce am nevoie. Ca pictor, o mare parte din timpul meu în Photoshop îl petrec ajustând setarea pensulei și cred că butoanele de comenzi rapide simple nu îmi oferă controlul pentru a se potrivi cu fluxul meu de lucru. Așa că am decis să-mi creez propria tastatură, una care este mică, discretă și are cadrane care să-mi ofere acea interacțiune analogică pe care mi-am dorit-o întotdeauna.

Modul în care funcționează este simplu: pentru a face microcontrolerul să interacționeze cu Photoshop, profităm de comenzile rapide implicite. Cu o placă pe care computerul o poate citi sub formă de tastatură / mouse, tot ce trebuie să facem este să folosim câteva linii simple de cod pentru a spune computerului să citească fiecare intrare ca o combinație de apăsări de taste. Acum, butonul de anulare este doar o apăsare de buton!

Să începem! Pentru acest proiect veți avea nevoie de:

• 1 Sparkfun ProMicro (sau un Arduino Leonardo, nerecomandat)
• 1 adaptor micro-USB
• 6 butoane (sau orice număr doriți)
• Rezistențe de 10 k Ohm (1 pentru fiecare buton)
• 1 potențiometru
• 1 codificator rotativ
• fire, panou, panou, lipit, știfturi etc.

Puteți utiliza un Arduino Leonardo pentru acest proiect, dar ProMicro este o alternativă mult mai ieftină care folosește același cip atmega32u4, are mai mulți pini și vine într-o formă mult mai mică, făcându-l perfect pentru o tastatură.

Pentru a programa ProMicro în Arduino IDE, poate fi necesar să configurați mai întâi câteva lucruri. Puteți citi mai multe despre aceasta în ghidul SparkFun:

În cazul în care computerul dvs. întâmpină probleme la găsirea dispozitivului, asigurați-vă că micro-USB-ul pe care îl utilizați nu este numai de alimentare și acceptă transferul de date.

Acesta este primul meu proiect Arduino și este potrivit pentru începători.

Pasul 1: Prototiparea blocului de control

Vă recomandăm să testați mai întâi programul pe o placă de calcul înainte de a începe să lipiți.

Aici puteți vedea schema mea.

Butoanele 1 și 2 vor fi Anulați și Refaceți, 3 până la 5 sunt pentru instrumentele Pensulă, Ștergere și Lasso, butonul 6 este un buton de salvare rapidă. Codificatorul și potmetrul controlează dimensiunea și respectiv opacitatea.

Rețineți că sunt stângaci și am proiectat aspectul în modul cel mai confortabil pentru mine. Vedeți momentul în care vă folosiți panoul de testare ca o oportunitate de a vă gândi la ce funcții doriți să aibă controlerul dvs., ce funcționează cel mai bine pentru dvs. și, în cele din urmă, dacă veți avea nevoie de piese suplimentare pentru realizarea acestuia.

Pasul 2: Apăsați butoanele

Butoanele sunt cele mai simple de implementat. Să aruncăm o privire asupra codului:

#include

butoane const int = {2, 3, 4, 5, 6, 7, 8, 9}; // matricea tuturor pinilor butonului char ctrlKey = KEY_LEFT_GUI; // utilizați această opțiune pentru Windows și Linux: // char ctrlKey = KEY_LEFT_CTRL; char shiftKey = KEY_LEFT_SHIFT; char altKey = KEY_LEFT_ALT; void setup () {// puneți codul de configurare aici, pentru a rula o dată: Serial.begin (9600); Keyboard.begin (); // Butoane - parcurgeți matricea și verificați dacă există apăsări pentru (int i = butoane [0]; i <(sizeof (butoane) / sizeof (butoane [0])) + butoane [0]; ++ i) { pinMode (i, INPUT); }} boolean readButton (pin int) {// butoane de verificare și debounce dacă (digitalRead (pin) == HIGH) {delay (10); if (digitalRead (pin) == HIGH) {return true; }} returnează fals; } void doAction (pin int) {// efectuați comutatorul de sarcini (pin) {// ---- Comenzi rapide ---- // Anulați cazul 4: Keyboard.press (ctrlKey); Keyboard.print ('z'); Serial.print („intrare”); Serial.println (pin); întârziere (200); Keyboard.releaseAll (); pauză; // Refaceți cazul 5: Keyboard.press (ctrlKey); Keyboard.print („y”); Serial.print („intrare”); Serial.println (pin); întârziere (200); Keyboard.releaseAll (); pauză; // Carcasă perie 6: Keyboard.press ('b'); Serial.print („intrare”); Serial.println (pin); întârziere (200); Keyboard.releaseAll (); pauză; // Cazul Eraser 7: Keyboard.press ('e'); Serial.print („intrare”); Serial.println (pin); întârziere (200); Keyboard.releaseAll (); pauză; // Lasso case 8: Keyboard.press ('l'); Serial.print („intrare”); Serial.println (pin); întârziere (200); Keyboard.releaseAll (); pauză; // Salvează cazul 9: Keyboard.press (ctrlKey); Keyboard.print („s”); Serial.print („intrare”); Serial.println (pin); întârziere (200); Keyboard.releaseAll (); pauză; implicit: Keyboard.releaseAll (); pauză; }}

bucla nulă () {

// puneți codul principal aici, pentru a rula în mod repetat:

for (int i = butoane [0]; i <sizeof (butoane) / sizeof (butoane [0]) + butoane [0]; ++ i) {if (readButton (i)) {doAction (i); }} // Resetați modificatorii Keyboard.releaseAll ();

}

Sunt destul de simple. Pentru ca computerul să recunoască apăsarea unui buton ca apăsare pe tastă, folosim pur și simplu funcția Keyboard.press (). Deci, pentru a activa comanda rapidă Undo (ctrl + z), folosim pur și simplu Keyboard.press (ctrlKey) și apoi Keyboard.press ('z'). Amintiți-vă că va trebui să includeți Keyboard.h și să inițializați tastatura pentru a accesa aceste funcții.

Pinii de intrare sunt stocați într-o matrice, astfel încât să puteți parcurge cu ușurință toate în funcția loop (). O modalitate ușoară de a accesa și lungimea matricei în c ++ prin împărțirea dimensiunii întregii matrice la elementul matricei, plus un element. Parcurgem toate butoanele pentru a verifica dacă unul a fost apăsat.

Pentru a menține lucrurile organizate, am stocat toate acțiunile butonului meu în instrucțiunea de comutare a unei funcții care ia drept cod numărul pinului.

Dacă doriți ca butoanele dvs. să facă diferite lucruri sau doriți să adăugați mai multe butoane, pur și simplu editați conținutul funcției doAction!

Datorită modului în care funcționează butoanele fizice, va trebui să le denunțăm. Aceasta pentru a împiedica programul să citească orice presă nedorită cauzată de elasticitatea butoanelor. Există multe modalități de a face acest lucru, dar am adăugat o funcție simplă readButton () care se ocupă de asta.

Doar conectați-vă butoanele cu câteva rezistențe de 10k și ar trebui să fiți aurii!

Pasul 3: Potențiometrul

Acum pe potometru:

#include

int dial0 = 0; void setup () {// puneți codul de configurare aici, pentru a rula o dată: Serial.begin (9600); Keyboard.begin (); // Dialuri dial0 = analogRead (0); dial0 = hartă (dial0, 0, 1023, 1, 20); } void dialAction (int dial, int newVal, int lastVal) {switch (dial) {// Caz opacitate 0: întârziere (200); if (newVal! = lastVal) {int decim = ((newVal * 5) / 10); int unit = ((newVal * 5)% 10); if (newVal == 20) {Keyboard.write (48 + 0); Keyboard.write (48 + 0); Serial.println („apel maxim 1”); } else {decim = constrain (decim, 0, 9); unitate = constrângere (unitate, 0, 9); Serial.println (newVal * 2); Keyboard.write (48 + decim); Keyboard.write (48 + unitate); }} dial0 = newVal; pauză; implicit: pauză; }} // ------------------ MAIN LOOP ------------------------- nul loop () {// puneți codul principal aici, pentru a rula în mod repetat: // Opacitate // delay (500); int val0 = analogRead (0); val0 = hartă (val0, 0, 1023, 1, 20); //Serial.print ("dial0:"); //Serial.println(val0); if (val0! = dial0) {// Fă ceva dialAction (0, val0, dial0); }}

Potmetrul urmează aceeași logică, dar este puțin mai complicat.

Mai întâi să vedem cum vrem să funcționeze: Photoshop are câteva comenzi rapide la îndemână pentru a schimba opacitatea unei pensule. Dacă apăsați orice tastă num, opacitatea va fi egală cu numărul * 10. Dar dacă apăsați două numere, acesta va citi al doilea număr ca unitate, oferindu-vă un control mai precis.

Deci, vrem ca potmetrul nostru să mapeze rotația la un procent, dar nu vrem să o facem tot timpul, deoarece ar fi o prostie. Vrem să schimbăm opacitatea doar atunci când potometrul este rotit. Deci stocăm o valoare suplimentară pe care o comparăm cu valoarea analogRead () și executăm scriptul de acțiune numai atunci când există o diferență.

O altă problemă pe care o vom întâlni este modul în care transformăm revenirea analogRead ca intrare. Deoarece nu există o modalitate ușoară de a transforma un int într-un șir, va trebui să folosim int-ul în sine. Cu toate acestea, dacă pur și simplu scrieți Keyboard.press (int), veți observa că intrarea nu va fi ceea ce doriți și, în schimb, o altă tastă va fi apăsată.

Acest lucru se datorează faptului că tastele tastaturii dvs. sunt toate codificate ca numere întregi, fiecare tastă având propriul index. Pentru a utiliza corect cheia num, va trebui să căutați indexul în tabelul ASCII:

După cum puteți vedea, tastele num încep de la indexul 48. Deci, pentru a apăsa tasta corectă, tot ce va trebui să facem este să adăugăm valoarea cadranului la 48. Valorile zecimale și unitare sunt apăsări separate.

În cele din urmă, avem nevoie de o modalitate de a împiedica valoarea să sară înainte și înapoi. Deoarece dacă încercați să utilizați cadranul cu hartă (val0, 0, 1023, 0, 100), veți găsi rezultatele foarte nervoase. În mod similar cu modul în care am respins butoanele, vom remedia acest lucru sacrificând o parte din acuratețe. Am constatat că maparea acestuia la 1-20 și apoi multiplicarea valorii argumentelor cu 5 pentru a fi un compromis acceptabil.

Pentru a conecta potențiometrul, conectați doar un fir de 5V, un fir de împământare și un cablu de intrare analogic și nu ar trebui să existe probleme.

Fapt amuzant: dacă utilizați această comandă rapidă în timp ce este selectat un instrument precum Lasso, acesta va schimba opacitatea stratului. Ceva de luat în seamă.

Pasul 4: Codificatorul rotativ

Codificatoarele rotative seamănă puțin cu potențiometrele, dar fără o limită la cât de mult pot roti. În loc de o valoare analogică, ne vom uita la direcția de cotire a codificatorului digital. Nu voi intra în prea multe detalii despre modul în care funcționează acestea, dar ceea ce trebuie să știți este că folosește doi pini de intrare pe arduino pentru a spune în ce direcție este rotit. Codificatorul rotativ poate fi mai dificil de utilizat, diferite codificatoare ar putea necesita configurări diferite. Pentru a face lucrurile mai ușoare, am cumpărat unul cu PCB, care sunt gata să fie agățat cu știfturi de sex feminin. Acum, codul:

#include

// Codificator rotativ #define outputA 15 #define outputB 14 int counter = 0; int aStat; int aLastState; void setup () {// puneți codul de configurare aici, pentru a rula o dată: // Rotary pinMode (outputA, INPUT); pinMode (outputB, INPUT); // Citește starea inițială a outputA aLastState = digitalRead (outputA); } void rotaryAction (int dir) {if (dir> 0) {Keyboard.press (']'); } else {Keyboard.press ('['); } Keyboard.releaseAll (); } // ------------------ MAIN LOOP ------------------------- bucla nulă () {// puneți codul principal aici, pentru a rula în mod repetat: // Dimensiune aState = digitalRead (outputA); if (aState! = aLastState) {if (digitalRead (outputB)! = aState) {// counter ++; rotaryAction (1); } else {// counter -; rotaryAction (-1); } //Serial.print("Position: "); //Serial.println(counter); } aLastState = aState; }

În mod implicit, Photoshop] și [comenzile rapide cresc și reduc dimensiunea pensulei. La fel ca înainte, vrem să le introducem ca apăsări de taste. Codificatorul trimite un număr de intrări pe rând (care depinde de model) și dorim să mărim / micșorăm dimensiunea pensulei pentru fiecare dintre aceste intrări, astfel încât să puteți roti cadranul în sus sau în jos foarte repede, dar și să puteți controlează-l încet cu mare precizie.

La fel ca în cazul potmetrului, vrem să rulăm acțiunea numai când cadranul este rotit. Spre deosebire de potmetru, așa cum am explicat anterior, codificatorul rotativ are două intrări alternative. Ne uităm la care dintre acestea s-a schimbat pentru a stabili direcția în care este rotit cadranul.

Apoi, în funcție de direcție, apăsăm tasta corectă.

Atâta timp cât nu aveți probleme de contact, ar trebui să funcționeze.

Pasul 5: Puneți totul împreună

Acum la lipire. Mai întâi, găurim două găuri în panoul de perfecționare pentru a se potrivi celor două cadrane. am lipit butoanele și rezistențele lor respective. Am forat două găuri mici pentru a lăsa firele de intrare să treacă deasupra pentru a economisi spațiu dedesubt, dar acest lucru nu este necesar. Nu există prea multe fire de intrare, astfel încât firele GND și 5V rulează în paralel, dar dacă vă simțiți viclean, ați putea dori să creați o matrice. Am lipit microcontrolerul pe o altă placă de perfecționare mai mică, care se potrivea dedesubt alături de codificator și potmetru. Acum am lipit toate firele către ProMicro. Nu este nevoie să fii creativ, ci doar a trebuit să urmez aceeași schemă ca cea de pe panou, dar lipirea într-un loc atât de mic poate înțeles să fie plictisitoare. Nu fi ca mine, folosește un decofrător și o lipire bună!

În cele din urmă, ați putea dori să creați un caz frumos pentru noul dvs. prieten Photoshop. Una mai bună decât a mea, cel puțin!

Dar dacă sunteți dornici să-l încercați, utilizați niște carton și bandă și conectați-vă micro-USB-ul.

Pasul 6: Cod + demonstrație

Asigurați-vă că testați programul plăcii de control pe măsură ce vă deplasați în proiect pentru a evita surprize!

Iată codul complet:

Vă mulțumesc mult pentru lectură!