მიკროპროგრამირება: ბიტი რობოტი და ჯოისტიკი: ბიტი კონტროლერი მიკროპითონით: 11 ნაბიჯი

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

Robocamp 2019-ისთვის, ჩვენი საზაფხულო რობოტიკის ბანაკისთვის, 10-13 წლის ახალგაზრდები ყიდულობენ, პროგრამირებენ და ქმნიან BBC მიკრო: ბიტზე დაფუძნებულ 'ანტიბოტოტ რობოტს', ასევე პროგრამირებენ მიკრო: ბიტს დისტანციური მართვისთვის.

თუ ამჟამად იმყოფებით Robocamp– ში, გადადით მე –3 საფეხურზე, რადგან ჩვენ გავაკეთეთ პირველი ორი ნაბიჯი ჯგუფურად

ეს არის ნაბიჯ-ნაბიჯ სახელმძღვანელო მიკრო: ბიტიანი რობოტის კომუნიკაციისთვის ჯოისტიკით: ბიტის კონტროლერით.

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

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

ჩვენი რობოტის დიზაინის ფაილები შეგიძლიათ იხილოთ აქ:

ეს სახელმძღვანელო დაწერილია დამწყებთათვის, მაგრამ თუ აქამდე მიკრო: ბიტი არ გამოგიყენებიათ MicroPython– ით, ჩვენ გირჩევთ სცადოთ ჯერ უფრო მარტივი პროგრამა, როგორიცაა ჩვენი სახელის სამკერდე ინსტრუქცია: https://www.instructables.com/id/Felt -მიკრობიტ-ნამ …

მარაგები

2x BBC მიკრო: ცოტა

რობოტი, რომელიც მუშაობს BBC მიკრო: bit (იხ ახსნა ზემოთ)

ჯოისტიკი: ბიტი კონტროლერი (ჩვენ მივიღეთ ჩვენი მაგარი კომპონენტებისგან)

ნაბიჯი 1: რობოტის დაყენება

თქვენ გაქვთ რამდენიმე ვარიანტი თქვენი მიკრო მიკროპითონის კოდის დასაწერად: bit:

• Mu, რომელიც შეგიძლიათ გადმოწეროთ და დააინსტალიროთ აქედან:
• ონლაინ რედაქტორი, რომელსაც აქ ნახავთ:

ეს ინსტრუქციები ვარაუდობენ, რომ თქვენ იყენებთ Mu- ს

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

მიიღეთ რობოტის საავტომობილო გამოცდის კოდის ასლი აქედან:

თუ თქვენ არ ხართ მიჩვეული Github– ს, ეს შეიძლება იყოს არაინტუიციური! ამ კოდის მისაღებად ორი მარტივი გზაა:

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

ახლა დააწკაპუნეთ ღილაკზე 'Flash' Mu- ს პანელიდან, რომ გაგზავნოთ თქვენი ახალი კოდი მიკრო: ბიტზე.

ეს არ იმუშავებს, სანამ მიკრო: ბიტი არ არის ჩართული

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

მოტორული მიმართულებების დაყენება-დაყენება

ეს პროგრამა ჩართავს ძრავებს სხვადასხვა მიმართულებით, როდესაც დააჭერთ 'A' ღილაკს მიკრო: ბიტზე.

რაც გინდა რომ მოხდეს არის:

• როდესაც "A" გამოჩნდება, მარცხენა ძრავა წინ მიიწევს
• როდესაც 'B' არის ნაჩვენები, მარცხენა ძრავა უკანა მხარეს
• როდესაც 'C' არის ნაჩვენები, მარჯვენა საავტომობილო ნაბიჯია წინ
• როდესაც "D" გამოჩნდება, მარჯვენა ძრავა უკან

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

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

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

თუ თქვენ იყენებთ საკუთარ რობოტს, კოდის რედაქტირებამდე შეამოწმეთ რომელ პინებს უკავშირდება ძრავის მძღოლი.

დრაივის ტესტირება

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

თქვენ ეუბნებით რობოტს მართოს დრაივი () ფუნქციის გამოძახებით. ამას სჭირდება ორი არგუმენტი - მნიშვნელობა მარცხენა ძრავისთვის და მნიშვნელობა მარჯვენა ძრავებისთვის, 0 -დან (გამორთული) და 1023 -მდე (მაქსიმალური სიჩქარე).

მაგალითად, დისკზე დარეკვით (500, 500), თქვენ ეუბნებით ორივე ძრავას, რომ ჩართონ, წინ მიმართულებით, დაახლოებით ნახევარი სიჩქარით.

სცადეთ რამდენიმე ვარიანტი, რათა გაეცნოთ რამდენად სწორია ის და რამდენად კარგად ბრუნავს.

მინიშნება: საავტომობილო ტესტები იყო შიგნით, როგორც მარყუჟში, ასევე if- ში - ძრავები არ ბრუნდებოდა მანამ, სანამ არ დააჭერთ A ღილაკს მიკრო: ბიტზე, და ის სამუდამოდ ამოწმებს, დააჭირეთ თუ არა ღილაკს.

მინიშნება: ძრავები არ ითიშება, სანამ ამას არ ეტყვით! ისინი ყოველთვის გააგრძელებენ ბოლო ინსტრუქციის შესრულებას.

სურვილისამებრ: მართვის გაუმჯობესება სწორი ხაზით

თუ თქვენი რობოტი არ იმოძრავებს სწორი ხაზით, თქვენი ერთ -ერთი ძრავა შეიძლება უფრო სწრაფად ბრუნდეს, ვიდრე მეორე.

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

გადაახვიეთ ზემოთ, რომ იპოვოთ დისკის ფუნქციის განმარტება და გადახედეთ ზედა ორ ინსტრუქციას:

def დისკი (L, R):

# ქვემოთ არის კორექტირება ძრავის სიჩქარის შეუსაბამობის გამოსასწორებლად L = int (L*1) R = int (R*1)

ეს ორი ხაზი ამჟამად იღებს L და R მნიშვნელობას, ამრავლებენ მათ 1 -ით, შემდეგ დარწმუნდით, რომ ისინი მაინც მთლიანი რიცხვებია (int).

მაგალითად, თუ თქვენი მარცხენა ძრავა უფრო სწრაფია, შეცვალეთ *1 მის ხაზზე *0.9 და ნახეთ გააუმჯობესებს თუ არა ეს.

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

რადიოს დაყენება

ახლა დააყენეთ რადიო, დაამატეთ შემდეგი ხაზები თქვენი კოდის ზედა ნაწილში:

რადიოს იმპორტი

radio.config (არხი = 7, ჯგუფი = 0, რიგი = 1) radio.on ()

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

ეს იმიტომ ხდება, რომ არხი 7 და ჯგუფი 0 ნაგულისხმევი არხებია.

შეცვალეთ ეს რიცხვები, შეარჩიეთ არხი 0-82 და ჯგუფი 0-255 შორის. ახლა თქვენი მიკრო: ბიტი მიიღებს ინსტრუქციებს სხვაგან იგივე კონფიგურაციის ინფორმაციის მქონე.

რიგი = 1 ნიშნავს მიკრო: ბიტი დაიცავს მხოლოდ ერთ შემოსულ შეტყობინებას ერთდროულად - ეს იძლევა რეაგირების ოდნავ უფრო სწრაფ დროს ვიდრე ნაგულისხმევი, რაც არის 3.

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

სცადეთ შემდეგი კოდი ტესტის სახით (ის არაფერს გააკეთებს მანამ, სანამ არ დააინსტალირებთ ჯოისტიკს მე –2 ნაბიჯში):

მართალია:

შეტყობინება = radio.receive () თუ შეტყობინება == 'წინ': დისკი (500, 500)

ნაბიჯი 2: ჯოისტიკის დაყენება

გამორთეთ თქვენი რობოტის მიკრო: ბიტი და შეაერთეთ თქვენი ჯოისტიკის მიკრო: ბიტი ნაცვლად

მიიღეთ ჯოისტიკის დაყენებული კოდის ასლი აქედან:

დააყენეთ რადიო იმავე კონფიგურაციის გამოყენებით (არხისა და ჯგუფის ნომერი), რაც გააკეთეთ რობოტისთვის - ეს საშუალებას მისცემს ორს დაუკავშირდნენ ერთმანეთს.

პროგრამის ბოლოს, დაიწყეთ თქვენი ძირითადი მარყუჟი:

მართალია:

თუ button_a.was_pressed (): radio.send ('წინ')

ეს კოდი ჯერ არ იყენებს ჯოისტიკს: bit. ის იყენებს ღილაკს A მიკროზე: bit შეტყობინების გასაგზავნად.

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

თუ შეტყობინება წარმატებით იქნა მიღებული და თქვენი რობოტი მოძრაობს … კარგად გააკეთეთ! თქვენ დაასრულეთ დაყენების ინსტრუქცია.

რჩევების აღმოფხვრა პრობლემებთან დაკავშირებით

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

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

თუ საერთოდ არაფერი მოხდება

• დარწმუნდით, რომ თითოეული მიკრო მიკროსქემის სწორი კოდი ჩაწერეთ: ბიტი - ადვილია შემთხვევით ააფეთქოთ არასწორი!
• დარწმუნდით, რომ თქვენი არხის და ჯგუფის ნომრები ემთხვევა თითოეულ მიკრო: ბიტს

ნაბიჯი 3: ჯოისტიკის ღირებულებების შემოწმება

შემდეგი რამდენიმე ნაბიჯი არის კონტროლერის კოდის გამოყენებით

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

შეცვალეთ თქვენი ძირითადი მარყუჟი შემდეგი კოდით:

მართალია:

ჯოისტიკი = ჯოისტიკი_პუში () ბეჭდვა (ჯოისტიკი) ძილი (500)

შეავსეთ ეს კოდი თქვენს მიკრო: ბიტზე, შემდეგ დააწკაპუნეთ REPL ღილაკზე Mu- ს პანელზე. ეს გახსნის ტერმინალს რედაქტორის ბოლოში, რომელიც გაძლევთ რეალურ დროში ბმულს მიკრო: bit.

ეს არ იმუშავებს, სანამ მიკრო: ბიტი არ არის ჩართული

როდესაც REPL ღიაა, დააჭირეთ გადატვირთვის ღილაკს თქვენი მიკრო: ბიტის უკანა მხარეს.

თქვენ უნდა ნახოთ რამდენიმე მნიშვნელობა, რომლებიც "დაბეჭდილია" თქვენს ეკრანზე:

დააწექი ჯოისტიკის ჯოხს და ნახე რა ხდება ციფრებთან.

აღნიშნე მნიშვნელობები, როდესაც ჯოისტიკი ცენტრალურ პოზიციაშია - ჩემს შემთხვევაში (518, 523).

დააწკაპუნეთ მუ -ის ინსტრუმენტთა პანელზე REPL ღილაკზე, რომ დახუროთ იგი - თქვენ ვერ შეძლებთ ახალი კოდის მიკროზუსტირებას მიკრო: ცოტა სანამ ის ღიაა.

ნაბიჯი 4: X და Y ცვლადების მორგება

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

• ცენტრში არის ნული
• up დადებითია
• ქვემოთ არის უარყოფითი.

ეს ემთხვევა მითითებებს რობოტს სჭირდება - დადებითი რიცხვი წინსვლისთვის და უარყოფითი რიცხვი უკანა მიმართულებით.

შეხედეთ რიცხვებს, რომლებიც მიიღეთ ბოლო საფეხურზე. პირველი რიცხვია x, ხოლო მეორე რიცხვი y.

რედაქტირება joystick_push () განმარტებით, რომელიც უკვე არის პროგრამაში, მინუს თქვენი ღირებულებების ორიგინალიდან:

def joystick_push ():

x = pin0.read_analog () - 518 y = pin1.read_analog () - 523 დაბრუნება x, y

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

შეავსეთ ახალი კოდი, გახსენით REPL, დააჭირეთ მიკრო: ბიტის გადატვირთვის ღილაკს და შეამოწმეთ თქვენი მნიშვნელობები.

იღებთ (0, 0)?

ნაბიჯი 5: გადააქციეთ X და Y მნიშვნელობად მარცხენა და მარჯვენა ძრავებისათვის

ამ დროისთვის ეს ჯოისტიკი არ იქნება ძალიან სასარგებლო რობოტის მართვისთვის. მთელი გზა წინ მიიწევთ, თქვენ მიიღებთ მნიშვნელობას, როგორიცაა (0, 500).

რობოტს რომ მიეცით ეს რიცხვები, ის ჩართავს მარჯვენა ძრავას, მაგრამ არა მარცხენას, რაც არ არის ის, რაც გსურთ რომ მოხდეს!

ეს დიაგრამა გვიჩვენებს რა ხდება x და y მნიშვნელობებთან ჯოისტიკის გადაადგილებისას და რისი გაკეთება გვსურს რობოტმა ჯოისტიქის გადაადგილებისას.

თქვენ უნდა გამოიყენოთ რამდენიმე მათემატიკა, რომ შეურიოთ x და y მნიშვნელობები, რათა მოგაწოდოთ რაიმე უფრო სასარგებლო.

n

მათემატიკა

დავიწყოთ ჯოისტიკის წინსვლით.

ღირებულებების მაგალითი, რომელიც შეიძლება მიიღოთ არის:

x = 0

y = 500

რობოტისთვის რომ გამოსადეგი იყოთ, გსურთ მიიღოთ შემდეგი მნიშვნელობები:

მარცხენა = 500

მარჯვნივ = 500

მოდით ვცადოთ x და y სხვადასხვა გზით დამატება, რომ ნახოთ რა რიცხვებს ვიღებთ:

x + y = 0 + 500 = 500

x - y = 0 - 500 = -500 y + x = 500 + 0 = 500 y - x = 500 - 0 = 500

ახლა ვნახოთ რა მოხდება, თუ ჯოისტიკს ბოლომდე მივუყვებით მარჯვნივ.

ღირებულებების მაგალითი, რომელიც შეიძლება მიიღოთ არის:

x = 500

y = 0

იმისათვის, რომ რობოტი მოტრიალდეს მარჯვნივ, თქვენ გინდათ რომ მარცხენა ძრავა წავიდეს წინ და მარჯვენა ძრავა უკანა მიმართულებით:

მარცხენა = 500

მარჯვნივ = -500

მოდი ვცადოთ ისევ ჩვენი ფორმულა:

x + y = 500 + 0 = 500

x - y = 500 - 0 = 500 y + x = 0 + 500 = 500 y - x = 0 - 500 = -500

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

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

n

ჯოისტიკის ფუნქციის გაფართოება

გააფართოვეთ და შეცვალეთ ჯოისტიკის ფუნქცია, რათა გააკეთოთ ორი ახალი ცვლადი მარცხნივ და მარჯვნივ და დააბრუნოთ ეს მნიშვნელობები x და y ნაცვლად:

def joystick_push ():

x = pin0.read_analog () - 518 y = pin1.read_analog () - 523 მარცხენა = მარჯვნივ = დაბრუნება მარცხნივ, მარჯვნივ

შეავსეთ ახალი კოდი, გახსენით REPL, დააჭირეთ მიკრო: ბიტის გადატვირთვის ღილაკს და შეამოწმეთ თქვენი მნიშვნელობები.

იღებთ იმ ღირებულებებს, რასაც ელოდებით?

თუ კიდევ გჭირდებათ დახმარება, გადახედეთ ჩვენს კოდის მაგალითს აქ:

ნაბიჯი 6: ღირებულებების გაგზავნა რადიო შეტყობინებების სახით

ახლა თქვენ გაქვთ რამდენიმე მნიშვნელობა, რომელიც მზად არის გამოგიგზავნოთ თქვენს რობოტზე.

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

მართალია:

ჯოისტიკი = ჯოისტიკი_პუში () შეტყობინება = სტრიქონი (ჯოისტიკი [0]) + "" + სტრიქონი (ჯოისტიკი [1])

ეს რეალურად ჯერ არ გაგზავნის შეტყობინებას!

რა ხდება ამ კოდის ახალ ხაზში?

• ჯოისტიკი [0] ნიშნავს ინფორმაციის პირველ ნაწილს, რომელიც გამოდის ჯოისტიკის ფუნქციიდან (მარცხნივ)
• ჯოისტიკი [1] არის შემდეგი ინფორმაცია (მარჯვნივ)
• str () გარდაქმნის ორივე ამ რიცხვს სიმების ფორმატში (ტექსტი რიცხვების ნაცვლად) - ეს აუცილებელია იმისათვის, რომ შეძლოთ ინფორმაციის გაგზავნა რადიოთი.

თქვენ შეჩვეული იქნებით, რომ ნახოთ + ნიშნავს დამატებას - მას შეუძლია რიცხვების დამატება და სტრიქონების ერთმანეთთან შეერთება, რაც იმას ნიშნავს, რომ ის ინფორმაციის ორ ნაწილს ერთმანეთთან დააკავშირებს.

მაგალითი:

150 + 100 = 250

str (150) + str (100) = 150100

ასე რომ, შერწყმა დააკავშირებს თქვენს მარცხენა და მარჯვენა მნიშვნელობებს.

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

დაბოლოს, გააფართოვეთ თქვენი კოდი, რომ გაგზავნოთ ეს ახლად შექმნილი შეტყობინება რადიოთი:

radio.send (შეტყობინება)

ძილი (10)

ძილი ანელებს შეტყობინებების გაგზავნას ისე, რომ მიმღები მიკრო: ბიტი არ გადატვირთოს ძალიან ბევრი ინფორმაცია!

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

ნაბიჯი 7: შეტყობინებების მიღება თქვენს რობოტზე

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

გადაახვიეთ ქვემოთ თქვენს მთავარ მარყუჟზე - ამოიღეთ ტესტირების კოდი და დაამატეთ ეს ნაცვლად:

მართალია:

შეტყობინება = radio.ceceive () print (message) sleep (100)

ეს ადგენს ცვლადს შემომავალი შეტყობინების ტოლფასი და ბეჭდავს შეტყობინებას REPL– ში - რათა შეამოწმოს, რომ შეტყობინებები გადის როგორც მოსალოდნელი იყო.

განათავსეთ თქვენი ახალი კოდი, რომელიც დაკავშირებულია REPL– თან, შემდეგ დააჭირეთ ჯოისტიკს.

თქვენ უნდა მიიღოთ მსგავსი რამ:

რჩევების აღმოფხვრა პრობლემებთან დაკავშირებით

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

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

თუ საერთოდ არაფერი მოხდება

• დარწმუნდით, რომ თითოეული მიკრო მიკროსქემის სწორი კოდი ჩაწერეთ: ბიტი - ადვილია შემთხვევით ააფეთქოთ არასწორი!
• დარწმუნდით, რომ თქვენი არხის და ჯგუფის ნომრები ემთხვევა თითოეულ მიკრო: ბიტს

ნაბიჯი 8: შემომავალი შეტყობინებების გამოყენება რობოტის ძრავების გასაკონტროლებლად

თქვენ ახლა იღებთ ორ ნომერს, რომელიც იგზავნება რადიოთი სტრიქონის სახით.

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

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

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

მართალია:

შეტყობინება = radio.receive () თუ შეტყობინება არ არის: message = message.split () წამყვანი (int (შეტყობინება [0]), int (შეტყობინება [1]))

რა ხდება აქ?

• ახალი კოდი იმუშავებს, თუ შეტყობინება სხვა არაფერია, თუ არა "არა".
• message.split () ამოწმებს სივრცეს შეტყობინებაში (რომელიც ჩვენ დავამატეთ ბოლო ნაბიჯში) და იყენებს ამას შეტყობინების ორად გაყოფისთვის.
• int (შეტყობინება [0]), int (შეტყობინება [1]) აკეთებს საპირისპიროს იმას, რაც ჩვენ გავაკეთეთ წინა საფეხურზე - იღებს ინფორმაციის თითოეულ ნაწილს ინდივიდუალურად და გარდაქმნის მას მთელ რიცხვში (მთელი რიცხვი).
• int (შეტყობინება [0]) გამოიყენება როგორც ღირებულება მარცხენა ძრავისთვის დისკის ფუნქციაში, ხოლო int (შეტყობინება [1]) გამოიყენება როგორც მარჯვენა ძრავის მნიშვნელობა.

შეამოწმეთ მუშაობს თუ არა - ძრავები ბრუნდება როცა ჯოისტიკს უბიძგებთ?

თუ არა - დროა გამართვისთვის!

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

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

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

თუ გსურთ ნახოთ ამ კოდის ჩვენი ვერსია აქამდე:

• რობოტი:
• კონტროლერი:

ნაბიჯი 9: ღილაკების გამოყენება - დამატებითი შეტყობინებების მიღება

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

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

გააფართოვეთ თქვენი კოდი ასე:

თუ შეტყობინება არ არის არცერთი:

თუ შეტყობინება == 'გამარჯობა': display.show (Image. HAPPY) elif შეტყობინება == 'იხვი': display.show (Image. DUCK) სხვა: შეტყობინება = message.split () დისკი (int (შეტყობინება [0]), int (შეტყობინება [1]))

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

თუ შეტყობინება არ არის გამარჯობა, ის შემდეგ შეამოწმებს არის თუ არა შეტყობინება "იხვი".

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

ორმაგი ტოლობის ნიშანი მნიშვნელოვანია - ეს ნიშნავს "უდრის", ერთი ტოლობის ნიშანთან შედარებით, რომელიც რაღაცას ადგენს (ასე რომ, შეტყობინება = "გამარჯობა" ნიშნავს, რომ ჩვენ ვაყენებთ ცვლადს "გამარჯობა", შეტყობინება == "გამარჯობა" ნიშნავს, რომ ჩვენ ვეკითხებით არის თუ არა შეტყობინება ტოლი "გამარჯობა").

სცადეთ ახლავე მხოლოდ ორი ვარიანტით, მისი შესამოწმებლად - შეგიძლიათ დაამატოთ იმდენი სხვა შეტყობინება, რამდენიც მოგწონთ მოგვიანებით.

ბმული სამუშაო კოდზე:

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

გამორთეთ თქვენი რობოტის მიკრო: ბიტი და შეაერთეთ თქვენი ჯოისტიკის მიკრო: ბიტი ნაცვლად

დაუბრუნდით თქვენს კონტროლერის კოდს შესწორების მიზნით.

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

მარყუჟის ზედა ნაწილში, ჩვენ კვლავ გვინდა, რომ მან შეამოწმოს ჯოისტიკის ამჟამინდელი მნიშვნელობები, მაგრამ ჩვენ ასევე გვინდა, რომ მან შეამოწმოს ღილაკზე დაჭერილი არის თუ არა:

მართალია:

ჯოისტიკი = joystick_push () ღილაკი = ღილაკი_პრესა ()

button_press () აბრუნებს მნიშვნელობას A, B, C, D, E ან F იმისდა მიხედვით, თუ რომელ ღილაკზეა ამჟამად დაჭერილი (თუ არაფერი დაჭერილია, ის აბრუნებს არცერთს).

ახლა ჩვენ შეგვიძლია გავაკეთოთ if-elif-else განცხადება, როგორც ეს გავაკეთეთ რობოტის კოდისთვის-ორი ღილაკის გამოყენებით და ჯოისტიკის მნიშვნელობის გაგზავნით, თუ ღილაკს არ დააჭერთ.

თუ ღილაკი == 'A':

radio.send ('გამარჯობა') ძილი (500) elif ღილაკი == 'B': radio.send ('იხვი') ძილი (500) სხვა: შეტყობინება = str (ჯოისტიკი [0]) + "" + str (ჯოისტიკი [1]) რადიო. გაგზავნა (შეტყობინება) ძილი (10)

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

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

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

მუშაობს?

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

თუ თქვენ იღებთ შეცდომას რობოტზე, როდესაც დააჭირეთ ღილაკს თქვენს კონტროლერზე - თქვენ იცით, რომ შეტყობინება ვრცელდება, მაგრამ ის აბნევს რობოტს. შეამოწმეთ, რომ თქვენ მიერ გაგზავნილი შეტყობინება და რობოტისთვის ნათქვამი შეტყობინება ერთი და იგივეა.

ბმული სამუშაო კოდზე:

ნაბიჯი 11: შემდეგი ნაბიჯები

თქვენ უკვე გაქვთ ცოდნა, რომელიც გჭირდებათ რობოტის ძრავებზე და ჯოისტიკზე: ბიტის კონტროლერზე

გამოიყენეთ ეს ცოდნა ორი პროგრამის გასაუმჯობესებლად და გახადეთ ისინი თქვენი. რამდენიმე იდეა ქვემოთ!

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

• რას იტყვით თქვენი რობოტისთვის საცეკვაო რუტინის დაპროგრამებაზე, რომელიც უნდა შეასრულოს ბრძანებით? დაწერეთ drive () ბრძანებების ალგორითმი, რომლებიც გამოყოფილია sleep () ბრძანებებით!
• გსურთ შეცვალოთ რობოტის მიმართულებით მოძრაობა ისე, რომ მას ადვილად შეეძლოს თავდაყირა დაყენება? იფიქრეთ თქვენი ჯოისტიკის x და y ღირებულებებზე. რას წარმოადგენენ ისინი და როგორ შეიძლება მათი მანიპულირება?
• აქვს თქვენს რობოტს (ან შეგიძლიათ დაამატოთ!) დამატებითი ფუნქციები, როგორიცაა LED- ები, სპიკერი ან სენსორები?

იდეები კოდის გასაუმჯობესებლად

• იქნებ დაგეხმაროთ თქვენს რობოტს გაუმკლავდეს უცნობ შეტყობინებებს try/გარდა კოდის გამოყენებით?
• ჯოისტიკიდან მარცხენა და მარჯვენა მნიშვნელობების გამოსათვლელად გამოყენებული მათემატიკა არ გვაძლევს ღირებულებების სრულ სპექტრს (რობოტის დისკს შეუძლია მიიღოს რიცხვი 1023 -მდე). შეგიძლიათ შეცვალოთ ეს კოდი უკეთესი დიაპაზონის მისაღებად?
• ჯოისტიკის ღირებულებების შერევის სხვა მეთოდებიც არსებობს - შეგიძლიათ ამის უკეთესი გზა მოიფიქროთ?