בקר קיצור כף יד (ל- Photoshop + More) [Arduino]: 4 שלבים

2024 מְחַבֵּר: John Day | [email protected]. שונה לאחרונה: 2024-01-30 09:15

בפעם האחרונה יצרתי משטח שליטה זעיר לשימוש בפוטושופ. זה עשה פלאים, ואני עדיין משתמש בו! אבל הוא גם מוגבל למדי, עם חמישה לחצנים בלבד וחוגות הגודל השימושיות והאטימות. עדיין מצאתי את עצמי מושיט יד הרבה למקלדת …

אז התחלתי לעבוד על האיטרציה הבאה של לוח הבקרה, אחד עם הרבה יותר כפתורים ופונקציונליות. משטח שליטה אחד לשליטה בכולם.

זה לא משטח הבקרה הזה. אבל במובן מסוים זה יכול להיות טוב יותר.

מה אם היית יכול לקבל המון קיצורי דרך, אבל באריזה סופר צמודה וקלה תוכל להחזיק ביד החופשית בזמן שאתה מצייר ללא הפרעה? … בסדר, מספיק עם המידע האינפורמטיבי.

בקר זה מתוכנת באופן שעם 4 כפתורים בלבד ניתן למפות אותו עד 32 קיצורי דרך אפשריים! הכפתור החמישי הנוסף נמצא שם כדי לאפשר לי להשתמש במקשי שינוי בכל שילוב, וזה שימושי לתוכניות רבות (האם ניסית פעם את שילוב Alt-RMB ב- PS? אם לא עשית זאת. זה מציל חיים). אני מסביר את המערכת בהמשך.

כדי לעשות את כל זה תצטרך:

• בקר אחד (השתמשתי ב- Adafruit ItsyBitsy 32u4 אבל כל אחד צריך לעשות זאת כל עוד יש לו שבב atmega32u4)
• מתאם מיקרו USB אחד (נתונים, לא כוח בלבד)
• 5 כפתורי לחיצה (השתמשתי בכפתורים רכים, כמו אלה)
• נגדי 10k אוהם (1 לכל כפתור)
• חוטים, קרש לחם, חומר הלחמה וכו '.
• משהו לעשות איתו מעטפת (מדפסת תלת מימד וכו ')

זהו פרויקט ארדואינו ברמה בינונית, ואני מציע להסתכל במדריך העבר שלי כדי להבין טוב יותר מה קורה, כיוון שחלק גדול מזה הוא חזרה על הדברים שהסברתי שם.

אוקיי, בואו נתחיל!

שלב 1: תכנון

זהו סכמטי בסיסי שציירתי של הבקר. המעגל ממש פשוט כשמשווים אותו לפרויקט הקודם שלי! אבל נוכל לעשות הרבה יותר עם הכפתורים המעטים שיש לו, עם העוצמה של לחיצות משולבות!

הרעיון שעומד מאחורי תוכנית הבקרה הוא שכל כפתור יכול להיות חופשי, ניתן ללחוץ ולשחרר אותו, או ללחוץ והחזק אותו. לחיצה ושחרור זה מה שיפעיל למעשה את קיצור הדרך, בעוד לחיצה ממושכת על כפתורים תעניק לנו גישה לקיצורי דרך שונים. אז אם רק תלחץ על כפתור A, תפעיל קיצור דרך A, אך אם תחזיק B בעת לחיצה על A, תקבל קיצור דרך אחר. אתה יכול להחזיק עד 3 כפתורים בבת אחת תוך לחיצה, כך שכאשר תיישם כמה קומבינטורות בסיסיות, תראה כמה שילובים אפשריים עם מערכת זו!

הכפתור החמישי הנוסף הרגיש כמו תוספת טבעית, בהתחשב בצורת כף היד שהבאתי. החלטתי להשתמש בו כדי לגשת למפתחות השינוי בפוטושופ. אופן הפעולה שלו שונה במקצת מהלחצנים האחרים: בכל פעם שתלחץ על כפתור האגודל, ישמשו רק משתנים. אלה יופעלו כאשר הם מוחזקים וניתן ללחוץ על מספר רב. אז אם כפתור A הוא Shift, ולחצן B הוא Ctrl, כאשר אתה מחזיק את A ו- B לחיצה ארוכה זה יהיה כמו לחיצה על Shift ו- Ctrl, אך רק כל עוד לחצן האגודל מוחזק!

הקליפה נועדה להיות ארגונומית וגם אמביקסטרוסית. הקפדתי מאוד להתאים אותו כך שהשימוש באצבע הקטנה לא יהיה מעייף מדי, וזה אמור לעבוד גם לבעלי ידיים גדולות משלי.

שלב 2: אב טיפוס + קוד

נוהג לבדוק את הכפתורים בלוח הלחם. זה די פשוט, פשוט חבר את הכפתורים והנגדים כפי שמוצג. אתה יכול לבדוק את זה עם הקוד כאן (חלופת קישור pastebin):

#לִכלוֹל

// השתמש באפשרות vthisv עבור MacOS:

// char ctrlKey = KEY_LEFT_GUI;

// השתמש באפשרות vthisv עבור Windows ו- Linux:

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

// מקשי פונקציות כאן

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

const int pins = {9, 10, 11, 12, 13}; // מערך של כל סיכות הכפתורים

//רְגִישׁוּת

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;

// להקפיא מסגרות

const int DELAY = 0;

enum מדינות {שחררו, לחצו, החזיקו, שחררו};

כפתור struct {

סיכה int; מדינות קובעות; int timeHeld; }; // אגודל, אינדקס, אמצע, טבעת, קטן;

לחצני כפתורים [BUTTON_NUM] = {};

כפתור initButton (int p) {

כפתור ב; pinMode (p, INPUT); b.pin = p; b.state = מדינות:: משוחררים; b.timeHeld = 0; החזרה ב; }

הגדרת בטל () {

// שים את קוד ההתקנה שלך כאן, להפעלה פעם אחת: Serial.begin (9600); Keyboard.begin ();

בעוד (! סדרתי) {};

// לחצנים עבור (int i = 0; i <(BUTTON_NUM); ++ i) {Serial.print ("כפתור set"); Serial.print (i); Serial.print ("לפי סיכה:"); Serial.println (סיכות ); // לחצנים .pin = 1; כפתורים = initButton (סיכות ); Serial.println (כפתורים .pin); }

}

bool readButton (int pin) {

// סמן ולחצן את הלחצנים אם (digitalRead (pin) == HIGH) {עיכוב (10); if (digitalRead (pin) == HIGH) {return true; }} החזר שקר; }

int pintobin (int pin) {

if (pin == pins [0]) החזר 1; if (pin == pins [1]) החזר 10; if (pin == pins [2]) החזר 100; if (pin == pins [3]) החזר 1000; if (pin == pins [4]) החזר 10000; } כפתור לחצן StateUpdate (כפתור ב) {

bool press = readButton (b.pin);

switch (b.state) {Case States:: freed: b.timeHeld = 0; אם (הקש) b.state = States:: לחוץ; לשבור; מקרה נלחץ: b.timeHeld+= 1; if (הקש) {if (b.timeHeld> (THRESH_1/(1+DELAY))) {b.state = States:: held; }} אחר {// if (b.timeHeld

int getButtonStateCode (כפתור ב)

{החזר b.state*pintobin (b.pin); }

int getCodeByButton (קוד int, אינדקס int) {

int r1, r2, r3, r4, r5; int opStep = BUTTON_NUM - (1+אינדקס);

// ניתוח ראשון

אם (opStep == 0) קוד החזרה/10000; r1 = קוד%10000;

אם (opStep == 1)

החזר r1/1000; r2 = r1%1000; אם (opStep == 2) החזר r2/100; r3 = r2%100; אם (opStep == 3) החזר r3/10; r4 = r3%10; אם (opStep == 4) החזר r4/1; r5 = r4%1; }

void completePress (int pin) {

// Serial.print ("קלט"); // Serial.println (סיכה); עיכוב (THRESH_3); Keyboard.releaseAll (); }

void doAction (int code) {

// משתנים אם (getCodeByButton (קוד, 0) == 2) {// Serial.println ("--- משתנים ----"); if (getCodeByButton (קוד, 1)> 0) {Keyboard.press (altKey); // Serial.println ("------- alt ---------"); } אחרת Keyboard.release (altKey); if (getCodeByButton (קוד, 2)> 0) {Keyboard.press (ctrlKey); // Serial.println ("-------- ctrl ----------"); } אחרת Keyboard.release (ctrlKey); if (getCodeByButton (קוד, 3)> 0) {Keyboard.press (''); } אחרת Keyboard.release (''); if (getCodeByButton (קוד, 4)> 0) {Keyboard.press (shiftKey); // Serial.println ("------ shift ------"); } אחרת Keyboard.release (shiftKey); } אחר {

// לבצע משימות

מתג (קוד) {מקרה 30: // --- | מברשת Keyboard.press (shiftKey); Keyboard.print ('b'); completePress (קוד); לשבור; תיק 300: // --- | מחק Keyboard.press (shiftKey); Keyboard.print ('e'); completePress (קוד); לשבור; תיק 3000: // --- | Bucket Keyboard.press (shiftKey); Keyboard.print ('g'); completePress (קוד); לשבור; תיק 30000: // --- | Lasso Keyboard.press (shiftKey); Keyboard.print ('l'); completePress (קוד); לשבור; מקרה 320: //-| o בטל Keyboard.press (ctrlKey); Keyboard.print ('z'); completePress (קוד); לשבור; מקרה 3020: //-| -o חזור על Keyboard.press (ctrlKey); Keyboard.print ('y'); completePress (קוד); לשבור; מקרה 30020: // | --o היסטוריה Keyboard.press (shiftKey); Keyboard.print ('y'); completePress (קוד); לשבור; מקרה 230: //-o | שמור Keyboard.press (ctrlKey); Keyboard.print ('s'); completePress (קוד); לשבור; מקרה 3200: //- | o- Quick-p.webp

int buttonCode = 0;

for (int i = 0; i <BUTTON_NUM; ++ i) {כפתורים = buttonStateUpdate (כפתורים ); buttonCode+= getButtonStateCode (כפתורים ); }

if (buttonCode! = 0) {

Serial.print ("קוד כפתור:"); Serial.println (buttonCode); }

doAction (buttonCode);

// שים את הקוד הראשי שלך כאן, כדי להריץ שוב ושוב: // for (int i = כפתורים [0]; i <sizeof (כפתורים)/sizeof (כפתורים [0])+לחצנים [0]; ++ i) {/ / // if (readButton (i)) {// doAction (i); //} //}

אם (getCodeByButton (buttonCode, 0)! = 2)

Keyboard.releaseAll ();

עיכוב (DELAY);

}

אין הרבה מה לומר על ההיגיון מכיוון שהוא דומה לזה של הבקר האחרון שלי, עם שני הבדלים בולטים:

1. הכפתורים הם מבנים עם מכונות מדינה משלהם
2. המדינות מסוכמות יחד כדי ליצור קוד הקובע את הפעולה

העיקרון דומה לשינוי סיביות, אך מכיוון שלכפתורים יש מספר מצבים ואי אפשר לייצג אותם פשוט בינארי, הם מוכפלים בעוצמות של עשר במקום זאת. לאחר מכן אני מצרף את כל מצבי הכפתורים למספר בודד, ומעביר אותו להצהר המתג doAction (), שם שמתי את כל קוד הקיצורים.

כפי שאתה יכול לראות, לא מיפיתי כל שילוב אפשרי. הוספתי רק כמה מקיצורי הדרך האהובים עליי, אני משאיר לך למלא את השאר איך שאתה הכי מתאים;)

שלב 3: מעטפת

השתמשתי במדפסת תלת מימד למעטפת. כפי שאתה יכול לראות, לעיצוב יש כמה פגמים והייתי צריך ל- MacGyver דרך פשוט לסגור אותו. אז אני לא אפרסם את קובץ הדגם עדיין.

הכפתורים מודבקים בחום על "ספסלים" כך שהם שומרים על הכובעים במקומם. כפתורי הלחיצה הרכים טובים בזה במיוחד, לכן הקפד להשיג כמה כאלו אם אתה מתכנן להכין מארז דומה לשלי.

כמו כן, אני מציע להוסיף מעט משקל בתוך המארז מכיוון שהוא קל מאוד. הגרמים הנוספים יגרום להחזקתו להרגיש טבעית יותר.

הלחם הכל כפי שמוצג וחבר את כבל ה- USB, והכל צריך להתאים למקומו (בעזרת קצת דבק)!

שלב 4: תוצאה ושיפורים אפשריים

הנה לך! בקר כף יד שבו תוכל להשתמש בכדי לגשת לכל קיצורי הדרך החשובים שלך ביד אחת בלבד!

נדרש קצת זיכרון שרירים כדי להשתמש בו, אבל הוא מאוד תכליתי!

כמובן שזה לא מושלם, וכרגע אני חושב על כמה דרכים לשפר את זה. מלבד שיפור המעטפת והוספת קיצורי הדרך, אני חושב שיהיה מעניין לתמוך ביישומים מרובים עם קיצורי דרך שונים. אני חושב שיהיה לי שילוב כפתורים כדי לעבור בין תוכניות שליטה, כמו לחיצה על 4 כפתורים בו זמנית כדי לעבור בין ספריית קיצורי דרך לפוטושופ לתפירה מותאמת אישית עבור מאיה.

רק כמה רעיונות.

תודה שקראתם, עד לפעם הבאה!