Minecraft მცოცავი დეტექტორი: 6 ნაბიჯი (სურათებით)

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

ავტორი: Allwined დიზაინი

შესახებ: მე მთელი ცხოვრება ვიყავი პროგრამული უზრუნველყოფის შემქმნელი, ვსწავლობდი კომპიუტერულ მეცნიერებებს კოლეჯში 3D გრაფიკაზე ფოკუსირებით, ვიყავი ეფექტების შემსრულებელი Dreamworks Animation– ისთვის და ვასწავლიდი ტექნოლოგიებს ბავშვებსა და მოზარდებს აქ … ვრცლად ყველა დიზაინის შესახებ »

რამდენიმე წლის განმავლობაში, მე ვეხმარებოდი ბოზემანის ბავშვთა მუზეუმს, შეემუშავებინათ სასწავლო პროგრამა მათი STEAMlab– ისთვის. მე ყოველთვის ვეძებდი სახალისო გზებს ბავშვებთან ელექტრონიკითა და კოდირებით. Minecraft არის მარტივი გზა ბავშვების კარებთან მისასვლელად და არსებობს უამრავი რესურსი, რომ გამოიყენოთ იგი სახალისო და საგანმანათლებლო გზებით. Minecraft– ის და ელექტრონიკის გაერთიანება რთული იყო, თუმცა. Arduino– ს პროექტების Minecraft– თან ინტეგრაციის დასახმარებლად, მე განვავითარე ჩემი საკუთარი Minecraft– ის მოდელის სახელწოდებით SerialCraft. იდეა ის იყო, რომ თქვენ შეგიძლიათ შეაერთოთ ნებისმიერი მოწყობილობა, რომელიც იყენებს სერიულ კომუნიკაციას და გააგზავნეთ შეტყობინებები და მიიღეთ შეტყობინებები Minecraft– დან ჩემი მოდიფიკაციის გამოყენებით. Arduinos– ს უმეტესობას შეუძლია სერიული კომუნიკაცია USB– ით, ასე რომ, მარტივია ჩართოთ წრე და გაგზავნოთ გარკვეული მონაცემები სერიულ კავშირზე. მე შევქმენი საკონტროლო კომპლექტი, რომ ბავშვებს შეეძლოთ შეკრება და პროგრამირება, რათა გააკონტროლონ თავიანთი ხასიათი, გამოიწვიონ და უპასუხონ Redstone სიგნალებს, და დახუჭონ LED- ები, რომ გააფრთხილონ მათ გარკვეული მოვლენების შესახებ, როგორიცაა დაბალი სიცოცხლე ან როდესაც მცოცავი ახლოსაა. ეს ინსტრუქცია ყურადღებას ამახვილებს მცოცავი გაფრთხილების ფუნქციონირებაზე და გადადგამს კიდევ ერთ ნაბიჯს Adafruit Neopixels და ლაზერული აკრილის და პლაივუდის გარსაცმის გამოყენებით. მცოცავი დეტექტორი იყენებს 8 LED NeoPixel ჯოხს, რომ მოგაწოდოთ ძვირფასი ინფორმაცია უახლოესი მცოცავის შესახებ. როდესაც ყველა LED ნათურა გამორთულია, ეს ნიშნავს, რომ 32 კორპუსში მცოცავი არ არის. როდესაც ყველა LED არის ჩართული (ისინი ასევე ციმციმებენ), თქვენ ხართ მცოცავი 3 ბლოკის აფეთქების რადიუსში (რადიუსი, რომელზეც მცოცავი გაჩერდება, აანთეთ მისი დაუკრავენ და აფეთქებენ). ყველაფერს შორის შეიძლება დადგინდეს რამდენად შორს არის მცოცავი თქვენგან. როდესაც 8 LED- დან 4 ნათდება, თქვენ დაახლოებით 16 ბლოკი ხართ მცოცავიდან, რაც არის დიაპაზონი, სადაც მცოცავი გნახავთ, ის თავს დაესხმება. LED- ები დაიწყებენ ციმციმს, როდესაც თქვენ ხართ მცოცავი რადიუსის რადიუსში (7 ბლოკი). ის ასევე არის რადიუსი, რომლიდანაც თუ გახვალთ, მცოცავი გააჩერებს თავის დაუკრავს და გააგრძელებს თქვენს უკან მოსვლას. ამ ცოდნის წყალობით, თქვენ უნდა შეგეძლოთ თავიდან აიცილოთ ნებისმიერი მოულოდნელი მცოცავი თავდასხმა ან ნადირობა ახლომდებარე მცოცავებზე!

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

ნაბიჯი 1: რაც დაგჭირდებათ

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

- მე გამოვიყენე 8 LED RGBW NeoPixel ჯოხი, მაგრამ მე საერთოდ არ გამოვიყენე თეთრი (W) LED, ასე რომ 8 LED RGB NeoPixel ჯოხი გააკეთებს. თქვენ შეგიძლიათ შეცვალოთ ეს ნებისმიერი RGB ან RGBW NeoPixel პროდუქტით, მაგრამ არსებობს ძალაუფლების გათვალისწინება, რომელსაც ჩვენ განვიხილავთ შემდეგ ეტაპზე და კოდის ცვლილებებს, რომელსაც მე აღვნიშნავ აქ მოხვედრისას. თქვენ შეიძლება გინდათ აირჩიოთ ის, რაც არ საჭიროებს შედუღებას, მაგრამ მე გაჩვენებთ თუ როგორ შევაერთე მავთულები ჯოხზე.

- მიკროკონტროლი და მისი შესაბამისი USB კაბელი. მე გამოვიყენე SparkFun– ის RedBoard, რომელიც არის Arduino Uno– ს კლონი. ის იყენებს Mini B USB კონექტორს (მე არ ვარ დარწმუნებული, რატომ არის ასე ძვირი ამაზონზე, შეგიძლიათ მიიღოთ ის პირდაპირ SparkFun– დან აქ, ან აირჩიოთ ალტერნატივა ამაზონზე, როგორც ეს). ჩვენ ვიყენებთ Arduino ბიბლიოთეკას კოდირების გასამარტივებლად, მაგრამ ის იყენებს მხოლოდ ძირითად სერიულ კომუნიკაციას, ასე რომ ბიბლიოთეკა შეიძლება იყოს პორტირებული ნებისმიერ მიკროკონტროლერზე სამუშაოდ, რომელსაც შეუძლია USB სერიის გაკეთება. თითქმის ნებისმიერი Arduino გააკეთებს. დარწმუნდით, რომ მას აქვს USB სერიალი (უმეტესობას აქვს, მაგრამ ზოგს არ აქვს ისეთი, როგორიც არის ორიგინალური წვრილმანი).

- მავთულები, გამაგრილებელი რკინა და შედუღება (მავთულხლართები და მესამე ხელიც გამოდგება). ჩვენ შევაერთებთ მავთულს NeoPixel ჯოხზე, რათა ის იყოს ჩართული არდუინოში. ეს შეიძლება იყოს არასაჭირო, თუ აირჩევთ NeoPixel პროდუქტს, რომელსაც უკვე აქვს მავთული ან მიკროკონტროლი, რომელსაც მოყვება NeoPixels ბორტზე (მაგალითად, Circuit Playground Express, რომლის კოდიც შემდგომში ჩავდე). 8 LED ჯოხის ფორმულა არის ის, რისთვისაც მე შევიმუშავე ჩემი Creeper Detector- ის დანართი, ასე რომ თქვენ მოგიწევთ ცვლილებების შეტანა ან გარსაცმის გარეშე წასვლა, თუ სხვა ფორმის ფაქტორზე მიდიხართ.

- დანართის მასალები. მე გამოვიყენე 1/8 "გაყინული აკრილი, 1/8" გამჭვირვალე აკრილი და 1/8 "პლაივუდი, რომელსაც ლაზერულად ვჭრი და M3 აპარატის ხრახნები და თხილი, რომ შევიკავო. მე ასევე ვიყენებ რამოდენიმე #2 x 1/4 "ხის ხრახნებს NeoPixel ჯოხის ჩასამაგრებლად. დანართი არასაჭიროა, მაგრამ რათქმაუნდა დამატებით დამატებით მიმზიდველობას ანიჭებს. ჩემი გარსი განკუთვნილია მხოლოდ NeoPixels- ისთვის, არა მიკროკონტროლისთვის. თუ გსურთ ის იყოს მთლიანად დამოუკიდებელი, თქვენ მოგიწევთ ცვლილებები!

- Minecraft ანგარიში, Minecraft Forge 1.7.10 და SerialCraft (mod და Arduino ბიბლიოთეკა). მცოცავი დეტექტორი ეყრდნობა SerialCraft მოდას, რომელიც მუშაობს მხოლოდ Minecraft 1.7.10 – ზე Minecraft Forge– ით. ჩვენ განვიხილავთ, თუ როგორ გადმოწეროთ ეს და როგორ დავაყენოთ ისინი მომავალში.

- Arduino IDE ან ანგარიში Arduino Create- ზე და Arduino Create მოდული (მე გირჩევთ გამოიყენოთ Arduino Create რადგან თქვენ შეძლებთ პირდაპირ ჩემს Arduino- ს შექმნას ესკიზის წასვლას და შედგენას და ატვირთვას იქიდან).

ნაბიჯი 2: წრე

წრე ძალიან მარტივია, სულ რაღაც 3 მავთული, NeoPixel ჯოხი და არდუინო. ყველა Adafruit NeoPixel- ს აქვს საკუთარი კონტროლერი, რომელიც საშუალებას აძლევს ერთ მონაცემთა მავთულს აკონტროლოს ნებისმიერი რაოდენობის მიჯაჭვული LED- ები. მე დავუკავშირე მას პინ 12 ჩემს არდუინოზე.

დანარჩენი ორი მავთული არის ძალა და მიწა. NeoPixels– ის გასაძლიერებლად, დაგვჭირდება 5 ვ ენერგიის წყარო. ჩვენ უნდა დავრწმუნდეთ, რომ ჩვენი ენერგიის წყაროს შეუძლია უზრუნველყოს საკმარისი დენი. თითოეულ NeoPixel- ს შეუძლია 60 mA- მდე (80mA RGBW LED- ებით) სრული სიკაშკაშის დროს. 8 LED- ით, ეს ნიშნავს, რომ ჩვენი მაქსიმალური დენი არის 480mA (640mA RGBW LED- ებით). Arduino იღებს 40mA მხოლოდ ჩართვა. ერთი შეხედვით, როგორც ჩანს, დაგვჭირდება გარე კვების ბლოკის გამოყენება. USB იძლევა მაქსიმუმ 500 mA- ს, რომლის გადაჭარბებაც ჩვენ შეგვიძლია, თუ ყველა ჩვენი LED- ები დავაყენებთ მაქსიმუმს (480+40 = 520 RGB LED- ებით ან 640+40 = 680 RGBW LED- ებით). საბედნიეროდ, ჩვენ არასოდეს დაგვჭირდება LED- ების სრული სიკაშკაშისკენ გადაქცევა (სრული სიკაშკაშე საკმაოდ ბრმაა), ასე რომ ჩვენ ვიქნებით უსაფრთხოდ ჩვენი არდუინოს 5V სარკინიგზო ხაზის გამოყენებით, რომელიც ჩართულია USB- ის საშუალებით. ფაქტობრივად, ჩემი შერჩეული მწვანე ფერის გამოყენება იქნება მხოლოდ LED 7-8mA max თითო LED- ზე, ჯამში ~ 100mA მაქსიმალური მიმდინარე გათამაშებისთვის, ასევე USB- ით დაწესებული 500mA max- ის ქვეშ.

ამრიგად, ყველაფერი რაც ჩვენ გვჭირდება არის NeoPixel ჯოხის DIN პინზე მიმაგრება პინ 12 -ზე (თითქმის ნებისმიერი პინი იმუშავებს, მაგრამ ეს არის ის, რაც მე გამოვიყენე), NevPixel- ის 5V პინდი 5V- ზე Arduino– ზე და NeoPixel- ის GND პუნქტი ჯდება GND არდუინოზე. პირველ რიგში, ჩვენ უნდა შევაერთოთ ჩვენი მავთულები NeoPixel ჯოხზე.

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

ნაბიჯი 3: კოდი

განახლება (2/19/2018): მე გამოვაქვეყნე ახალი Arduino ესკიზი GitHub რეპოში, რომელიც მოიცავს ყველა აუცილებელ ცვლილებას Creeper Detector– ზე Circuit Playground Express– ზე სამუშაოდ (ის არ იმუშავებს დანართთან ერთად, მაგრამ მას აქვს ყველა LED- ები და დაფაზე ჩაშენებული ზოგიერთი სენსორი, ასე რომ არ არის საჭირო შედუღება). იგი მოიცავს დამატებით ფუნქციონირებას, რომელიც დაკავშირებულია მის ღილაკებთან და სლაიდების გადამრთველთან!

სრული კოდისთვის შეგიძლიათ გადახვიდეთ ჩემს Arduino Create sketch ან GitHub საცავში. მიჰყევით აქ მითითებებს, თუ არ ხართ დარწმუნებული როგორ შეადგინოთ და ატვირთოთ კოდი. თუ აირჩევთ Arduino IDE– ს გამოყენებას, თქვენ უნდა დააინსტალიროთ SerialCraft Arduino ბიბლიოთეკა. ამისათვის მიჰყევით ნაბიჯებს "Zip- ის იმპორტი". თუ თქვენ იყენებთ Arduino შექმნა ვებ რედაქტორს, შეგიძლიათ პირდაპირ ჩემს ესკიზზე გადახვიდეთ დაყენებისთანავე და თავიდან აიცილოთ SerialCraft ბიბლიოთეკის დაყენების საჭიროება.

ქვემოთ განვიხილავ რას აკეთებს კოდი.

პირველი ორი სტრიქონი მოიცავს ბიბლიოთეკას. პირველი, SerialCraft.h, არის ბიბლიოთეკა, რომელიც მე დავწერე, რაც საშუალებას იძლევა მარტივი კომუნიკაცია SerialCraft მოდასთან. მე გაგიმხელთ იმ მახასიათებლებს, რომლებსაც მე ვიყენებ ქვემოთ, მაგრამ თქვენ შეგიძლიათ ნახოთ მაგალითები და დოკუმენტაცია, რომელიც საჭიროებს რაიმე სამუშაოს მის GitHub საცავში. მეორე ბიბლიოთეკა არის ადაფრუტის NeoPixel ბიბლიოთეკა და უზრუნველყოფს API NeoPixel ზოლებზე LED- ების რეგულირებისთვის.

#ჩართეთ

#ჩართეთ

4-17 სტრიქონები არის მუდმივები, რომლებიც შეიძლება შეიცვალოს თქვენი კონფიგურაციის საფუძველზე. თუ თქვენ იყენებდით NeoPixel ზოლს სხვადასხვა რაოდენობის პიქსელებით, ან თუ თქვენს NeoPixels- ს მიამაგრეთ სხვა პინზე, თქვენ უნდა შეცვალოთ ცვლილებები პირველ ორ განსაზღვრებაში, NUMLEDS და PIN. თქვენ უნდა შეცვალოთ LED_TYPE იმ ტიპზე, რაც გაქვთ, სცადეთ შეცვალოთ NEO_GRBW NEO_RGB ან NEO_RGBW, თუ პრობლემები შეგექმნათ. თქვენ შეგიძლიათ შეცვალოთ BLOCKS_PER_LED, თუ გსურთ შეცვალოთ დიაპაზონი, სადაც შეგიძლიათ აღმოაჩინოთ მცოცავი.

// შეცვალეთ ეს ცვლადები, რათა შეესაბამებოდეს თქვენს კონფიგურაციას

// LED- ების რაოდენობა თქვენს ზოლში #განსაზღვრეთ NUMLEDS 8 // პინი, რომლის LED მონაცემთა პინი დაკავშირებულია #განსაზღვრეთ PIN 12 // ბლოკების რაოდენობა, რომელსაც თითოეული LED წარმოადგენს #განსაზღვრეთ BLOCKS_PER_LED 4 // თქვენი LED ზოლის ტიპი (თუ თქვენი LED- ები არ მწვანე ხდება, მაშინ თქვენ უნდა შეცვალოთ GRBW რიგი) #განსაზღვრეთ LED_TYPE (NEO_GRBW+NEO_KHZ800) // END ცვლადები

19-27 სტრიქონები განსაზღვრავს ზოგიერთ მნიშვნელობას, რომელსაც ჩვენ მოგვიანებით გამოვიყენებთ. DETONATE_DIST არის მანძილი Minecraft– ში, სადაც მცოცავი მოძრაობა შეწყვეტს, აანთებს მის დაუკრავს და აფეთქდება. SAFE_DIST არის მცოცავი აფეთქების რადიუსი. ამ ღირებულებების შეცვლა გავლენას მოახდენს LED- ების ქცევაზე, მაგრამ მე გირჩევთ შეინარჩუნოთ ისინი ის, რაც ისინი ასახავენ ქცევებს Minecraft– ში. MAX_DIST არის მაქსიმალური მანძილი, რომელზეც ჩვენ თვალყურს ვადევნებთ მცოცავებს, რომელიც ემყარება ჩვენი NeoPixel ზოლის LED- ების რაოდენობას და ჩვენს მიერ ზემოთ განსაზღვრულ BLOCKS_PER_LED მუდმივობას.

// ეს არის ღირებულებები, რომლებიც გამოყენებული იქნება ჩვენი გათვლებით LED სიკაშკაშისათვის

// დისტანციური მცოცავი დაიწყებს აფეთქებას #განსაზღვრეთ DETONATE_DIST 3 // მანძილი ჩვენ დაცული ვართ მცოცავი აფეთქებისგან (თქვენ მიიღებთ ზარალს, თუ ამ მანძილზე ხართ) #განსაზღვრეთ SAFE_DIST 7 // მაქსიმალური მანძილი, რომელსაც ჩვენ თვალყურს ვადევნებთ მცოცავ #define MAX_DIST (NUMLEDS*BLOCKS_PER_LED)

29-36 სტრიქონები განსაზღვრავს რამდენიმე ცვლადს, რომელსაც ჩვენ გამოვიყენებთ მთელი პროგრამის განმავლობაში. Sc ცვლადი არის SerialCraft ობიექტი, რომელიც უზრუნველყოფს მარტივად გამოსაყენებელ ინტერფეისს SerialCraft Minecraft mod– თან კომუნიკაციისთვის. თქვენ ნახავთ, როგორ ვიყენებთ მას ქვემოთ. dist არის ცვლადი, რომელსაც ჩვენ დავაყენებთ მანძილზე უახლოეს მცოცავთან, როდესაც მივიღებთ მცოცავი მანძილის შეტყობინებას SerialCraft mod– დან. ზოლები არის Adafruit_NeoPixel ობიექტი, რომელიც უზრუნველყოფს NeoPixel ზოლების კონტროლის მეთოდებს.

// ეს არის SerialCraft ობიექტი SerialCraft Minecraft mod– თან კომუნიკაციისთვის

SerialCraft sc; // მანძილი მცოცავი int dist = 100; // LED- ების ზოლის ინიციალიზაცია, შეიძლება დაგჭირდეთ მე -3 Adafruit_NeoPixel ზოლის შეცვლა = Adafruit_NeoPixel (NUMLEDS, PIN, LED_TYPE);

ხაზები 38-47 არის ჩვენი დაყენების ფუნქცია. Arduino– ს ყველა სკრიპტს უნდა ჰქონდეს ერთი. ის მუშაობს ერთხელ, როდესაც Arduino ჩართულია, ამიტომ ის შესანიშნავი ადგილია ცვლადების ინიციალიზაციისთვის. ჩვენ მოვუწოდებთ setup () მეთოდს ჩვენს SerialCraft ობიექტზე სერიული პორტის ინიციალიზაციისთვის იმავე სიჩქარით, როგორც ეს კონფიგურირებულია SerialCraft mod (115200). შემდეგ ჩვენ მოვუწოდებთ RegisterCreeperDistanceCallback მეთოდს, ასე რომ ჩვენ შეგვიძლია ვუპასუხოთ creeper მანძილზე გაგზავნილ შეტყობინებებს SerialCraft mod– ის მიერ. ჩვენ პერიოდულად მოვუწოდებთ sc.loop () მეთოდს ცოტა ქვემოთ. მარყუჟის მეთოდით, ის ამოწმებს, მივიღეთ თუ არა რაიმე შეტყობინება SerialCraft- ის მოდიფიკაციიდან, თუ ვიწყებთ რაიმე მოვლენას, როგორიცაა ღილაკის დაჭერა და იძახებს შესაბამის ფუნქციას, რომელიც ჩვენ დავარეგისტრირეთ, რომ გავუმკლავდეთ მას. ჩვენ რასაც ვაკეთებთ, ვეძებთ უახლოეს მცოცავ მანძილს, ასე რომ ეს არის ერთადერთი ფუნქცია, რომელსაც ჩვენ ვარეგისტრირებთ. თქვენ დაინახავთ ქვემოთ, რომ რასაც ჩვენ ვაკეთებთ ამ ფუნქციაში არის ჩვენი dist ცვლადი, რომელსაც ჩვენ გამოვიყენებთ LED- ების განახლებისას. დაბოლოს, ჩვენ ვიწყებთ ჩვენი LED ზოლის ინიციალიზაციას და ვთიშავთ ყველა LED- ს strip.begin () და strip.show () გამოყენებით.

void setup () {// ინიციალიზაცია SerialCraft sc.setup (); // დაარეგისტრირეთ მცოცავი მანძილის გამოძახება, რათა მიიღოთ მანძილი უახლოეს მცოცავთან sc.registerCreeperDistanceCallback (მცოცავი); // LED ზოლის ინიციალიზაცია strip.begin (); ზოლები. ჩვენება (); }

49-80 სტრიქონები განსაზღვრავს მარყუჟის ფუნქციას. მარყუჟის ფუნქცია არის იქ, სადაც ხდება ყველა მაგია. მარყუჟის ფუნქცია არაერთხელ იძახება. როდესაც მარყუჟის ფუნქცია დასრულდება, ის კვლავ იწყებს უკან დაბრუნებას. მასში ჩვენ ვიყენებთ dist ცვლადს და ჩვენს მუდმივებს ფაილის ზედა ნაწილში, რათა განვსაზღვროთ, რა მდგომარეობაში უნდა იყოს თითოეული LED.

მარყუჟის ფუნქციის ზედა ნაწილში ჩვენ განვსაზღვრავთ რამდენიმე ცვლადს.

// მერყეობს 0 -დან როდესაც = = MAX_DIST მოშორებით მცოცავის აფეთქების რადიუსიდან NUMLEDS*BLOCKS_PER_LED, როდესაც მცოცავი თავზეა

int blocksFromCreeperToMax = შეზღუდვა (MAX_DIST+DETONATE_DIST-dist, 0, MAX_DIST); int curLED = ბლოკებიFreeCreeperToMax/BLOCKS_PER_LED; // მერყეობს 0-დან NUMLEDS-1 int curLEDLevel = (blocksFromCreeperToMax%BLOCKS_PER_LED+1); // მერყეობს 1 -დან BLOCKS_PER_LED- მდე

ვინაიდან ჩვენ ვანთებთ LED- ებს იმის საფუძველზე, თუ რამდენად ახლოს ვართ მცოცავთან, ჩვენ გვჭირდება ეფექტურად შევაბრუნოთ ჩვენი მანძილის ცვლადი. ჩვენ განვსაზღვრავთ ბლოკებსFromCreeperToMax, რომ წარმოვადგენთ ბლოკების რაოდენობას მცოცავი არის მაქსიმალური მანძილიდან, რომელსაც ჩვენ ვადევნებთ თვალყურს. როდესაც ჩვენ ვართ ზემოთ მცოცავი (უფრო სწორად, ნაკლები ან ტოლი მცოცავიდან DETONATE_DIST), ბლოკებიFromCreeperToMax იქნება MAX_DIST. როდესაც ჩვენ მცოცავიდან MAX_DIST- ის მიღმა ვართ, ბლოკებიFromCreeperToMax იქნება 0. ეს ცვლადი სასარგებლო იქნება, როდესაც ჩვენ ვანთებთ ჩვენს LED- ებს რაც უფრო დიდია, მით უფრო მეტ LED- ს ვანთებთ.

curled არის ყველაზე ყველაზე LED, რომელიც განათდება. ყოველი 4 ბლოკი, რომელსაც ჩვენ გადავივლით მცოცავისკენ, აანთებს დამატებით LED- ს (ეს რიცხვი შეიძლება შეიცვალოს ფაილის ზედა ნაწილში BLOCKS_PER_LED ცვლადით). ჩვენ ვარეგულირებთ ზედა LED- ების სიკაშკაშეს, რათა დავინახოთ ცვლილებები მანძილზე ერთ ბლოკამდე. curLEDLevel არის ცვლადი, რომელსაც ჩვენ გამოვიყენებთ იმ სიკაშკაშის ცვლილებების გამოსათვლელად. ის მერყეობს 1 -დან 4 -მდე (ან რასაც BLOCKS_PER_LED განსაზღვრავს).

ჩვენ გამოვიყენებთ ამ ცვლადებს თითოეული LED- ზე გადასვლისას:

for (uint16_t i = 0; i <strip.numPixels (); i ++) {if (i <= curled) {// ყველაზე კაშკაშა როდესაც მცოცავის აფეთქების რადიუსში, გამორთულია როცა მცოცავი არის NUMLEDS*BLOCKS_PER_LED მოშორებით float ინტენსივობა = (float) ბლოკებიFromCreeperToMax /MAX_DIST; if (i == curled) {// ბოლო LED განათებული // გახადე ბოლო LED უფრო ნათელი, როდესაც მივუახლოვდებით მომდევნო LED float lastIntensity = (float) curLEDLevel/BLOCKS_PER_LED; ინტენსივობა *= ბოლო ინტენსივობა; } if (dist <SAFE_DIST) {ინტენსივობა *= (მილი ()/75)%2; } ინტენსივობა = ძალა (ინტენსივობა, 2.2); // გამა მრუდი, ხდის LED სიკაშკაშეს ხაზოვანი ჩვენი თვალისთვის, როდესაც სიკაშკაშის მნიშვნელობა ნამდვილად არ არის strip.setPixelColor (i, strip. Color (10*ინტენსივობა, 70*ინტენსივობა, 10*ინტენსივობა, 0)); } else {strip.setPixelColor (i, strip. Color (0, 0, 0, 0)); }}

თუ ამჟამინდელი LED, რომელსაც ჩვენ ვაახლებთ, არის ნაკლები ან ტოლი curled ცვლადის, მაშინ ჩვენ ვიცით, რომ ის უნდა იყოს ჩართული და ჩვენ უნდა გამოვთვალოთ მისი სიკაშკაშე. წინააღმდეგ შემთხვევაში, გამორთეთ. ჩვენ ვიყენებთ ინტენსივობის ცვლადს, რომელსაც ექნება მნიშვნელობა 0 -დან 1 -მდე, რათა წარმოაჩინოს ჩვენი LED სიკაშკაშე. LED- ის საბოლოო ფერის დაყენებისას ჩვენ გავამრავლებთ ინტენსივობას მწვანე (10, 70, 10) ფერით. ჩვენ ვიყენებთ blockFromCreeperToMax ცვლადს, რომ მივიღოთ პროცენტი MAX_DIST- ზე გაყოფით, ასე რომ LED- ები იქნება ყველაზე ნათელი, როდესაც მცოცავთან ახლოს ვართ. თუ ჩვენ ვიანგარიშებთ curled სიკაშკაშეს, მაშინ ჩვენ ვცვლით მის სიკაშკაშეს მანძილიდან თითოეული ბლოკის მანძილზე მცოცავი თქვენგან BLOCKS_PER_LED პარამეტრამდე. ეს არის დახვეწილი ცვლილება, მაგრამ ის შეიძლება გამოყენებულ იქნას იმის გასარკვევად, მცოცავი ახლოვდება თუ უფრო შორს წვრილ მარცვალზე, ვიდრე 4 ბლოკი, რომელიც დამატებით LED- ს განათებას სჭირდება. შემდეგ ჩვენ ვამოწმებთ, ვართ თუ არა მცოცავის აფეთქების რადიუსში და ვხუჭავთ, თუ ვართ. გამოთქმა (millis ()/75)%2 არაერთხელ შეაფასებს 0 -ს 75 მილიწამში და შემდეგ 1 -ს 75 მილიწამში, ასე რომ, ჩვენი ინტენსივობის გამრავლებით ამ გამოხატულებით გამოიწვევს LED- ების დახამხამებას.

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

ჩვენი მარყუჟის ფუნქციის ბოლო ორი ხაზი განაახლონ LED- ები იმ მნიშვნელობებამდე, რომლებიც ჩვენ უბრალოდ დავაყენეთ და შემდეგ მოვუწოდებთ ნებისმიერ დამმუშავებელს, რომელსაც უნდა დაურეკოს SerialCraft (ამ შემთხვევაში მცოცავი მანძილის ფუნქცია, თუ ჩვენ მივიღეთ რაიმე მცოცავი მანძილის შეტყობინება SerialCraft mod– დან) რა

ზოლები. ჩვენება ();

sc.loop ();

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

void creeper (int d) {dist = d; }

ახლა თქვენ უბრალოდ უნდა შეადგინოთ და ატვირთოთ კოდი!

ნაბიჯი 4: დანართი

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

NeoPixel ჯოხი დამონტაჟებულია პლაივუდის უკანა ნაწილზე #2 ხის ხრახნებისა და ნეილონის შუასადებების გამოყენებით. აკრილის მცოცავი პლაივუდის ორ ნაწილად იკეტება კვადრატული ხვრელებით. სანამ ამას გააკეთებთ, დარწმუნდით, რომ გახსოვთ რომელი მავთულის ფერი რომელ ბალიშზე მიდის ჯოხზე.

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

გაყინული აკრილი ავრცელებს შუქს ცალკეული LED- ებიდან და გამჭვირვალე აკრილი უკეთესად აჩვენებს მცოცავი გრავიურას, ასე რომ ორივე კომბინირებული ჩემთვის უკეთ გამოიყურება, ვიდრე ინდივიდუალურად. როდესაც მცოცავი ადგილებია, დააწყვეთ პლაივუდის ყველა ნაჭერი ერთად და მიამაგრეთ ისინი M3 მანქანების ხრახნებთან და კაკლებთან ერთად. შემდეგ ხელახლა შეაერთეთ მავთულები 5V, GND და pin 12.

ნაბიჯი 5: Minecraft Forge და SerialCraft Mod

დაიწყეთ Minecraft ანგარიშის შექმნით, შემდეგ გადმოწერეთ და დააინსტალირეთ Minecraft კლიენტი.

თქვენ გჭირდებათ Minecraft Forge 1.7.10 ვერსიისთვის, რომ შეძლოთ SerialCraft mod- ის დაყენება. გადადით 1.7.10 Minecraft Forge ჩამოტვირთვის გვერდზე. Minecraft Forge საიტს აქვს ბევრი რეკლამა, რომელიც ცდილობს თქვენ დააჭიროთ არასწორ ნივთს და მიგიყვანოთ სხვაგან. მიჰყევით ზემოთ მოცემულ სურათებს, რათა დარწმუნდეთ, რომ დარჩებით სწორ გზაზე! თქვენ მოგიწევთ დააწკაპუნოთ Installer ღილაკზე რეკომენდებული 1.7.10 ვერსიის ქვეშ (ან უახლესი, მე ნამდვილად არ ვარ დარწმუნებული განსხვავებაში). თქვენ გადაგიყვანთ გვერდზე, რომელზეც განთავსებულია ბანერი გვერდის ზედა ნაწილში, სადაც ნათქვამია "შინაარსი ამ სათაურის ქვემოთ არის რეკლამა. დათვლის შემდეგ, დააწკაპუნეთ ღილაკზე" გამოტოვება "მარჯვნივ, რომ დაიწყოთ თქვენი Forge ჩამოტვირთვა." დარწმუნდით, რომ დაელოდებით დათვლას და შემდეგ დააწკაპუნეთ ღილაკზე გამოტოვება ჩამოტვირთვის დასაწყებად.

ორჯერ დააწკაპუნეთ ინსტალერზე გადმოტვირთვის დასრულების შემდეგ. დატოვეთ ნაგულისხმევი პარამეტრები (დააინსტალირეთ კლიენტი და ნაგულისხმევი გზა, რომელსაც ის განსაზღვრავს), შემდეგ დააჭირეთ ღილაკს OK. ის დააინსტალირებს Minecraft Forge- ს. როდესაც ის დასრულდება, თქვენ შეძლებთ Minecraft Launcher– ის დაწყებას, მაგრამ იქნება დამატებითი ვარიანტი Forge– ის 1.7.10 ვერსიის შესარჩევად (იხ. სურათი ზემოთ).

ახლა ჩვენ უნდა დავაინსტალიროთ SerialCraft mod თქვენს მოდების დირექტორიაში. ჩამოტვირთეთ SerialCraft mod– ის უახლესი ვერსია აქ. თქვენ ასევე დაგჭირდებათ jssc ბიბლიოთეკა. გახსენით ორივე ფაილი, რამაც უნდა დატოვოს ორი.jar ფაილი. თქვენ უნდა ჩაწეროთ ეს ფაილები თქვენი mods საქაღალდეში. Windows- ზე, თქვენ უნდა შეგეძლოთ წასვლა Run საწყისი მენიუდან და შეიყვანოთ %appdata %\. Minecraft / mods სანამ გაშვებას დააწკაპუნებთ. Mac– ზე შეგიძლიათ გადახვიდეთ სახლში/ბიბლიოთეკაში/პროგრამის მხარდაჭერაში/minecraft/mods– ში. ჩაწერეთ ორი.jar ფაილი თქვენს ახლად გახსნილ საქაღალდეში. ახლა გაუშვით Minecraft და გაუშვით 1.7.10 Forge ვერსია. თქვენ უნდა შეგეძლოთ დააწკაპუნოთ Mods– ზე და იხილოთ SerialCraft მარცხნივ.

ნაბიჯი 6: SerialCraft Mod– ის გამოყენება

ახლა, როდესაც თქვენ დააინსტალირეთ SerialCraft mod, თქვენ უნდა შეხვიდეთ სამყაროში და დაიწყოთ მისი გამოყენება. შექმენით ახალი სამყარო ან გახსენით თქვენი შენახული სამყარო (თუ გსურთ ითამაშოთ მრავალფუნქციური რუქაზე, თქვენ უნდა დარწმუნდეთ, რომ სერვერზე და მასთან დაკავშირებულ ყველა კლიენტზე დამონტაჟებულია SerialCraft mod). დარწმუნდით, რომ თქვენი მცოცავი დეტექტორი დაკავშირებულია თქვენს კომპიუტერთან, შემდეგ დააჭირეთ K ღილაკს. მან უნდა წარმოაჩინოს დიალოგი, როგორც ზემოთ მოყვანილი სურათი (Windows- ზე, ნაცვლად /dev/tty.usbserial… უნდა თქვას COM1- ის მსგავსი). თუ არაფერია ნაჩვენები, დარწმუნდით, რომ თქვენ დაუკავშირდით მცოცავი დეტექტორს. დააწკაპუნეთ დაკავშირების ღილაკზე, შემდეგ დააჭირეთ Escape. თუ თქვენი კოდი შედგენილი და ატვირთულია სწორად, თქვენი მცოცავი დეტექტორი უნდა იყოს კარგი წასასვლელი! თუ მცოცავი მდებარეობს 32 ბლოკში, ის უნდა ანათებდეს. Ბედნიერი ნადირობა!

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

მეორე პრიზი Minecraft გამოწვევაში 2018