შეხების მოცულობა/ამბილაცია: 8 ნაბიჯი

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

ეს სასწავლო არის ჩემი გამოცდილების სწრაფი ჩაწერა მრავალფუნქციური განწყობის შესაქმნელად. ელექტრონული სქემების ზოგიერთი ძირითადი ცოდნაა მოსალოდნელი. პროექტი ჯერ არ დასრულებულა, გარკვეული ფუნქციონირება და შესწორება უნდა გაკეთდეს, მაგრამ ის უკვე ფუნქციონირებს. თუ თქვენ ხართ აღფრთოვანებული ამ ინსტრუქციის შესახებ, მე განვაახლებ მას. სისტემის გულში არის Arduino. ის დაამუშავებს USB– ის ან თითოეული Capacitive touch შეყვანის შეყვანას და გააკონტროლებს RGB შუქს. ეს ინსტრუქცია დაყოფილია სამ ნაწილად:- კაპიტალური შეხების განყოფილება მოიცავს უხილავ შეყვანის ღილაკებს- განწყობის განათების განყოფილება მოიცავს განწყობის კონტროლს უარი პასუხისმგებლობაზე: ელექტრონიკა შეიძლება იყოს საშიში, თქვენ თვითონ ხართ პასუხისმგებელი მიყენებულ ნებისმიერ დაზიანებაზე. ზოგიერთი კოდი გროვდება ფორუმებიდან და შეიძლება არ შეიცავდეს მისი მფლობელის სახელს. გთხოვთ შემატყობინოთ და დავამატებ თქვენს სახელს.

ნაბიჯი 1: ნივთების სია

შემდეგი კომპონენტები საჭიროა ამ ინსტრუქციისთვის:- Arduino+USB კაბელი- პურის დაფა- კომპიუტერის ელექტრომომარაგება- 3x RGB ზოლები, იხილეთ dealextreme.com.- 3x TIP120 FET, როგორიცაა https://uk.farnell.com/stmicroelectronics/tip120 /darlington-transistor-to-220/dp/9804005- რამოდენიმე რეზისტორი (6 * 10 kiloOhm, 3 * 2 megaOhm)-ბევრი მავთული. - ინსტრუმენტები მოცულობის შეხება- ლითონის რგოლები იატაკისთვის- სპილენძის მავთულები ან ფირფიტები- რაღაც მის შესაქმნელად (როგორც წიგნის თარო:)

ნაბიჯი 2: Capacitive Touch - საფუძვლები და წრე

მას შემდეგ, რაც მე ვხატავდი ჩემს წიგნის თაროებს, მე მქონდა შესაძლებლობა, რომ მეც განმეახლებინა ისინი. მინდოდა განწყობის შუქის გაკონტროლება უხილავი შეხებით. თავიდან, ჩემი გეგმა იყო ამისათვის გამოყოფილი IC- ის გამოყენება (Atmel QT240- ის მსგავსად). მაგრამ შემდეგ მე წავაწყდი გვერდს, სადაც განმარტა, რომ Arduino– ს შეუძლია სიმულაციური სენსორის პროგრამული უზრუნველყოფის ემულაცია. ელექტრონული წრე შეიძლება ნახოთ სურათზე, სენსორი არის სპილენძის მავთული (მხოლოდ ერთი ნაჩვენებია სიმარტივისთვის). მგრძნობელობა კონტროლდება რეზისტორებით, რომლებიც ნაპოვნია ყოველი ბუდის წინ. მათი დიაპაზონი შეიძლება იყოს 1 მეგაჰომიდან (აბსოლუტური შეხება) 40 მეგაჰომამდე (12-24 ინჩი მოშორებით) იმისდა მიხედვით, საჭიროა თუ არა აბსოლუტური ან ახლო შეხება (მე დავამთავრე 2 მ Ohm რეზისტორების გამოყენებით). ექსპერიმენტი გააკეთეთ ღირებულებებამდე, სანამ სენსორი არ მოიქცევა როგორც სასურველი. კარგი იდეაა დააყენოთ გამტარი ზედაპირი (გამოყოფილია თხელი არაგამტარი ნაჭერით), რომელიც დაკავშირებულია სქემების მიწასთან თითოეული სპირალის უკანა ნაწილში. ამ გზით სენსორები იქნება უფრო სტაბილური და ნაკლებად იმოქმედებს ხმაურზე. კიდევ რამდენიმე სურათი სენსორების დაყენების შესახებ წიგნის თაროზე. ასევე დამონტაჟებულია დანამატი, რომელიც მოგვიანებით შეუერთდება წრეს. შემავსებელი გამოიყენება ყველაფრის დასამალად და ამის შემდეგ ისინი მზად არიან შეღებვისთვის.

ნაბიჯი 3: Capacitive Touch - კოდი და ტესტირება

შემდეგი წყაროს კოდი შეიძლება გამოყენებულ იქნას Arduino– ზე გამართვისთვის, შეამოწმეთ მნიშვნელობები arduino სერიული მონიტორით. იქმნება ექვსი მნიშვნელობა. პირველი არის სისტემის მუშაობის მაჩვენებელი. მეორედან მეექვსემდე არის შეგრძნებული მნიშვნელობები ყველა პინზე. ღირებულებები უნდა გაიზარდოს თითთან ახლოს. თუ არა, შეამოწმეთ ცუდი კავშირები და ჩარევა. რეზისტორის მნიშვნელობები შეიძლება შეიცვალოს მგრძნობელობის დასადგენად. თუ შემდეგ სტრუქტურის დანერგვით, რომელიც გააქტიურებულია გარკვეულ ლოგიკურ ზღურბლზე, შეიძლება მოხდეს გადართვა. ეს იქნება გამოყენებული არდუინოს საბოლოო კოდში. დამატებითი ინფორმაცია, წაკითხვა შესთავაზა: https://www.arduino.cc/playground/Main/CapSense--- Arduino CapTouch გამართვის კოდი ---#მოიცავს void setup () {CapSense cs_2_3 = CapSense (2, 4); // 10 მ რეზისტორი ქინძისთავებს შორის 2 და 4, პინ 4 არის სენსორის პინი, დაამატეთ მავთული, foilCapSense cs_2_4 = CapSense (2, 7); // 10 მ რეზისტორი ქინძისთავებს შორის 2 და 7, პინ 7 არის სენსორის პინი, დაამატეთ მავთული, foilCapSense cs_2_5 = CapSense (2, 8); // 10 მ რეზისტორი ქინძისთავებს შორის 2 და 8, პინ 8 არის სენსორის პინი, დაამატეთ მავთული, foilCapSense cs_2_6 = CapSense (2, 12); // 10 მ რეზისტორი ქინძისთავებს შორის 2 და 12, პინ 12 არის სენსორის პინი, დაამატეთ მავთული, foilCapSense cs_2_7 = CapSense (2, 13); // 10M რეზისტორი ქინძისთავებს შორის 2 და 13, პინ 13 არის სენსორის პინი, დაამატეთ მავთული, foilvoid setup () {Serial.begin (9600);} void loop () {long start = millis (); ხანგრძლივი სულ 1 = cs_2_3.capSense (30); ხანგრძლივი სულ 2 = cs_2_4.capSense (30); ხანგრძლივი სულ 3 = cs_2_5.capSense (30); ხანგრძლივი სულ 4 = cs_2_6.capSense (30); ხანგრძლივი სულ 5 = cs_2_7.capSense (30); Serial.print (millis () - დაწყება); // შეამოწმეთ შესრულება მილიწამებში Serial.print ("\ t"); // ჩანართის ხასიათი გამართვისათვის windown spacing Serial.print (total1); // ბეჭდვის სენსორის გამომავალი 1 Serial.print ("\ t"); სერიული. ბეჭდვა (სულ 2); // ბეჭდვის სენსორის გამომავალი 2 Serial.print ("\ t"); სერიული. ბეჭდვა (სულ 3); // ბეჭდვის სენსორის გამომავალი 3 Serial.print ("\ t"); სერიული. ბეჭდვა (სულ 4); // ბეჭდვის სენსორის გამომავალი 4 Serial.print ("\ t"); Serial.println (სულ 5); // ბეჭდვის სენსორის გამომავალი 5 დაყოვნება (10); // თვითნებური შეფერხება მონაცემების სერიულ პორტზე შეზღუდვისათვის} --- END ---

ნაბიჯი 4: განწყობის შუქი - საფუძვლები და წრე

ახლა დროა ავაშენოთ სისტემის გამომავალი ნაწილი. Arduino– ს PWM ქინძისთავები გამოყენებული იქნება თითოეული ფერის გასაკონტროლებლად. PWM ნიშნავს პულსის სიგანის მოდულაციას, ძალიან სწრაფად ჩართვის და გამორთვისას led- ები დაბნელდება 0 -დან 255 -მდე. ყველა პინი გაძლიერდება FET– ით. ჯერჯერობით, სისტემას აქვს მხოლოდ ერთი არხი თითო ფერიზე, რაც იმას ნიშნავს, რომ ყველა RGB ზოლები ერთდროულად იქნება კონტროლირებული და საჭიროა 3 PWM ქინძისთავები (ერთი ყველა ფერისთვის). მომავალში მინდა შევძლო ჩემი ოთხი RGB ზოლის გაკონტროლება. ეს ნიშნავს 4*3 = 12 PWM ქინძისთავს (და ალბათ Arduino Mega). კარგი, დროა რამდენიმე სქემისთვის! ეს (იხ. სურათი) არის სქემის ძირითადი წარმოდგენა (მალე გახდება უფრო ლამაზი). ასევე მოთავსებულია ტევადობის სენსორები (მწვანე ნაწილი). ძირითადად არის სამი კომპონენტი, რომელიც უნდა აიხსნას:- FET ეს არის გამაძლიერებელი, რომელზეც ვსაუბრობდი. მას აქვს კარიბჭე, წყარო და სანიაღვრე. ის აძლიერებს გრძნობს კარიბჭეზე არსებულ მცირე დენს (დაკავშირებულია არდუინოსთან) და ხსნის გზას RGB ზოლისთვის, რომელიც მოძრაობს 12 ვოლტზე. წყარო უნდა იყოს +12V- ზე, გადინება GND- ზე (Ground). შეამოწმეთ თქვენი FET– ის სპეციფიკაციების ფურცელი ზუსტი დასადგენად. თითოეული RGB არხი უნდა იყოს პოზიციონირებული საკუთარ FET– მდე. ამ თვალსაზრისით, ის მოქმედებს როგორც Arduino კონტროლირებადი გადამრთველი.- RGB ზოლები ეს 12 ვოლტიანი RGB ზოლები არის საერთო ანოდის (+) ტიპის. რაც იმას ნიშნავს, რომ საერთო მავთული უნდა იყოს დაკავშირებული +12 ვ -თან და დენი იძირება თითოეული ცალკეული ფერის არხის საშუალებით. ზოლს აქვს რეზისტორები, ასე რომ არ ინერვიულოთ ამაზე! სამი სხვა ზღუდავს FET– ის მაქსიმალურ დენს. ზედა სამი რეზისტორი უკვე RGB ზოლშია. მე შევაერთე USB კაბელები RGB ზოლებზე, ასე რომ მე შემიძლია მარტივად შევაერთო ისინი. ძველი კერადან დანამატები მოთავსებულია ჩემს პურის დაფაზე. გამოიყენეთ ძველი კომპიუტერის ელექტრომომარაგება წვენისთვის, 12V RGB ზოლის გასაძლიერებლად და საბოლოოდ 5V წრედისთვის, თუ გსურთ რომ ის USB კაბელის გარეშე იმუშაოს.

ნაბიჯი 5: განწყობის შუქი - კოდი და კონტროლი

განწყობის შუქი კონტროლდება capacitive სენსორების მიერ. ჯერჯერობით, მე მხოლოდ დაპროგრამებული სენსორები 2 და 3 ფერის შეცვლისთვის. სხვა სენსორებს ჯერ არ აქვთ ფუნქცია. აქ არის კოდი: --- Arduino განწყობის კონტროლის კოდი ---#მოიცავს const ლოგიკური ინვერტირება = true; const long timeout = 10000; // Capacitive სენსორის დეკლარაცია CapSense In1 = CapSense (2, 4); // 2M რეზისტორი ქინძისთავებს შორის 4 და 2, პინ 2 არის სენსორის პინი, დაამატეთ მავთული, foilCapSense In2 = CapSense (2, 7); // 2M რეზისტორი ქინძისთავებს შორის 4 და 6, პინ 6 არის სენსორის პინი, დაამატეთ მავთული, foilCapSense In3 = CapSense (2, 8); // 2 მ რეზისტორი ქინძისთავებს შორის 4 და 8, პინ 8 არის სენსორის პინი, დაამატეთ მავთული, foilCapSense In4 = CapSense (2, 12); // 2M რეზისტორი ქინძისთავებს შორის 4 და 8, პინი 8 არის სენსორის პინი, დაამატეთ მავთული, foilCapSense In5 = CapSense (2, 13); // 2M რეზისტორი ქინძისთავებს შორის 4 და 8, პინი 8 არის სენსორის პინი, დაამატეთ მავთული, კილიტა // PWM Pin დეკლარაციები PinR1 = 3; int PinG1 = 5; int PinB1 = 6; // სხვა ცვლადები ფერი 1 = 128; // იწყება წითელი ფერის მსგავსი Brightness1 = 255; // სრული სიკაშკაშის დაწყება RedValue1, GreenValue1, BlueValue1; // RGB კომპონენტები თავიდან აცილების კონფიგურაცია () {// სენსორის დროის ამოწურვის მნიშვნელობების დადგენა In1.set_CS_AutocaL_Millis (დროის გასვლა); In2.set_CS_AutocaL_Millis (ტაიმუატი); In3.set_CS_AutocaL_Millis (ტაიმუატი); In4.set_CS_AutocaL_Millis (ტაიმუატი); In5.set_CS_AutocaL_Millis (დროის გასვლა);} void loop () {long start = millis (); ხანგრძლივი სულ 1 = In1.capSense (30); ხანგრძლივი სულ 2 = In2.capSense (30); ხანგრძლივი სულ 3 = In3.capSense (30); ხანგრძლივი სულ 4 = In4.capSense (30); ხანგრძლივი სულ 5 = In5.capSense (30); if (სულ 2> 150) {ფერი 1 ++; // ფერის გაზრდა if (ფერი 1> 255) {// ფერი 1 = 0; }} else if (total3> 200) {ფერი 1--; // შეამცირეთ ფერი if (ფერი 1 <0) {// ფერი 1 = 255; } // შეცვალე ელფერი rgb hueToRGB (ფერი 1, სიკაშკაშე 1); // ჩაწერეთ ფერები PWM ქინძისთავებზე analogWrite (PinR1, RedValue1); analogWrite (PinG1, GreenValue1); analogWrite (PinB1, BlueValue1);} // ფუნქცია ფერის გადასაყვანად მის წითელ, მწვანე და ცისფერ კომპონენტებზე. მოხსნა hueToRGB (int hue, int brightness) {unsigned int scaledHue = (hue * 6); ხელმოუწერელი int სეგმენტი = scaledHue / 256; // სეგმენტი 0 -დან 5 -მდე ფერადი ბორბლის გარშემო ხელმოუწერელი int segmentOffset = scaledHue - (სეგმენტი * 256); // პოზიცია სეგმენტის შიგნით ხელმოუწერელი int კომპლიმენტი = 0; ხელმოუწერელი int prev = (სიკაშკაშე * (255 - segmentOffset)) / 256; ხელმოუწერელი int შემდეგი = (სიკაშკაშე * segmentOffset) / 256; თუ (ინვერსიული) {სიკაშკაშე = 255-სიკაშკაშე; კომპლიმენტი = 255; წინა = 255-წინა; შემდეგი = 255-შემდეგი; } გადამრთველი (სეგმენტი) {შემთხვევა 0: // წითელი RedValue1 = სიკაშკაშე; GreenValue1 = შემდეგი; BlueValue1 = კომპლიმენტი; შესვენება; შემთხვევა 1: // ყვითელი RedValue1 = წინა; GreenValue1 = სიკაშკაშე; BlueValue1 = კომპლიმენტი; შესვენება; შემთხვევა 2: // მწვანე RedValue1 = კომპლიმენტი; GreenValue1 = სიკაშკაშე; BlueValue1 = შემდეგი; შესვენება; შემთხვევა 3: // ცისფერი RedValue1 = კომპლიმენტი; GreenValue1 = წინა; BlueValue1 = სიკაშკაშე; შესვენება; შემთხვევა 4: // ლურჯი RedValue1 = შემდეგი; GreenValue1 = კომპლიმენტი; BlueValue1 = სიკაშკაშე; შესვენება; შემთხვევა 5: // მაგენტა ნაგულისხმევი: RedValue1 = სიკაშკაშე; GreenValue1 = კომპლიმენტი; BlueValue1 = წინა; შესვენება; }}--- ᲓᲐᲡᲐᲡᲠᲣᲚᲘ ---

ნაბიჯი 6: Ambi Light - Arduino Side

რა თქმა უნდა, სრულიად მაგარი იქნება, რომ შეძლოთ გააკონტროლოთ თქვენი კომპიუტერის განწყობის შუქი. მაგალითად, ამბილატის ან ხმის კონტროლირებადი დისკოს შესაქმნელად. ეს განყოფილება ფოკუსირებულია ამბილაიტ ნაწილზე, მომავალში მე დავამატებ უფრო მეტ ფუნქციურობას. ისე, არ არის დამატებითი სქემა, რადგან ეს ყველაფერი შესაძლებელია Arduino– ში. რასაც ჩვენ ვაპირებთ გამოვიყენოთ არის სერიული კომუნიკაციის შესაძლებლობები და ზოგიერთი '1.0 დამუშავების' პროგრამული უზრუნველყოფა. შეაერთეთ თქვენი arduino თქვენს კომპიუტერში USB კაბელის საშუალებით (თუ თქვენ ატვირთავდით ესკიზებს, ეს უკვე არის). არდუინოსთვის, თქვენ უნდა დაამატოთ დამატებითი კოდი სერიული კომუნიკაციისთვის. კოდი გადადის მოსმენის რეჟიმში, ტევადი სენსორების გადაბრუნებამდე, სანამ ის მიიღებს RGB მნიშვნელობებს კომპიუტერიდან. შემდეგ ადგენს RGB მნიშვნელობებს PWM ქინძისთავებზე. ეს არის ჩემი საბოლოო კოდი ახლავე, შეამოწმეთ ცვლილებები: --- Arduino Ambilight Code ---#მოიცავს const boolean invert = true; const long timeout = 10000; long commStart = 0; char val; // Capacitive sensor statementCapSense In1 = CapSense (2, 4); // 2M რეზისტორი ქინძისთავებს შორის 4 და 2, პინ 2 არის სენსორის პინი, დაამატეთ მავთული, foilCapSense In2 = CapSense (2, 7); // 2M რეზისტორი ქინძისთავებს შორის 4 და 6, პინ 6 არის სენსორის პინი, დაამატეთ მავთული, foilCapSense In3 = CapSense (2, 8); // 2 მ რეზისტორი ქინძისთავებს შორის 4 და 8, პინ 8 არის სენსორის პინი, დაამატეთ მავთული, foilCapSense In4 = CapSense (2, 12); // 2M რეზისტორი ქინძისთავებს შორის 4 და 8, პინ 8 არის სენსორის პინი, დაამატეთ მავთული, foilCapSense In5 = CapSense (2, 13); // 2M რეზისტორი ქინძისთავებს შორის 4 და 8, პინი 8 არის სენსორის პინი, დაამატეთ მავთული, კილიტა // PWM Pin დეკლარაციები PinR1 = 3; int PinG1 = 5; int PinB1 = 6; // სხვა ცვლადები ფერი 1 = 128; // იწყება წითელი ფერის მსგავსი Brightness1 = 255; // სრული სიკაშკაშის დაწყება RedValue1, GreenValue1, BlueValue1; // RGB კომპონენტების განთავისუფლების კონფიგურაცია () {Serial.begin (9600); // სერიული კომუნიკაციის დაწყება // სენსორის დროის ამოწურვის მნიშვნელობების დაყენება In1.set_CS_AutocaL_Millis (დროის გასვლა); In2.set_CS_AutocaL_Millis (ტაიმუატი); In3.set_CS_AutocaL_Millis (ტაიმუატი); In4.set_CS_AutocaL_Millis (ტაიმუატი); In5.set_CS_AutocaL_Millis (დროის გასვლა);} void loop () {long start = millis (); ხანგრძლივი სულ 1 = In1.capSense (30); ხანგრძლივი სულ 2 = In2.capSense (30); ხანგრძლივი სულ 3 = In3.capSense (30); ხანგრძლივი სულ 4 = In4.capSense (30); ხანგრძლივი სულ 5 = In5.capSense (30); if (Serial.available ()) {// თუ მონაცემები ხელმისაწვდომია წასაკითხად, val = Serial.read (); // წაიკითხეთ და შეინახეთ val commStart = millis (); if (val == 'S') {// თუ ჩარტი იწყება, მაშინ როცა (! Serial.available ()) {} // დაელოდეთ შემდეგ მნიშვნელობას. RedValue1 = Serial.read (); // მას შემდეგ რაც ხელმისაწვდომი იქნება, მიანიჭეთ. ხოლო (! Serial.available ()) {} // იგივე, რაც ზემოთ. GreenValue1 = Serial.read (); ხოლო (! Serial.available ()) {} BlueValue1 = Serial.read (); } Serial.print (RedValue1); Serial.print (GreenValue1); Serial.println (BlueValue1); } else if ((millis () - commStart)> 1000) {if (სულ 2> 150) {ფერი 1 ++; // ფერის გაზრდა if (ფერი 1> 255) {// ფერი 1 = 0; }} else if (total3> 200) {ფერი 1--; // შეამცირეთ ფერი if (ფერი 1 <0) {// ფერი 1 = 255; }} hueToRGB (ფერი 1, სიკაშკაშე 1); } analogWrite (PinR1, RedValue1); analogWrite (PinG1, GreenValue1); analogWrite (PinB1, BlueValue1);} // ფუნქცია ფერის გადასაყვანად მის წითელ, მწვანე და ცისფერ კომპონენტებზე. მოხსენი hueToRGB (int hue, int brightness) {unsigned int scaledHue = (hue * 6); ხელმოუწერელი int სეგმენტი = scaledHue / 256; // სეგმენტი 0 -დან 5 -მდე ფერადი ბორბლის გარშემო ხელმოუწერელი int segmentOffset = scaledHue - (სეგმენტი * 256); // პოზიცია სეგმენტის შიგნით ხელმოუწერელი int კომპლიმენტი = 0; ხელმოუწერელი int prev = (სიკაშკაშე * (255 - segmentOffset)) / 256; ხელმოუწერელი int შემდეგი = (სიკაშკაშე * segmentOffset) / 256; თუ (ინვერსიული) {სიკაშკაშე = 255-სიკაშკაშე; კომპლიმენტი = 255; წინა = 255-წინა; შემდეგი = 255-შემდეგი; } გადამრთველი (სეგმენტი) {შემთხვევა 0: // წითელი RedValue1 = სიკაშკაშე; GreenValue1 = შემდეგი; BlueValue1 = კომპლიმენტი; შესვენება; შემთხვევა 1: // ყვითელი RedValue1 = წინა; GreenValue1 = სიკაშკაშე; BlueValue1 = კომპლიმენტი; შესვენება; შემთხვევა 2: // მწვანე RedValue1 = კომპლიმენტი; GreenValue1 = სიკაშკაშე; BlueValue1 = შემდეგი; შესვენება; შემთხვევა 3: // ცისფერი RedValue1 = კომპლიმენტი; GreenValue1 = წინა; BlueValue1 = სიკაშკაშე; შესვენება; შემთხვევა 4: // ლურჯი RedValue1 = შემდეგი; GreenValue1 = კომპლიმენტი; BlueValue1 = სიკაშკაშე; შესვენება; საქმე 5: // მაგენტა ნაგულისხმევი: RedValue1 = სიკაშკაშე; GreenValue1 = კომპლიმენტი; BlueValue1 = წინა; შესვენება; }}--- ᲓᲐᲡᲐᲡᲠᲣᲚᲘ ---

ნაბიჯი 7: Ambi Light - კომპიუტერის გვერდი

კომპიუტერის გვერდით არის გაშვებული Processing 1.0 ესკიზი, იხილეთ processing.org. ეს პატარა (გარკვეულწილად არეული) პროგრამა ითვლის საშუალო ეკრანის ფერს ყოველ მომენტში და აგზავნის მას სერიულ პორტში. ის ჯერჯერობით ძალიან ფუნდამენტურია და მას შეუძლია შეცვალოს გარკვეული ცვლილებები, მაგრამ ის ძალიან კარგად მუშაობს! მე მას მომავალში განვაახლებ რამოდენიმე ცალკეულ RGB ზოლისა და ეკრანის განყოფილებისთვის. თქვენ ასევე შეგიძლიათ ამის გაკეთება საკუთარ თავს, ენა საკმაოდ მარტივია. აქ არის კოდი: --- 1.0 კოდის დამუშავება --- იმპორტის დამუშავება. სერიალი.*; იმპორტი java.awt. AWTException; იმპორტი java.awt. Robot; იმპორტი java.awt. Rectangle; იმპორტი java.awt.image. BufferedImage; PImage screenShot; Serial myPort; static public void main (სიმებიანი არგები ) {PApplet.main (new String {"-present", "shooter"});} void setup () {size (100, 100); // ზომა (ეკრანი. სიგანე, ეკრანი. სიმაღლე); // დაბეჭდეთ სერიული პორტების სია, გამართვის მიზნით: println (Serial.list ()); // მე ვიცი, რომ სერიული სიის პირველი პორტი ჩემს mac //– ში ყოველთვის არის ჩემი FTDI ადაპტერი, ამიტომ ვხსნი Serial.list () [0] - ს. // Windows აპარატებზე, ეს ჩვეულებრივ ხსნის COM1- ს. // გახსენით ნებისმიერი პორტი, რომელსაც თქვენ იყენებთ. სიმებიანი portName = Serial.list () [0]; myPort = ახალი სერიალი (ეს, portName, 9600);} ბათილად გათამაშება () {// სურათი (ეკრანის გადაღება, 0, 0, სიგანე, სიმაღლე); screenShot = getScreen (); ფერი kleur = ფერი (0, 0, 0); kleur = ფერი (ეკრანის სურათი); //myPort.write(int(red(kleur))++ ','+int (მწვანე (kleur))+','+int (ლურჯი (kleur))+13); //myPort.write(int(red(kleur))); //myPort.write (','); //myPort.write(int(green(kleur))); //myPort.write (','); //myPort.write(int(blue(kleur))); //myPort.write(13); შევსება (kleur); rect (30, 20, 55, 55);} ფერის ფერი (სურათი img) {int cols = (img.width); int რიგები = (img. სიმაღლე); int განზომილება = (img. სიგანე*img. სიმაღლე); int r = 0; int g = 0; int b = 0; img.loadPixels (); // Ga elke pixel langs (dimension) for (int i = 0; i <(dimension/2); i ++) {r = r+((img.pixels >> 16) & 0xFF); g = g + ((img.pixels >> 8) & 0xFF); b = b + (img.pixels & 0xFF);} int საშუალო_r = r/(განზომილება/2); int საშუალო_g = g/(განზომილება/2); int საშუალო_b = b/(განზომილება/2); ფერი mean_clr = ფერი (mean_r, mean_g, mean_b); myPort.write ('S'); myPort.write (mean_r); myPort.write (mean_g); myPort.write (mean_b); return (mean_clr);} PImage getScreen () {GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment (); GraphicsDevice gs = ge.getScreenDevices (); DisplayMode რეჟიმი = gs [0].getDisplayMode (); მართკუთხედის საზღვრები = ახალი მართკუთხედი (0, 0, mode.getWidth (), mode.getHeight ()); BufferedImage desktop = new BufferedImage (mode.getWidth (), mode.getHeight (), BufferedImage. TYPE_INT_RGB); სცადეთ {desktop = new Robot (gs [0]). createScreenCapture (საზღვრები); } catch (AWTException e) {System.err.println ("ეკრანის გადაღება ვერ მოხერხდა."); } დაბრუნება (ახალი PImage (სამუშაო მაგიდა));} --- END ---

ნაბიჯი 8: შედეგი

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