Contrôleur de raccourci portable (pour Photoshop + Plus) [Arduino] : 4 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:08

La dernière fois, j'ai créé un petit pavé de contrôle à utiliser dans Photoshop. Cela a fait des merveilles, et je l'utilise toujours ! Mais c'est aussi assez limité, avec seulement cinq boutons et les cadrans utiles de taille et d'opacité. Je me suis quand même beaucoup retrouvé à toucher le clavier…

J'ai donc commencé à travailler sur la prochaine itération du pavé de commande, une avec beaucoup plus de boutons et de fonctionnalités. Un pavé de contrôle pour les gouverner tous.

Ce n'est pas ce pavé de contrôle. MAIS d'une certaine manière, cela pourrait être mieux.

Et si vous pouviez avoir une tonne de raccourcis, mais dans un emballage super confortable et léger que vous pouvez tenir avec votre main libre pendant que vous dessinez sans interruption ? …ok, assez avec l'infopublicité.

Ce contrôleur est programmé de manière à ce qu'avec seulement 4 boutons, il puisse être associé à jusqu'à 32 raccourcis possibles ! Le 5ème bouton supplémentaire est là pour me permettre d'utiliser les touches de modification dans n'importe quelle combinaison, ce qui est utile pour de nombreux programmes (avez-vous déjà essayé le combo Alt-RMB dans PS ? Si ce n'est pas le cas, faites-le. C'est une bouée de sauvetage). J'explique le système plus tard.

Pour réaliser tout cela, vous aurez besoin de:

• 1 Microcontrôleur (j'ai utilisé un Adafruit ItsyBitsy 32u4 mais n'importe lequel devrait faire l'affaire tant qu'il a la puce atmega32u4)
• 1 adaptateur micro-USB (données, pas d'alimentation uniquement)
• 5 boutons poussoirs (j'ai utilisé des boutons souples, comme ceux-ci)
• Résistances 10k Ohm (1 par bouton)
• Fils, planche à pain, matériel de soudure, etc.
• De quoi faire un boîtier avec (imprimante 3D, etc.)

Il s'agit d'un projet Arduino de niveau intermédiaire, et je suggère de consulter mon tutoriel précédent pour mieux comprendre ce qui se passe, car il s'agit en grande partie d'une répétition des choses que j'ai expliquées ici.

D'accord, commençons !

Étape 1: Planification

C'est un schéma de base que j'ai dessiné du contrôleur. Le circuit est vraiment simple quand on le compare à mon précédent projet ! Mais nous pourrons faire bien plus avec les quelques boutons dont il dispose, avec la puissance des pressions combinées !

L'idée derrière le schéma de contrôle est que chaque bouton peut être libre, enfoncé et relâché, ou enfoncé et maintenu. Appuyer et relâcher est ce qui activera réellement le raccourci, tandis que le maintien des boutons nous donnera accès à différents raccourcis. Donc, si vous appuyez simplement sur le bouton A, vous activerez le raccourci A, mais si vous maintenez B en appuyant sur A, vous obtiendrez un raccourci différent. Vous pouvez maintenir jusqu'à 3 boutons à la fois tout en appuyant, donc lorsque vous appliquez quelques combinatoires de base, vous verrez combien de combinaisons sont possibles avec ce système !

Le cinquième bouton supplémentaire semblait être un ajout naturel, compte tenu de la forme de l'ordinateur de poche que j'ai imaginé. J'ai décidé de l'utiliser pour accéder aux touches de modification dans Photoshop. La façon dont cela fonctionne est légèrement différente des autres boutons: chaque fois que le bouton du pouce est maintenu enfoncé, seuls les modificateurs seront utilisés. Ceux-ci s'activeront lorsqu'ils sont maintenus et plusieurs peuvent être enfoncés. Donc, si le bouton A est Shift et le bouton B est Ctrl, lorsque vous maintenez A et B enfoncés, ce sera comme appuyer à la fois sur Shift et Ctrl, mais seulement aussi longtemps que le bouton du pouce est maintenu!

La coque est conçue pour être à la fois ergonomique et ambidextre. J'ai pris grand soin de l'ajuster parfaitement pour que l'utilisation du petit doigt ne soit pas trop fatigante, et cela devrait également fonctionner pour ceux qui ont des mains plus grandes que les miennes.

Étape 2: Prototype + Code

Il est recommandé de tester les boutons sur une maquette. C'est assez simple, il suffit de connecter les boutons et les résistances comme indiqué. Vous pouvez le tester avec le code ici (alternative au lien pastebin):

#comprendre

// utilise l'option vthisv pour MacOS:

//char ctrlKey = KEY_LEFT_GUI;

// utilise l'option vthisv pour Windows et Linux:

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

//Touches de fonction ici

car Fn1Key = KEY_F2; car Fn2Key = KEY_F3; car Fn3Key = KEY_F4; caractère Fn4Key = KEY_F5;

const int broches = {9, 10, 11, 12, 13}; // tableau de toutes les broches de bouton

//Sensibilité

const entier SEUIL_0 = 10; const entier SEUIL_1 = 20; const entier SEUIL_2 = 25; const entier SEUIL_3 = 50; const entier SEUIL_4 = 100; const entier SEUIL_5 = 200;

const int BUTTON_NUM = 5;

//Geler les images

const entier DELAY = 0;

enum States { libéré, pressé, maintenu, libéré };

bouton struct {

broche int; État des États; int timeHold; }; //pouce, index, milieu, anneau, petit;

bouton boutons[BUTTON_NUM] = {};

bouton initButton(int p) {

bouton b; pinMode(p, INPUT); b.pin = p; b.state = États::libérés; b.timeHeld = 0; retour b; }

void setup() {

// mettez votre code de configuration ici, à exécuter une fois: Serial.begin(9600); Keyboard.begin();

while(!Série){};

//Boutons for(int i = 0; i < (BUTTON_NUM); ++i) { Serial.print("set button "); Serial.print(i); Serial.print(" à la broche: "); Serial.println(broches); //boutons.pin = 1; boutons=initButton(broches); Serial.println(boutons.pin); }

}

bool readButton(int pin) {

// vérifie et évite les boutons if (digitalRead(pin) == HIGH) { delay(10); if (digitalRead(pin) == HIGH) { return true; } } renvoie faux; }

int pintobin(int pin) {

if (pin==pins[0]) renvoie 1; si (broche== broches[1]) renvoie 10; if (pin== pins[2]) renvoie 100; if (pin== pins[3]) renvoie 1000; si (broche== broches[4]) renvoie 10000; } bouton buttonStateUpdate(bouton b) {

bool press = readButton(b.pin);

switch (b.state) { case States::freed: b.timeHeld=0; if (press) b.state=States::pressed; Pause; casse pressée: b.timeHeld+=1; if (press) { if (b.timeHeld>(THRESH_1/(1+DELAY))) { b.state=States::held; } } else { //if (b.timeHeld

int getButtonStateCode(bouton b)

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

int getCodeByButton(int code, int index) {

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

//première opération

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

si (opStep==1)

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

void completePress(int pin) {

// Serial.print ("input"); // Serial.println(pin); retard(SEUIL_3); Keyboard.releaseAll(); }

void doAction(int code) {

//Modificateurs 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 Keyboard.release(' '); if (getCodeByButton(code, 4)>0) { Keyboard.press(shiftKey); // Serial.println("------shift------"); } else Keyboard.release(shiftKey); } autre {

// effectuer des tâches

switch (code) { case 30: //---| Brush Keyboard.press(shiftKey); Keyboard.print('b'); completeAppuyez sur(code); Pause; cas 300: //---| Eraser Keyboard.press (shiftKey); Keyboard.print('e'); completeAppuyez sur(code); Pause; cas 3000: //---| Seau Keyboard.press (shiftKey); Keyboard.print('g'); completeAppuyez sur(code); Pause; cas 30000: //---| Lasso Keyboard.press(shiftKey); Keyboard.print('l'); completeAppuyez sur(code); Pause; case 320: //--|o Annuler Keyboard.press(ctrlKey); Keyboard.print('z'); completeAppuyez sur(code); Pause; case 3020: //-|-o Redo Keyboard.press(ctrlKey); Keyboard.print('y'); completeAppuyez sur(code); Pause; case 30020: //|--o History Keyboard.press(shiftKey); Keyboard.print('y'); completeAppuyez sur(code); Pause; cas 230: //--o| Enregistrer Keyboard.press(ctrlKey); Keyboard.print('s'); completeAppuyez sur(code); Pause; case 3200: //-|o- Quick-p.webp

int buttonCode=0;

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

if(boutonCode!=0) {

Serial.print("code du bouton: "); Serial.println(boutonCode); }

doAction(boutonCode);

// mettez votre code principal ici, pour l'exécuter à plusieurs reprises: // for(int i = button[0]; i < sizeof(buttons)/sizeof(buttons[0])+buttons[0]; ++i) { / / // if (readButton(i)) { // doAction(i); // } // }

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

Keyboard.releaseAll();

retard(DÉLAI);

}

Il n'y a pas grand chose à dire sur la logique car elle est similaire à celle de ma dernière manette, avec deux différences notables:

1. Les boutons sont des structures avec leurs propres machines à états
2. Les états sont additionnés pour former un code qui détermine l'action

Le principe est similaire au décalage de bits, mais comme les boutons ont plusieurs états et ne peuvent pas être simplement représentés avec un binaire, ils sont plutôt multipliés par des puissances de dix. J'additionne ensuite tous les états des boutons en un seul nombre et le passe à l'instruction de commutation doAction(), où je mets tout le code des raccourcis.

Comme vous pouvez le voir, je n'ai pas cartographié toutes les combinaisons possibles. Je n'ai ajouté que quelques-uns de mes raccourcis préférés, je vous laisse le soin de remplir le reste comme bon vous semble;)

Étape 3: Le boîtier

J'ai utilisé une imprimante 3D pour le boîtier. Comme vous pouvez le voir, le design a quelques défauts et j'ai dû trouver un moyen pour MacGyver de le fermer. Je ne posterai donc pas le fichier modèle pour l'instant.

Les boutons sont collés à chaud sur des "bancs" afin qu'ils maintiennent les capuchons en place. Les boutons-poussoirs souples sont particulièrement efficaces pour cela, alors assurez-vous d'en obtenir si vous envisagez de créer un boîtier similaire au mien.

Aussi, je suggère d'ajouter un peu de poids à l'intérieur du boîtier, car il est très léger. Les grammes supplémentaires le rendront plus naturel.

Soudez le tout comme indiqué et connectez le câble USB, et tout devrait s'emboîter (à l'aide d'un peu de colle) !

Étape 4: Résultat et améliorations possibles

Voilà! Un contrôleur portable que vous pouvez utiliser pour accéder à tous vos raccourcis importants d'une seule main !

Il faut de la mémoire musculaire pour l'utiliser, mais c'est vraiment polyvalent !

Bien sûr, ce n'est pas parfait, et en ce moment je réfléchis à des façons de l'améliorer. En plus d'améliorer le boîtier et d'ajouter les raccourcis, je pense que je serais intéressant de prendre en charge plusieurs applications avec différents raccourcis. Je pense avoir une combinaison de boutons pour basculer entre les schémas de contrôle, comme appuyer sur 4 boutons en même temps pour basculer entre une bibliothèque de raccourcis Photoshop et une création sur mesure pour Maya.

Juste quelques idées.

Merci d'avoir lu, jusqu'à la prochaine fois!