Mini Control Pad voor Photoshop (Arduino) - Ajarnpa

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

Hier laat ik je zien hoe je een klein hulpmiddel kunt maken waarmee je sneller in Photoshop kunt werken!

Toetsenborden die speciaal voor PS zijn gemaakt, zijn niet nieuw, maar ze bieden niet precies wat ik nodig heb. Als schilder besteed ik veel van mijn tijd in Photoshop aan het aanpassen van de penseelinstelling, en ik denk dat eenvoudige sneltoetsen me niet de controle geven die bij mijn workflow past. Dus besloot ik om mijn eigen toetsenbord te maken, een die klein, onopvallend is en wijzerplaten heeft om me die analoge interactie te geven die ik altijd al wilde.

De manier waarop het werkt is eenvoudig: om de microcontroller te laten communiceren met Photoshop, maken we gebruik van de standaardsnelkoppelingen. Met een bord dat de computer kan lezen als een toetsenbord/muis, hoeven we alleen maar enkele eenvoudige regels code te gebruiken om de computer te vertellen dat elke invoer moet worden gelezen als een combinatie van toetsaanslagen. Nu is de knop ongedaan maken slechts een druk op de knop verwijderd!

Laten we beginnen! Voor dit project heb je nodig:

• 1 Sparkfun ProMicro (of een Arduino Leonardo, niet aanbevolen)
• 1 micro-USB-adapter
• 6 drukknoppen (of een willekeurig nummer)
• 10k Ohm weerstanden (1 voor elke knop)
• 1 potentiometer
• 1 roterende encoder
• draden, breadboard, perfboard, soldeer, header-pinnen, enz.

Je kunt voor dit project een Arduino Leonardo gebruiken, maar de ProMicro is een veel goedkoper alternatief dat dezelfde atmega32u4-chip gebruikt, meer pinnen heeft en in een veel kleinere vorm komt, waardoor het perfect is voor een toetsenbord.

Om de ProMicro in de Arduino IDE te programmeren, moet je misschien eerst het een en ander instellen. Je kunt er meer over lezen in de handleiding van SparkFun:

Als uw computer het apparaat niet kan vinden, controleer dan of de micro-USB die u gebruikt niet alleen voor stroomvoorziening is en gegevensoverdracht ondersteunt.

Dit is mijn eerste Arduino-project en is geschikt voor beginners.

Stap 1: Prototyping van de Control Pad

Ik raad je aan om je programma eerst op een breadboard te testen voordat je gaat solderen.

Hier zie je mijn schema.

Knoppen 1 en 2 zijn Ongedaan maken en Opnieuw, 3 tot 5 zijn voor de gereedschappen Penseel, Gum en Lasso, knop 6 is een snelle knop Opslaan. De encoder en de potmeter regelen respectievelijk Grootte en Opacity.

Merk op dat ik linkshandig ben en de lay-out heb ontworpen op de manier die voor mij het meest comfortabel is om te gebruiken. Zie het moment waarop je je breadboard gebruikt als een kans om na te denken over welke functies je wilt dat je controller heeft, wat voor jou het beste werkt en uiteindelijk of je extra onderdelen nodig hebt om het te maken.

Stap 2: Drukknoppen

De knoppen zijn het eenvoudigst te implementeren. Laten we de code eens bekijken:

#erbij betrekken

const int-knoppen = {2, 3, 4, 5, 6, 7, 8, 9}; // array van alle knoppinnen char ctrlKey = KEY_LEFT_GUI; // gebruik deze optie voor Windows en Linux: //char ctrlKey = KEY_LEFT_CTRL; char shiftKey = KEY_LEFT_SHIFT; char altKey = KEY_LEFT_ALT; void setup() { // plaats hier uw setup-code om een keer uit te voeren: Serial.begin (9600); Toetsenbord.begin(); // Buttons -- loop door de array en controleer op drukken voor (int i = buttons[0]; i < (sizeof(buttons)/sizeof(buttons[0]))+buttons[0]; ++i) { pinMode(i, INPUT); } } boolean readButton (int pin) {// check en debounce knoppen if (digitalRead (pin) == HIGH) { delay (10); if (digitalRead(pin) == HIGH) { return true; } } retourneer onwaar; } void doAction (int pin) { // taken uitvoeren switch (pin) { // ---- Snelkoppelingen ---- // Case 4: Keyboard.press (ctrlKey) ongedaan maken; Toetsenbord.print('z'); Serial.print ("invoer"); Serial.println(pin); vertraging (200); Toetsenbord.releaseAll(); pauze; // Herhaal geval 5: Keyboard.press (ctrlKey); Toetsenbord.print('y'); Serial.print ("invoer"); Serial.println(pin); vertraging (200); Toetsenbord.releaseAll(); pauze; //Borsteldoos 6: Keyboard.press('b'); Serial.print ("invoer"); Serial.println(pin); vertraging (200); Toetsenbord.releaseAll(); pauze; //Gum case 7: Keyboard.press('e'); Serial.print ("invoer"); Serial.println(pin); vertraging (200); Toetsenbord.releaseAll(); pauze; //Lasso geval 8: Keyboard.press('l'); Serial.print ("invoer"); Serial.println(pin); vertraging (200); Toetsenbord.releaseAll(); pauze; // Bewaar case 9: Keyboard.press (ctrlKey); Toetsenbord.print('s'); Serial.print ("invoer"); Serial.println(pin); vertraging (200); Toetsenbord.releaseAll(); pauze; standaard: Keyboard.releaseAll(); pauze; } }

lege lus() {

// 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); } } //Reset modifiers Keyboard.releaseAll();

}

Ze zijn redelijk rechttoe rechtaan. Om ervoor te zorgen dat de computer een druk op een knop herkent als een toetsaanslag, gebruiken we gewoon de functie Keyboard.press(). Dus om de sneltoets Ongedaan maken (ctrl+z) te activeren, gebruiken we gewoon Keyboard.press(ctrlKey) en vervolgens Keyboard.press('z'). Onthoud dat u Keyboard.h moet opnemen en het toetsenbord moet initialiseren om toegang te krijgen tot deze functies.

De invoerpinnen worden opgeslagen in een array, zodat u ze gemakkelijk allemaal kunt doorlopen in de loop()-functie. Een gemakkelijke manier om toegang te krijgen tot en de lengte van de array in c++ door de grootte van de hele array te delen door het array-element, plus één element. We doorlopen alle knoppen om te controleren of er op een is gedrukt.

Om de zaken overzichtelijk te houden, heb ik alle acties van mijn knop opgeslagen in de switch-instructie van een functie die het pinnummer als argument neemt.

Als je wilt dat je knoppen verschillende dingen doen, of meer knoppen wilt toevoegen, bewerk dan gewoon de inhoud van de doAction-functie!

Vanwege de manier waarop fysieke knoppen werken, moeten we ze debouncen. Dit is om te voorkomen dat het programma ongewenste drukken leest die worden veroorzaakt door de veerkracht van de drukknoppen. Er zijn veel manieren om dit te doen, maar ik heb een eenvoudige readButton()-functie toegevoegd die daarvoor zorgt.

Sluit gewoon je knoppen aan met een paar 10k-weerstanden, en je zou goud moeten zijn!

Stap 3: De potentiometer

Nu op de potmeter:

#erbij betrekken

int dial0 = 0; void setup() { // plaats hier uw setup-code om een keer uit te voeren: Serial.begin (9600); Toetsenbord.begin(); // Kiest dial0 = analogRead (0); dial0= kaart (dial0, 0, 1023, 1, 20); } void dialAction (int dial, int newVal, int lastVal) {switch (dial) {// Dekkingsgeval 0: vertraging (200); if (newVal!=lastVal) { int decim = ((newVal*5)/10); int-eenheid = ((newVal *5)% 10); if (newVal==20) { Keyboard.write(48+0); Toetsenbord.schrijven (48+0); Serial.println ("max. kies 1"); } else { decim=constrain(decim, 0, 9); unit=beperking(eenheid, 0, 9); Serial.println(newVal*2); Toetsenbord.schrijven (48+decim); Toetsenbord.schrijven (48+eenheid); } } dial0=newVal; pauze; standaard: pauze; } } //------------------ HOOFDLUS------------------------- ongeldig loop() { // plaats hier je hoofdcode, om herhaaldelijk uit te voeren: //Opacity //delay(500); int val0 = analoog lezen (0); val0 = kaart (val0, 0, 1023, 1, 20); //Serial.print ("dial0: "); //Serial.println(val0); if (val0!=dial0) {//Doe iets dialAction (0, val0, dial0); } }

De potmeter volgt dezelfde logica, maar het is een beetje lastiger.

Laten we eerst eens kijken hoe we willen dat het werkt: Photoshop heeft enkele handige sneltoetsen om de dekking van een penseel te wijzigen. Als u op een cijfertoets drukt, is de dekking gelijk aan dat getal*10. Maar als u op twee cijfers drukt, wordt het tweede cijfer als een eenheid gelezen, waardoor u nauwkeuriger kunt controleren.

Dus we willen dat onze potmeter zijn rotatie in kaart brengt naar een percentage, maar we willen het niet de hele tijd doen, want dat zou dwaas zijn. We willen de dekking alleen veranderen als de potmeter wordt gedraaid. We slaan dus een extra waarde op die we vergelijken met de waarde analogRead() en voeren het actiescript alleen uit als er een verschil is.

Een ander probleem waar we tegenaan zullen lopen, is hoe we de return van analogRead omzetten in een invoer. Omdat er geen gemakkelijke manier is om een int in een string te veranderen, zullen we de int zelf moeten gebruiken. Als u echter gewoon Keyboard.press(int) schrijft, zult u merken dat de invoer niet is wat u wilde, en in plaats daarvan wordt een andere toets ingedrukt.

Dit komt omdat de toetsen van uw toetsenbord allemaal zijn gecodeerd als gehele getallen, waarbij elke toets zijn eigen index heeft. Om de num-sleutel correct te gebruiken, moet u hun index opzoeken in de ASCII-tabel:

Zoals u kunt zien, beginnen de cijfertoetsen bij index 48. Dus om de juiste toets in te drukken, hoeven we alleen maar de waarde van de wijzerplaat op te tellen bij 48. De decimale en eenheidswaarden zijn afzonderlijke drukken.

Ten slotte hebben we een manier nodig om te voorkomen dat de waarde heen en weer springt. Want als je de wijzerplaat probeert te gebruiken met map (val0, 0, 1023, 0, 100), zul je merken dat de resultaten erg zenuwachtig zijn. Net zoals we de knoppen debouncen, zullen we dit oplossen door een deel van de nauwkeurigheid op te offeren. Ik ontdekte dat het toewijzen aan 1-20 en het vermenigvuldigen van de waarde van de argumenten met 5 een acceptabel compromis was.

Om de potentiometer aan te sluiten, sluit u gewoon een 5V-draad, een aardingsdraad en een analoge ingangsdraad aan en er zouden geen problemen moeten zijn.

Leuk weetje: als je deze sneltoets gebruikt terwijl een tool zoals de lasso is geselecteerd, zal het in plaats daarvan de dekking van de laag veranderen. Iets om op te letten.

Stap 4: De roterende encoder

Roterende encoders zijn een beetje zoals potentiometers, maar zonder een limiet aan hoeveel ze kunnen draaien. In plaats van een analoge waarde kijken we digitaal naar de draairichting van de encoder. Ik zal niet in detail treden over hoe deze werken, maar wat je moet weten, is dat het twee invoerpinnen op de Arduino gebruikt om te vertellen in welke richting het wordt gedraaid. De roterende encoder kan lastiger zijn om mee te werken, verschillende encoders kunnen verschillende instellingen vereisen. Om het gemakkelijker te maken, heb ik er een gekocht met PCB, die klaar is om te worden aangesloten met vrouwelijke pinnen. Nu de code:

#erbij betrekken

// Roterende encoder #define outputA 15 #define outputB 14 int teller = 0; int een Staat; int aLastState; void setup () {// plaats hier uw setup-code, om één keer uit te voeren: // Rotary pinMode (outputA, INPUT); pinMode (uitgangB, INPUT); // Leest de beginstatus van de outputA aLastState = digitalRead (outputA); } void rotaryAction(int dir) { if (dir>0) { Keyboard.press(']'); } else { Toetsenbord.press('['); } Toetsenbord.releaseAll(); } //------------------MAIN LOOP------------------------- ongeldige lus () { // plaats hier uw hoofdcode, om herhaaldelijk uit te voeren: //Size aState = digitalRead (outputA); if (aState!= aLastState){if (digitalRead(outputB)!= aState) {//counter ++; roterendeActie(1); } anders { //teller --; roterende actie(-1); } //Serial.print("Positie: "); //Serial.println(teller); } aLastState = aState; }

Standaard vergroten en verkleinen de sneltoetsen] en [van Photoshop de penseelgrootte. Net als voorheen willen we die invoeren als toetsaanslagen. De encoder stuurt een aantal inputs per beurt (afhankelijk van het model), en we willen de brush size voor elk van deze inputs vergroten/verkleinen, zodat je de draaiknop heel snel omhoog of omlaag kunt draaien, maar ook in staat bent om regel het langzaam met grote precisie.

Net als bij de potmeter willen we de actie alleen uitvoeren als er aan de draaiknop wordt gedraaid. In tegenstelling tot de potmeter, zoals ik eerder heb uitgelegd, heeft de roterende encoder twee afwisselende ingangen. We kijken welke hiervan is veranderd om de richting te bepalen waarin de wijzerplaat wordt gedraaid.

Afhankelijk van de richting drukken we vervolgens op de juiste toets.

Zolang je geen contactproblemen hebt, zou het moeten werken.

Stap 5: Alles samenbrengen

Nu op naar het solderen. Eerst boren we twee gaten in de perfboard om op de twee wijzerplaten te passen. we solderen de knoppen en hun respectievelijke weerstanden. Ik heb twee extra kleine gaatjes geboord om de ingangsdraden bovenaan te laten passeren om ruimte eronder te besparen, maar dit is niet nodig. Er zijn niet veel ingangsdraden, dus de GND- en 5V-draden lopen parallel, maar als je je handig voelt, wil je misschien een matrix maken. Ik heb de microcontroller op een ander, kleiner perfboard gesoldeerd, dat eronder naast de encoder en de potmeter past. Nu soldeer ik alle draden aan de ProMicro. Het is niet nodig om creatief te zijn, ik moest gewoon hetzelfde schema volgen als dat op het breadboard, maar solderen op zo'n kleine plaats kan begrijpelijkerwijs vervelend zijn. Wees niet zoals ik, gebruik een draadstripper en een goed soldeersel!

Ten slotte wil je misschien een mooie case maken voor je nieuwe Photoshop-buddy. Een beter dan de mijne, tenminste!

Maar als je het graag wilt proberen, gebruik dan wat karton en plakband en sluit je micro-USB aan.

Stap 6: Code + Demonstratie

Zorg ervoor dat u het programma van het bedieningspaneel test terwijl u door het project loopt om verrassingen te voorkomen!

Hier is de volledige code:

Heel erg bedankt voor het lezen!