Handheld Shortcut Controller (voor Photoshop + More) [Arduino] - Ajarnpa

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:17

De laatste keer dat ik een klein bedieningspaneel heb gemaakt om in Photoshop te gebruiken. Het deed wonderen en ik gebruik het nog steeds! Maar het is ook vrij beperkt, met slechts vijf knoppen en het handige formaat en de ondoorzichtigheid. Ik merkte dat ik nog steeds veel naar het toetsenbord reikte …

Dus begon ik te werken aan de volgende iteratie van het bedieningspaneel, een met veel meer knoppen en functionaliteit. Eén bedieningspaneel om ze allemaal te besturen.

Dit is niet dat bedieningspaneel. MAAR in zekere zin is het misschien beter.

Wat als je een heleboel snelkoppelingen zou kunnen hebben, maar in een super knus en lichtgewicht pakket dat je met je vrije hand kunt vasthouden terwijl je ononderbroken tekent? …ok, genoeg met de infomercial.

Deze controller is zo geprogrammeerd dat hij met slechts 4 knoppen kan worden toegewezen aan maximaal 32 mogelijke snelkoppelingen! De extra 5e knop is er zodat ik modificatietoetsen in elke combinatie kan gebruiken, wat handig is voor veel programma's (heb je ooit de Alt-RMB-combo in PS geprobeerd? Als je dat nog niet hebt gedaan, doe dat dan alsjeblieft. Het is een redder in nood). Ik leg het systeem later uit.

Om dit allemaal te maken heb je nodig:

• 1 Microcontroller (ik gebruikte een Adafruit ItsyBitsy 32u4, maar elke zou moeten doen zolang het de atmega32u4-chip heeft)
• 1 micro-USB-adapter (data, niet alleen stroom)
• 5 drukknoppen (ik gebruikte zachte, zoals deze)
• 10k Ohm weerstanden (1 per knop)
• Draden, breadboard, soldeermateriaal, enz.
• Iets om een behuizing mee te maken (3D-printer, etc.)

Dit is een Arduino-project op gemiddeld niveau en ik raad aan om naar mijn eerdere tutorial te kijken om beter te begrijpen wat er aan de hand is, omdat veel hiervan een herhaling is van de dingen die ik daar heb uitgelegd.

Oké, laten we beginnen!

Stap 1: Plannen

Dit is een basisschema dat ik van de controller heb getekend. Het circuit is heel eenvoudig als je het vergelijkt met mijn vorige project! Maar we zullen veel meer kunnen doen met de weinige knoppen die het heeft, met de kracht van gecombineerde persen!

Het idee achter het bedieningsschema is dat elke knop vrij, ingedrukt en losgelaten of ingedrukt en vastgehouden kan worden. Indrukken en loslaten is wat de snelkoppeling daadwerkelijk activeert, terwijl het ingedrukt houden van knoppen ons toegang geeft tot verschillende snelkoppelingen. Dus als je gewoon op knop A drukt, activeer je snelkoppeling A, maar als je B ingedrukt houdt terwijl je op A drukt, krijg je een andere snelkoppeling. Je kunt maximaal 3 knoppen tegelijk ingedrukt houden, dus als je wat basiscombinatoriek toepast, zul je zien hoeveel combinaties er mogelijk zijn met dit systeem!

De extra vijfde knop voelde als een natuurlijke toevoeging, gezien de vorm van de handheld die ik bedacht. Ik besloot het te gebruiken om toegang te krijgen tot modificatietoetsen in photoshop. De manier waarop het werkt, verschilt enigszins van de andere knoppen: wanneer de duimknop wordt ingedrukt, worden alleen modifiers gebruikt. Deze worden geactiveerd wanneer ze worden vastgehouden en meerdere kunnen worden ingedrukt. Dus als knop A Shift is en knop B Ctrl, dan is het alsof je zowel Shift als Ctrl ingedrukt houdt als je A en B ingedrukt houdt, maar alleen zolang als de duimknop wordt ingedrukt!

De schaal is ontworpen om zowel ergonomisch als tweehandig te zijn. Ik heb er alles aan gedaan om het goed passend te maken, zodat het gebruik van de pink niet te vermoeiend is, en het zou ook moeten werken voor mensen met grotere handen dan de mijne.

Stap 2: Prototype + code

Het is een goede gewoonte om de knoppen op een breadboard te testen. Het is vrij eenvoudig, sluit gewoon de knoppen en weerstanden aan zoals weergegeven. Je kunt het testen met de code hier (alternatief voor pastebin-link):

#erbij betrekken

// gebruik de vthisv-optie voor MacOS:

//char ctrlKey = KEY_LEFT_GUI;

// gebruik de vthisv-optie voor Windows en Linux:

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

// Functietoetsen hier

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

const int pinnen = {9, 10, 11, 12, 13}; // array van alle knoppinnen

//Gevoeligheid

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;

//Frames bevriezen

const int VERTRAGING = 0;

enum Staten {vrijgemaakt, ingedrukt, vastgehouden, vrijgegeven};

struct knop {

int-pin; Staten staat; int tijdHeld; }; //duim, index, midden, ring, klein;

knopknoppen [BUTTON_NUM] = {};

knop initKnop(int p) {

knop b; pinMode (p, INPUT); b.pin = p; b.state = Staten::bevrijd; b.tijdHeld = 0; retour b; }

ongeldige setup() {

// plaats hier uw setup-code om een keer uit te voeren: Serial.begin (9600); Toetsenbord.begin();

while(!Serial){};

// Knoppen voor (int i = 0; i < (BUTTON_NUM); ++i) { Serial.print ("knop instellen"); Serial.print(i); Serial.print(" bij pin: "); Serial.println(pinnen); //knoppen .pin = 1; buttons=initButton(pinnen); Serial.println(knoppen.pin); }

}

bool readButton(int pin) {

// controleer en debounce-knoppen als (digitalRead (pin) == HOOG) {vertraging (10); if (digitalRead(pin) == HIGH) { return true; } } retourneer onwaar; }

int pintobin(int pin) {

if (pin==pins[0]) retourneert 1; if (pin== pinnen[1]) retourneer 10; if (pin== pinnen[2]) retourneer 100; if (pin== pinnen[3]) retourneer 1000; if (pin== pinnen[4]) retourneer 10000; } knop buttonStateUpdate(knop b) {

bool druk = readButton(b.pin);

switch (b.state) { case States::freed: b.timeHeld=0; if (druk op) b.state=Staten::ingedrukt; pauze; case ingedrukt: b.timeHeld+=1; if (druk op) { if (b.timeHeld>(THRESH_1/(1+DELAY))) { b.state=Staten::held; } } else { //if (b.timeHeld

int getButtonStateCode(knop b)

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

int getCodeByButton(int code, int index) {

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

//eerste operatie

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

if (opStep==1)

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

leegte compleetDruk (int pin) {

// Serial.print ("invoer"); // Serieel.println (pin); vertraging (THRESH_3); Toetsenbord.releaseAll(); }

void doAction(int code) {

//Modifiers if (getCodeByButton(code, 0)==2) { // Serial.println("---modifiers----"); if (getCodeByButton(code, 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(code, 3)>0) { Keyboard.press(' '); } else Toetsenbord.release(' '); if (getCodeByButton(code, 4)>0) { Keyboard.press(shiftKey); // Serial.println ("------shift------"); } else Keyboard.release(shiftKey); } anders {

// taken uitvoeren

schakelaar (code) { geval 30: //---| Borstel Toetsenbord.press (shiftKey); Toetsenbord.print('b'); compleetPers(code); pauze; geval 300: //---| Eraser Keyboard.press (shiftKey); Toetsenbord.print('e'); compleetPers(code); pauze; geval 3000: //---| Emmer Toetsenbord.press(shiftKey); Toetsenbord.print('g'); compleetPers(code); pauze; geval 30000: //---| Lasso-toetsenbord.press(shiftKey); Toetsenbord.print('l'); compleetPers(code); pauze; case 320: //--|o Toetsenbord ongedaan maken.press(ctrlKey); Toetsenbord.print('z'); compleetPers(code); pauze; case 3020: //-|-o Toetsenbord opnieuw uitvoeren.press(ctrlKey); Toetsenbord.print('y'); compleetPers(code); pauze; case 30020: //|--o Geschiedenis Keyboard.press(shiftKey); Toetsenbord.print('y'); compleetPers(code); pauze; geval 230: //--o| Bewaar Keyboard.press(ctrlKey); Toetsenbord.print('s'); compleetPers(code); pauze; case 3200: //-|o- Snel PNG-toetsenbord.press(shiftKey); Toetsenbord.press(ctrlKey); Toetsenbord.print('\''); compleetPers(code); pauze; geval 22230: //ooo| Fn1 Toetsenbord.druk (Fn1Key); compleetPers(code); pauze; case 22320: //oo|o Fn2 Keyboard.press(Fn2Key); compleetPers(code); pauze; case 23220: //0|00 Fn3 Keyboard.press(Fn3Key); compleetPers(code); pauze; case 32220: //|ooo Fn4 Keyboard.press (Fn4Key); compleetPers(code); pauze; } } } int f = 0; //------------------ HOOFDLUS------------------------- ongeldige lus () {

int knopCode=0;

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

if(buttonCode!=0) {

Serial.print("knopcode: "); Serial.println(buttonCode); }

doAction(knopCode);

// plaats hier je hoofdcode om herhaaldelijk uit te voeren: // for(int i = buttons[0]; i < sizeof(buttons)/sizeof(buttons[0])+buttons[0]; ++i) { / / // if (readButton(i)) { // doAction(i); // } // }

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

Toetsenbord.releaseAll();

vertraging (VERTRAGING);

}

Er valt niet veel te zeggen over de logica, omdat deze vergelijkbaar is met die van mijn laatste controller, met twee opmerkelijke verschillen:

1. De knoppen zijn structs met hun eigen staatsmachines
2. De toestanden worden bij elkaar opgeteld om een code te maken die de actie bepaalt

Het principe is vergelijkbaar met bit-shifting, maar omdat de knoppen meerdere statussen hebben en niet eenvoudig kunnen worden weergegeven met een binair getal, worden ze in plaats daarvan vermenigvuldigd met machten van tien. Vervolgens tel ik alle knopstatussen bij elkaar op tot een enkel nummer en geef het door aan de doAction() switch-instructie, waar ik alle snelkoppelingencode plaats.

Zoals je kunt zien, heb ik niet alle mogelijke combinaties in kaart gebracht. Ik heb maar een paar van mijn favoriete sneltoetsen toegevoegd, ik laat het aan jou over om de rest in te vullen zoals jij dat het beste vindt;)

Stap 3: De behuizing

Voor de behuizing heb ik een 3D-printer gebruikt. Zoals je kunt zien, heeft het ontwerp enkele gebreken en ik moest MacGyver een manier vinden om het gewoon te sluiten. Dus ik zal het modelbestand nog niet posten.

De knoppen zijn warmgelijmd op "bankjes" zodat ze de doppen op hun plaats houden. De zachte drukknoppen zijn daar vooral goed in, dus zorg ervoor dat je er een paar krijgt als je van plan bent een behuizing te maken die lijkt op de mijne.

Ik raad ook aan om een beetje gewicht in de behuizing toe te voegen, omdat deze erg licht is. Door de extra grammen voelt het vasthouden natuurlijker aan.

Soldeer alles zoals afgebeeld en sluit de usb-kabel aan, en alles zou op zijn plaats moeten passen (met behulp van wat lijm)!

Stap 4: Resultaat en mogelijke verbeteringen

Daar heb je het! Een handheld-controller die u kunt gebruiken om met slechts één hand toegang te krijgen tot al uw belangrijke snelkoppelingen!

Het kost wat spiergeheugen om te gebruiken, maar het is echt veelzijdig!

Natuurlijk is het niet perfect, en op dit moment ben ik aan het nadenken over manieren om het te verbeteren. Afgezien van het verbeteren van de behuizing en het toevoegen van snelkoppelingen, denk ik dat het interessant zou zijn om meerdere applicaties met verschillende snelkoppelingen te ondersteunen. Ik denk aan een knopcombinatie om tussen besturingsschema's te schakelen, zoals het indrukken van 4 knoppen tegelijk om te schakelen tussen een Photoshop-snelkoppelingsbibliotheek naar een op maat gemaakt voor Maya.

Zomaar wat ideeën.

Bedankt voor het lezen, tot de volgende keer!