მინი კონტროლის ბალიში Photoshop– ისთვის (Arduino): 6 ნაბიჯი

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:19

აქ მე გაჩვენებთ, თუ როგორ უნდა გააკეთოთ პატარა ინსტრუმენტი, რომელიც დაგეხმარებათ Photoshop– ში უფრო სწრაფად მუშაობაში!

PS– სთვის სპეციალურად შექმნილი კლავიატურები არ არის ახალი, მაგრამ ისინი ზუსტად არ გვთავაზობენ იმას, რაც მჭირდება. როგორც მხატვარი, Photoshop– ში ჩემი დიდი დრო იხარჯება ფუნჯის პარამეტრების რეგულირებაში და ვფიქრობ, რომ მარტივი მალსახმობების ღილაკები არ მაძლევს კონტროლს, რომ შევადარო ჩემს სამუშაო ნაკადს. ასე რომ, მე გადავწყვიტე ჩემი საკუთარი კლავიატურის გაკეთება, რომელიც არის პატარა, შეუმჩნეველი და აქვს ციფერბლატები, რომ მომცეს ის ანალოგური ურთიერთქმედება, რაც მე ყოველთვის მინდოდა.

მისი მუშაობის მეთოდი მარტივია: მიკროკონტროლის Photoshop– თან ურთიერთქმედების მიზნით, ჩვენ ვიყენებთ უპირატესობას ნაგულისხმევი მალსახმობებისგან. დაფით, რომელსაც კომპიუტერი შეუძლია წაიკითხოს როგორც კლავიატურა/მაუსი, ჩვენ მხოლოდ ის უნდა გამოვიყენოთ, რომ გამოვიყენოთ კოდის რამდენიმე მარტივი ხაზი, რათა ვუთხრათ კომპიუტერს, რომ წაიკითხოს თითოეული შეყვანა, როგორც კლავიშის დაჭერის კომბინაცია. ახლა გაუქმების ღილაკი მხოლოდ ღილაკის დაჭერაა!

Დავიწყოთ! ამ პროექტისთვის დაგჭირდებათ:

• 1 Sparkfun ProMicro (ან Arduino Leonardo, არ არის რეკომენდებული)
• 1 მიკრო USB ადაპტერი
• 6 ღილაკი (ან ნებისმიერი ნომერი, რომელიც მოგწონთ)
• 10k Ohm რეზისტორები (1 თითოეული ღილაკისთვის)
• 1 პოტენომეტრი
• 1 მბრუნავი კოდირება
• მავთულები, პურის დაფა, პერფორი, შედუღება, სათაურის ქინძისთავები და ა.

თქვენ შეგიძლიათ გამოიყენოთ Arduino Leonardo ამ პროექტისთვის, მაგრამ ProMicro არის ბევრად უფრო იაფი ალტერნატივა, რომელიც იყენებს იგივე atmega32u4 ჩიპს, აქვს მეტი ქინძისთავები და გამოდის ბევრად უფრო მცირე ფორმით, რაც მას სრულყოფილად აქცევს კლავიატურაზე.

Arduino IDE– ში ProMicro– ს დასაპროგრამებლად შეიძლება დაგჭირდეთ ზოგიერთი ნივთის დაყენება. ამის შესახებ მეტის წაკითხვა შეგიძლიათ SparkFun– ის სახელმძღვანელოში:

თუ თქვენს კომპიუტერს უჭირს მოწყობილობის პოვნა, დარწმუნდით, რომ თქვენს მიერ გამოყენებული მიკრო USB არ არის მხოლოდ ენერგიის წყარო და მხარს უჭერს მონაცემთა გადაცემას.

ეს არის ჩემი პირველი Arduino პროექტი და შესაფერისია დამწყებთათვის.

ნაბიჯი 1: საკონტროლო ბადის პროტოტიპირება

გირჩევთ შედუღების დაწყებამდე ჯერ შეამოწმოთ თქვენი პროგრამა დაფაზე.

აქ თქვენ შეგიძლიათ ნახოთ ჩემი სქემა.

ღილაკები 1 და 2 იქნება Undo და Redo, 3 -დან 5 -მდე არის ფუნჯი, საშლელი და Lasso ინსტრუმენტები, ღილაკი 6 არის სწრაფი შენახვის ღილაკი. კოდირება და potmeter აკონტროლებენ ზომას და გამჭვირვალობას შესაბამისად.

გაითვალისწინეთ, რომ მე ვარ მემარცხენე და განლაგებული განლაგება ისე, როგორც ჩემთვის ყველაზე მოსახერხებელია გამოსაყენებლად. იხილეთ ის მომენტი, როდესაც თქვენ იყენებთ თქვენს პურის დაფას, როგორც შესაძლებლობას იფიქროთ იმაზე, თუ რა ფუნქციებს ისურვებდით თქვენი კონტროლერი, რა გამოგადგებათ საუკეთესოდ თქვენთვის და საბოლოოდ თუ დაგჭირდებათ დამატებითი ნაწილები მის დასამზადებლად.

ნაბიჯი 2: დააჭირეთ ღილაკებს

ღილაკები ყველაზე მარტივი განსახორციელებელია. მოდით შევხედოთ კოდს:

#ჩართეთ

const int ღილაკები = {2, 3, 4, 5, 6, 7, 8, 9}; // ღილაკის ყველა ქინძისთავის მასივი char ctrlKey = KEY_LEFT_GUI; // გამოიყენეთ ეს ვარიანტი Windows- ისა და Linux- ისთვის: // char ctrlKey = KEY_LEFT_CTRL; char shiftKey = KEY_LEFT_SHIFT; char altKey = KEY_LEFT_ALT; void setup () {// განათავსეთ თქვენი კონფიგურაციის კოდი აქ, ერთხელ გასაშვებად: Serial.begin (9600); კლავიატურა. დაწყება (); // ღილაკები - გადადით მასივში და შეამოწმეთ პრესები (int i = ღილაკები [0]; i <(sizeof (ღილაკები)/sizeof (ღილაკები [0]))+ღილაკები [0]; ++ i) { pinMode (i, INPUT); }} boolean readButton (int pin) {// შეამოწმეთ და გააუქმეთ ღილაკები if (digitalRead (pin) == HIGH) {დაგვიანებით (10); if (digitalRead (pin) == HIGH) {დაბრუნება true; }} დაბრუნება false; } void doAction (int pin) {// შეასრულეთ ამოცანების გადართვა (pin) {// ---- მალსახმობები ---- // საქმის გაუქმება 4: Keyboard.press (ctrlKey); Keyboard.print ('z'); Serial.print ("შეყვანა"); Serial.println (pin); დაგვიანება (200); Keyboard.releaseAll (); შესვენება; // ხელახლა საქმე 5: Keyboard.press (ctrlKey); Keyboard.print ('y'); Serial.print ("შეყვანა"); Serial.println (pin); დაგვიანება (200); Keyboard.releaseAll (); შესვენება; // ჯაგრისის საქმე 6: Keyboard.press ('b'); Serial.print ("შეყვანა"); Serial.println (pin); დაგვიანება (200); Keyboard.releaseAll (); შესვენება; // საშლელი 7: Keyboard.press ('e'); Serial.print ("შეყვანა"); Serial.println (pin); დაგვიანება (200); Keyboard.releaseAll (); შესვენება; // Lasso case 8: Keyboard.press ('l'); Serial.print ("შეყვანა"); Serial.println (pin); დაგვიანება (200); Keyboard.releaseAll (); შესვენება; // საქმის შენახვა 9: Keyboard.press (ctrlKey); Keyboard.print ('s'); Serial.print ("შეყვანა"); Serial.println (pin); დაგვიანება (200); Keyboard.releaseAll (); შესვენება; ნაგულისხმევი: Keyboard.releaseAll (); შესვენება; }}

ბათილი მარყუჟი () {

// განათავსეთ თქვენი მთავარი კოდი აქ განმეორებით გასაშვებად:

for (int i = ღილაკები [0]; i <sizeof (ღილაკები)/sizeof (ღილაკები [0])+ღილაკები [0]; ++ i) {if (readButton (i)) {doAction (i); }} // მოდიფიკატორების გადატვირთვა Keyboard.releaseAll ();

}

ისინი საკმაოდ პირდაპირები არიან. იმისათვის, რომ კომპიუტერმა აღიაროს ღილაკის დაჭერა, როგორც გასაღები, ჩვენ უბრალოდ ვიყენებთ Keyboard.press () ფუნქციას. გაუქმების მალსახმობის გასააქტიურებლად (ctrl+z), ჩვენ უბრალოდ ვიყენებთ Keyboard.press (ctrlKey) და შემდეგ Keyboard.press ('z'). გახსოვდეთ, თქვენ უნდა შეიყვანოთ Keyboard.h და ამ ფუნქციების წვდომისათვის კლავიატურის ინიციალიზაცია.

შეყვანის ქინძისთავები ინახება მასივში, ასე რომ თქვენ შეგიძლიათ მარტივად შეხვიდეთ ყველა მათგანში მარყუჟის () ფუნქციაში. C ++ - ში სიგრძის წვდომისა და მასივის სიგრძის ერთი მარტივი გზა მასივის მთლიანი მასის მასივის ელემენტზე გაყოფით, პლუს ერთი ელემენტით. ჩვენ ვაჭერთ ყველა ღილაკს, რომ შევამოწმოთ დაჭერილია თუ არა ერთი.

იმისათვის, რომ ყველაფერი ორგანიზებული იყოს, მე შევინახე ჩემი ღილაკის ყველა მოქმედება იმ ფუნქციის გადამრთველ განცხადებაში, რომელიც იღებს პინ ნომერს არგუმენტად.

თუ გსურთ, რომ თქვენი ღილაკები აკეთებდეს სხვადასხვა რამეს, ან გსურთ დაამატოთ მეტი ღილაკი, უბრალოდ შეცვალეთ doAction ფუნქციის შინაარსი!

იმის გამო, თუ როგორ მუშაობს ფიზიკური ღილაკები, ჩვენ დაგვჭირდება მათი დენონსირება. ეს არის იმისთვის, რომ პროგრამამ არ წაიკითხოს ნებისმიერი არასასურველი პრესი, რომელიც გამოწვეულია ბიძგების ღილაკებით. ამის მრავალი გზა არსებობს, მაგრამ მე დავამატე მარტივი readButton () ფუნქცია, რომელიც ზრუნავს ამაზე.

უბრალოდ მიამაგრეთ თქვენი ღილაკები 10 ათასი რეზისტორით და თქვენ გახდებით ოქროსფერი!

ნაბიჯი 3: პოტენომეტრი

ახლა გადავიდეთ ქვაბზე:

#ჩართეთ

int აკრიფეთ 0 = 0; void setup () {// განათავსეთ თქვენი დაყენების კოდი აქ, ერთხელ გასაშვებად: Serial.begin (9600); კლავიატურა. დაწყება (); // აკრიფეთ dial0 = analogRead (0); dial0 = რუკა (dial0, 0, 1023, 1, 20); } void dialAction (int dial, int newVal, int lastVal) {switch (dial) {// Opacity case 0: delay (200); if (newVal! = lastVal) {int decim = ((newVal*5)/10); int ერთეული = ((newVal *5)% 10); if (newVal == 20) {Keyboard.write (48+0); Keyboard.write (48+0); Serial.println ("მაქსიმალური აკრიფეთ 1"); } else {decim = შეზღუდვა (ათწილადი, 0, 9); ერთეული = შეზღუდვა (ერთეული, 0, 9); Serial.println (newVal*2); Keyboard.write (48+ათწილადი); Keyboard.write (48+ერთეული); }} dial0 = newVal; შესვენება; ნაგულისხმევი: შესვენება; }} // ------------------ მთავარი მარყუჟი ------------------------- ბათილია loop () {// განათავსეთ თქვენი ძირითადი კოდი აქ, განმეორებით გასაშვებად: // Opacity // delay (500); int val0 = analogRead (0); val0 = რუკა (val0, 0, 1023, 1, 20); //Serial.print ("dial0:"); //Serial.println(val0); თუ (val0! = dial0) {// გააკეთე რამე dialAction (0, val0, dial0); }}

პოტმეტრი იმავე ლოგიკას ემორჩილება, მაგრამ ის ცოტა უფრო რთულია.

ჯერ მოდით შევხედოთ როგორ გვინდა რომ ის იმუშაოს: Photoshop– ს აქვს რამდენიმე მოსახერხებელი კომბინაცია ფუნჯის გამჭვირვალეობის შესაცვლელად. თუ რომელიმე ნომერ ღილაკს დააჭერთ, გამჭვირვალეობა გაუტოლდება ამ რიცხვს*10. თუ დააჭერთ ორ რიცხვს, ის წაიკითხავს მეორე რიცხვს, როგორც ერთეულს, რაც უფრო ზუსტ კონტროლს მოგცემთ.

ასე რომ, ჩვენ გვინდა, რომ ჩვენმა პოტერმეტრმა დაადგინოს მისი ბრუნვა პროცენტულად, მაგრამ ჩვენ არ გვინდა ამის გაკეთება მუდმივად, რადგან ეს სულელური იქნება. ჩვენ გვსურს შევიცვალოთ გამჭვირვალეობა მხოლოდ მაშინ, როდესაც პოტმეტრი ბრუნავს. ასე რომ, ჩვენ ვინახავთ დამატებით მნიშვნელობას, რომელსაც ვადარებთ analogRead () მნიშვნელობას და ვუშვებთ სამოქმედო სკრიპტს მხოლოდ მაშინ, როცა სხვაობაა.

სხვა საკითხი, რომელსაც ჩვენ გადავეყრებით არის ის, თუ როგორ ვაქციოთ analogRead– ის დაბრუნება int, როგორც შეყვანა. ვინაიდან არ არის ადვილი გზა int- ს სტრიქონად გადაქცევა, ჩვენ თვითონ უნდა გამოვიყენოთ int. თუმცა, თუ თქვენ უბრალოდ დაწერთ Keyboard.press (int) შეამჩნევთ, რომ შეყვანა არ იქნება ის, რაც გინდოდათ, და სამაგიეროდ სხვა გასაღები დაჭერილი იქნება.

ეს იმიტომ ხდება, რომ თქვენი კლავიატურის კლავიშები დაშიფრულია როგორც მთელი რიცხვები, თითოეულ კლავიშს აქვს თავისი ინდექსი. რიცხვითი გასაღების სწორად გამოსაყენებლად, თქვენ უნდა მოძებნოთ მათი ინდექსი ASCII ცხრილში:

როგორც ხედავთ, რიცხვითი კლავიშები იწყება 48 -ე ინდექსით. ასე რომ, სწორი ღილაკის დასაჭერად, ყველაფერი რაც ჩვენ უნდა გავაკეთოთ არის აკრიფეთ 48 -ის მნიშვნელობა. ათობითი და ერთეულის მნიშვნელობები ცალკეული პრესებია.

დაბოლოს, ჩვენ გვჭირდება გზა, რომ დავიცვათ მნიშვნელობა წინ და უკან გადახტომიდან. თუ თქვენ ცდილობთ გამოიყენოთ ციფერბლატი რუქით (val0, 0, 1023, 0, 100), თქვენ ნახავთ, რომ შედეგები ძალიან დამღლელია. მსგავსად იმისა, თუ როგორ გამოვაღწიეთ ღილაკები, ჩვენ ამას გამოვასწორებთ გარკვეული სიზუსტის შეწირვით. აღმოვაჩინე, რომ მისი 1-20-ზე გამოსახვა და შემდეგ არგუმენტების მნიშვნელობის გამრავლება 5-ით მისაღები კომპრომისია.

პოტენომეტრის დასაკავშირებლად, უბრალოდ შეაერთეთ 5V მავთული, დასაკავშირებელი მავთული და ანალოგური შეყვანის მავთული და არანაირი პრობლემა არ უნდა წარმოიშვას.

სახალისო ფაქტი: თუ თქვენ იყენებთ ამ მალსახმობას მაშინ, როდესაც შერჩეულია ისეთი ინსტრუმენტი, როგორიც არის Lasso, ის შეცვლის ფენის გამჭვირვალობას. რაღაც გასათვალისწინებელია.

ნაბიჯი 4: Rotary Encoder

მბრუნავი კოდირები ოდნავ ჰგავს პოტენომეტრებს, მაგრამ შეზღუდვის გარეშე რამდენად შეუძლიათ მათი შემობრუნება. ანალოგური მნიშვნელობის ნაცვლად, ჩვენ შევხედავთ კოდირების შემობრუნების მიმართულებას ციფრულად. მე არ შევალ დეტალურად, თუ როგორ მუშაობს ეს, მაგრამ რაც თქვენ უნდა იცოდეთ არის ის, რომ ის იყენებს ორ შესასვლელს arduino– ზე, რომ გითხრათ რომელი მიმართულებით არის ის შემობრუნებული. მბრუნავი კოდირების დამუშავება შეიძლება იყოს უფრო რთული, სხვადასხვა შიფრატორს შეიძლება დასჭირდეს განსხვავებული კონფიგურაცია. საქმის გასაადვილებლად, მე ვიყიდე ერთი PCB, რომელიც მზადაა დაიმაგროს ქალი ქინძისთავებით. ახლა, კოდი:

#ჩართეთ

// მბრუნავი კოდირება #განსაზღვრეთ გამომავალი A 15 #განსაზღვრეთ გამომუშავება B 14 int counter = 0; სახელმწიფოში; int aLastState; void setup () {// განათავსეთ თქვენი კონფიგურაციის კოდი აქ, ერთხელ გასაშვებად: // Rotary pinMode (outputA, INPUT); pinMode (გამომავალი B, INPUT); // კითხულობს outputA– ს საწყის მდგომარეობას a aLastState = digitalRead (outputA); } void rotaryAction (int dir) {if (dir> 0) {Keyboard.press (']'); } else {Keyboard.press ('['); } Keyboard.releaseAll (); } // ------------------ MAIN LOOP ------------------------- ბათილი მარყუჟი () {// განათავსეთ თქვენი ძირითადი კოდი აქ, განმეორებით გასაშვებად: // ზომა aState = digitalRead (outputA); if (aState! = aLastState) {if (digitalRead (outputB)! = aState) {// counter ++; მბრუნავი მოქმედება (1); } else {// counter -; მბრუნავი მოქმედება (-1); } //Serial.print(" პოზიცია: "); //Serial.println (counter); } aLastState = aState; }

სტანდარტულად, Photoshop- ის] და [მალსახმობები ზრდის და ამცირებს ფუნჯის ზომას. ისევე, როგორც ადრე, ჩვენ გვსურს შევიტანოთ ისინი როგორც კლავიშთა დაჭერა. კოდირება აგზავნის უამრავ შეყვანას ერთ შემობრუნებაზე (რაც დამოკიდებულია მოდელზე) და ჩვენ გვსურს გავზარდოთ/შევამციროთ ფუნჯის ზომა თითოეული ამ შეყვანისთვის, ასე რომ თქვენ შეგიძლიათ სწრაფად აკრიფოთ მაღლა ან ქვემოთ, მაგრამ ასევე შეძლოთ აკონტროლეთ იგი ნელა დიდი სიზუსტით.

ისევე როგორც პოტმეტრთან, ჩვენ გვსურს მოქმედების გაშვება მხოლოდ მაშინ, როდესაც ციფერბლატი ბრუნავს. პოტმეტრისგან განსხვავებით, როგორც ადრე ავუხსენი, მბრუნავ კოდირებას აქვს ორი მონაცვლე შეყვანა. ჩვენ ვუყურებთ, რომელი მათგანი შეიცვალა იმისათვის, რომ დადგინდეს ის მიმართულება, რომლის მიხედვითაც ხდება ციფერბლატი.

შემდეგ მიმართულებიდან გამომდინარე, ჩვენ ვაჭერთ სწორ ღილაკს.

სანამ არ გაქვთ საკონტაქტო საკითხები, ის უნდა იმუშაოს.

ნაბიჯი 5: შეაჯამეთ ეს ყველაფერი ერთად

ახლა გადატანა soldering. პირველ რიგში, ჩვენ ორ ხვრელს ვჭრით პერფოფში, რათა მოთავსდეს ორი ციფერბლატი. ჩვენ შევაერთეთ ღილაკები და მათი შესაბამისი რეზისტორები. მე გავხსენი ორი დამატებითი პატარა ხვრელი, რომ შემეშვებინა მავთულები ზემოდან, რომ დაზოგოთ სივრცე, მაგრამ ეს არ არის აუცილებელი. არ არის ბევრი შეყვანის მავთული, ამიტომ GND და 5V მავთულები პარალელურად გადის, მაგრამ თუ თავს ოსტატურად გრძნობთ, შეიძლება დაგჭირდეთ მატრიცის გაკეთება. მე მიკროკონტროლი გავამაგრე სხვა, უფრო პატარა დაფაზე, რომელიც ქვემოთ მოთავსებულია კოდირებისა და პოტმეტრის გვერდით. ახლა გავაფორმე ყველა მავთული ProMicro- ს. არ არის საჭირო შემოქმედებითობა, მე უბრალოდ უნდა შევასრულო იგივე სქემა, როგორც პურის დაფაზე, მაგრამ ასეთ პატარა ადგილას შედუღება გასაგებია მოსაწყენი. ნუ იქნები ჩემნაირი, გამოიყენე მავთულის სტრიპტიზიორი და კარგი შესაკრავი!

დაბოლოს, შეიძლება დაგჭირდეთ ლამაზი შემთხვევის გაკეთება თქვენი ახალი Photoshop მეგობრისთვის. ერთი ჩემზე უკეთესი, ყოველ შემთხვევაში!

მაგრამ თუ დიდი სურვილი გაქვთ სცადოთ, გამოიყენეთ მუყაო და ლენტი და შეაერთეთ თქვენი მიკრო USB.

ნაბიჯი 6: კოდი + დემონსტრაცია

დარწმუნდით, რომ შეამოწმეთ საკონტროლო ბადის პროგრამა, როდესაც თქვენ გადადიხართ პროექტში, რათა თავიდან აიცილოთ სიურპრიზები!

აქ არის სრული კოდი:

დიდი მადლობა რომ კითხულობ!