გაგზავნეთ რიცხვითი მონაცემები ერთი არდუინოდან მეორეზე: 16 ნაბიჯი

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

შესავალი

დევიდ პალმერის მიერ, CDIO Tech. ასტონის უნივერსიტეტში.

ოდესმე დაგჭირდათ რამდენიმე ნომრის გაგზავნა ერთი არდუინოდან მეორეზე? ეს ინსტრუქცია გვიჩვენებს, თუ როგორ.

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

Რას აკეთებს

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

აღჭურვილობა

• 2 არდუინოს
• 2 USB კაბელი
• პატჩის მავთულები (საჭიროებისამებრ)
• 1 კომპიუტერი/ლეპტოპი დატვირთულია Arduino IDE– ით (ხელმისაწვდომია როგორც უფასო ჩამოტვირთვა Arduino.cc ვებ – გვერდიდან)

ნაბიჯი 1: დაყენება - პირველ რიგში დააყენეთ თქვენი აპარატურა

შეაერთეთ 2 Arduinos 2 USB პორტში თქვენს კომპიუტერში.

რჩევა, კარგი იდეაა მონიშნოთ ისინი როგორც M და S (ოსტატი და მონა), რათა მოგვიანებით არ ჩავარდეთ არეულობაში (როგორც ეს ნაჩვენებია აქ 2 ფოტოში.)

ნაბიჯი 2: დაყენება - დააყენეთ თქვენი ეკრანი

საუკეთესო რამ არის თქვენი ეკრანის დაყენება ისე, რომ გქონდეთ

• IDE დატვირთულია სამაგისტრო პროგრამით მარცხნივ და
• რომ მონასთან ერთად მარჯვნივ.

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

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

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

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

მე გამოვიყენე მწვანე და ყვითელი

• მიიღეთ პირველი ყვითელი, ეს უნდა ჩაერთოს D6 ერთ არდუინოში და D7 მეორეში
• შემდეგ პირიქით მწვანე მავთულისთვის, D7 პირველზე და D6 მეორე არდუინოზე.

გარდა ამისა, თუ თქვენ გაქვთ რაიმე ხელმისაწვდომი Bluetooth წყვილის მოდულის მსგავსად - HC -05– ის მსგავსად - ისინი ასევე მოგცემთ ზუსტად იგივე ეფექტს, როგორც ზემოთ მოყვანილი მავთულები.

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

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

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

ნაბიჯი 5: ესკიზების / პროგრამების მიმოხილვა - პროგრამის სტრუქტურა

განლაგება როგორც Arduino- ს ესკიზებში არის 3 ძირითადი ნაწილი:

• დეკლარაციები
• დაყენება
• მთავარი მარყუჟი

როგორც ხშირად ხდება, ჩვენ აქ გამოვიყენეთ მე -4 ნაწილი, რომელიც არის "ფუნქციების" დამატება. თუ თქვენ არ იცნობთ ფუნქციების გამოყენებას, შეგიძლიათ გუგლში მოიძიოთ "Arduino ფუნქციები" და ნახავთ განმარტებების საიტებს, როგორიცაა მაგალითი ამ ბმულზე: www.tutorialspoint.com/arduino/arduino_functions…. რა

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

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

• simpleRxTx0330 სამაგისტრო
• საერთო
• შენიშვნები

ეს არის რეალურად ცალკეული ფაილები პროგრამის საქაღალდეში, როგორც ამას ხედავთ Windows Explorer– ის მონების პროგრამის ფაილების ხედში.

არსებობს ძალიან კარგი მიზეზი, რის გამოც ჩვენ ეს გავაკეთეთ.

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

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

ნაბიჯი 6: დიზაინი ქვემოთ

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

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

ეს მიჰყვება კარგი დიზაინის ფილოსოფიას, რომელიც ისწავლება ბევრ უნივერსიტეტში, სახელწოდებით CDIO. ეს ძირითადად ამბობს: ნუ დაიწყებთ დიზაინს სანამ კონცეფცია არ გაირკვევა. არ დაიწყოთ განხორციელება მანამ, სანამ დიზაინი არ გაირკვევა. არ მოელოდოთ, რომ ის იმუშავებს მანამ, სანამ განხორციელება არ გაირკვევა. C პირველი, შემდეგ D, I და O. ყოველ მომდევნო ეტაპზე თქვენ იმეორებთ (დაბრუნდით მარყუჟზე), ასე რომ, ერთხელ თქვენ კმაყოფილი დარჩებით თქვენი საწყისი დიზაინის მარყუჟით და შეამოწმეთ, რომ ის კვლავ აკმაყოფილებს კონცეფციას და განაახლეთ C თუ საჭიროა. და ასე შემდეგ, მაშინაც კი, როდესაც მუშაობას შეუდგებით, დაბრუნდით ბოლომდე და კვლავ ნახეთ, როგორ გამოიყურება C ახლა, შემდეგ მე და D, და გააკეთეთ და შეამოწმეთ ყველაფერი საჭიროებისამებრ. პროგრამირების ესკიზებით ეს მუშაობს ერთნაირად, თუ თქვენ შეიმუშავებთ ზემოდან ქვემოთ.

ნაბიჯი 7: კონცეფცია და დიზაინი - ნაწილი 1

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

დიზაინი შეიძლება გამოიყურებოდეს მარყუჟის ადრეულ ვერსიად, რომელიც შეესაბამება შენიშვნების ჩანართს და შეიძლება გამოიყურებოდეს ისე, როგორც ხედავთ ამ ფიგურაში

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

ეს რეალურად ადგენს OK- ს, როგორც ხედავთ ფიგურის ეკრანის ბოლოში. ეს აღწევს CDIO ეტაპიდან D– მდე და კოდის შემუშავებისას კარგი იდეაა გავაგრძელოთ ეს D-I მარყუჟი.

ახლა დროა გადავიდეთ შემდეგ ეტაპზე, იქ არის კომენტარი, სადაც ნათქვამია, რომ ჩვენ ვაპირებთ: // მივიღოთ რაღაც აპარატურის USB– დან, შემდეგ ჩვენ ვაპირებთ ამის გადაცემას პროგრამულ სერიულ არხზე. ჩვენ ვწერთ ამ კოდს იმისათვის, რომ ეს მოხდეს - სტრიქონები 133 -დან 138 -მდე ნაჩვენებია აქ ყვითელი ჰაილაითერით

ნაბიჯი 8: კონცეფცია და დიზაინი - ნაწილი 2

ორი პირველი ორი ფუნქცია, რომელსაც ჩვენ შემოვიღებთ აქ არის (recv () და tran (), რათა მოხდეს აპარატურის პორტიდან მიღება და პროგრამული უზრუნველყოფის პორტში გადაცემა - შესაბამისად, მოვუწოდებთ მათ ნაჩვენები 'hw' ან 'sw' პარამეტრებით.

მათ გარდა, ჩვენ დავამატეთ ტესტი გლობალურ ცვლადზე, სახელწოდებით newData. ეს არის დროშა, რომელსაც ჩვენ დავაყენებთ "void recv ();" ფუნქციის შიგნით. შეტყობინების მიღების შემდეგ ეს ცვლადი მონიშნულია ყალბიდან ჭეშმარიტებამდე. ჩვენ ამას ვაკეთებთ ისე, რომ ჩვენ ვუგზავნით შეტყობინებას მხოლოდ იმ შემთხვევაში, თუ ის მიღებულია (დროშა == ჭეშმარიტი) 134 -ე სტრიქონში. და მას შემდეგ, რაც ჩვენ გადავეცით ჩვენი შეტყობინება, რომ "სამუშაო დასრულებულია", ასე რომ, ჩვენ დროშას ვაბრუნებთ ისევ ცრუ 137 -ე სტრიქონში.

ჩვენ კვლავ შეგვიძლია შევამოწმოთ შედგენა (D to I) და ამჯერად ჩვენ გვაქვს "გამოცხადებული" შეცდომის შეტყობინება (ნაჩვენებია). ეს გვეუბნება, რომ ჩვენ არ გამოვაცხადეთ recv (); ფუნქცია. ჩვენ ვგეგმავთ ამის გაკეთებას მოგვიანებით, ასე რომ მხოლოდ ახლა, რომ მოგვცეს საშუალება მივიღოთ სუფთა კომპილია, ჩვენ უნდა შევქმნათ დამანგრეველი ან დამცავი ფუნქცია, როგორც ნაჩვენებია შემდეგში.

ჩვენ კვლავ შეგვიძლია შევამოწმოთ შედგენა (D to I) და ამჯერად ჩვენ გვაქვს კიდევ ერთი 'არ გამოცხადებული' შეცდომის შეტყობინება tran () - ისთვის; ფუნქცია. ამას სჭირდება მსგავსი ძარღვის შექმნა. ჩვენ კვლავ შეგვიძლია შევამოწმოთ შედგენა (D to I) და ამ დროს ჩვენ ვიპოვით, რომ ეს მშვენივრად მუშაობს; ჯერჯერობით კარგად

ნაბიჯი 9: დაასრულეთ ძირითადი მარყუჟი: ა) USB– დან მიღება, ბ) მიღება მონა Arduino– დან

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

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

ასე რომ, ეს გამართვის სტრიქონები [ნაჩვენებია 136-139] დამატებულია შემდეგ მთავარ მარყუჟში და, აი, აქ შეგიძლიათ შეამოწმოთ ისინი სამაგისტრო ბოლოში, გამართვის ცვლადის ჭეშმარიტებით და შედგენით (I), შემდეგ თუ თქვენ აკავშირებთ Arduino– სთან, შეგიძლიათ ატვირთოთ, გახსნათ სერიული მონიტორი და ნახოთ თუ არა ის, რაც სერიულ მონიტორში ბრუნდება, როგორც აქ არის ნაჩვენები (ხედავთ, რომ შეტყობინება „DEBUG MODE“დამატებულია?)

ნაბიჯი 10: მონაცემების მიღება და დამუშავება მონა არდუინოში

მიღება მონა არდუინოსგან

დაამატეთ საჭირო კოდი მეორე არხის მთავარ მარყუჟს, პროგრამული სერიული მიმღები, როგორც ნაჩვენებია - სტრიქონები 149 -დან 155 -მდე.

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

ასევე ნახავთ, რომ ჩვენ ვიღებთ შემდგენლის შეცდომას, სხვა გამოუცხადებელ ფუნქციას - ამჯერად parseData (); - ასე რომ, ჩვენ ასევე უნდა გავაკეთოთ ამის გაკეთება, სანამ ჩვენ შევძლებთ შეცდომების გარეშე ტესტის კომპილების გაშვებას.

მონათა არდუინოში მონაცემების დამუშავება

დაამატეთ Arduino– სთვის საჭირო ძირითადი მარყუჟის კოდი, თუ ის კონფიგურირებულია როგორც Slave მოწყობილობა, როგორც ნაჩვენებია - ხაზები 163 – დან 174 – მდე. ხედავთ, რომ მისი სტრუქტურა ძალიან ჰგავს პირველი არხის სტრუქტურას?

და თქვენ უნდა იპოვოთ ამ დროს ის სრულყოფილად ჯდება.

ნაბიჯი 11: ჩაწერეთ მიღების ფუნქცია

ფუნქციის მიღება - void recv (char from) {} - აქვს ორი ძირითადი სამუშაო.

1 USB არხიდან სიმბოლოების სტრიქონის მისაღებად და

2 მიიღოს ერთი არდუინოდან არდუინოს არხზე.

პირველისთვის ჩვენ დაგვჭირდება გამოვიყენოთ, რადგან ის იყენებს Arduino- ს ჩამონტაჟებულ ტექნიკას UART, ხოლო მეორისთვის სტანდარტული Arduino ბიბლიოთეკის გამოყენებით: პროგრამული უზრუნველყოფა UART.

როდესაც ჩვენ ვიწყებთ ფუნქციის კოდის დამატებას - ისეთი ფუნქციის შესაქმნელად, რომელიც აკეთებს რაღაცას, მხოლოდ სტატუსის ნაცვლად - ჩვენ უნდა გვახსოვდეს, რომ ამოვიღოთ ან გამოვაქვეყნოთ სტატუსი, რომელსაც იგი ცვლის. წინააღმდეგ შემთხვევაში ჩვენ ვიღებთ შედგენის შეცდომას: refefintion of 'void lrec (char)'.

სცადეთ და მიიღეთ შეცდომა და შემდეგ სცადეთ ზემოთ მოყვანილი რომელიმე მეთოდი მისგან თავის დასაღწევად.

დაიწყეთ ისეთი ფუნქციით, რომელიც ჰგავს იმას, რასაც აქ ვაჩვენებთ 75 -დან 88 -მდე სტრიქონებს ყვითლად.

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

მოდით შევხედოთ ჩვენს მიერ დაწერილ კოდს recv () ფუნქციისთვის.

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

კოდი "sw" ნაწილში და "hw" ნაწილი ერთი და იგივე ფორმისაა და აქ აღვწერ.

თითოეულ წყვილში პირველი წყვილი არის მარყუჟის დასაწყისი. თუ თქვენ არ იცნობთ დროის შესახებ, შეგიძლიათ ნახოთ Arduino.cc/Reference საიტზე ახსნა -განმარტებისა და მაგალითებისათვის. აქ ჩვენ ველოდებით "სანამ" ჩაშენებულ "სერიულ" ფუნქციას არ მიუღია რაიმე სიმბოლო (ები) და რადგან newData ცვლადი გამორთულია (ანუ newData == ცრუ მდგომარეობა მართალია). როგორც კი პერსონაჟი - ან ერთზე მეტი პერსონაჟი - მიიღება, ამ წყვილის მეორე ხაზზე "გადავარდება". ეს გამოიძახებს recAstringChar (char); ფუნქცია გაუმკლავდეს მიმდინარე სიმბოლოს. ეს წყვილი სტრიქონები შეიცვლება მაშინ, სანამ (ან რამდენ ხანს) იქნება სიმბოლოები, რომლებიც ჯერ კიდევ მოითხოვს მიღებას. მას შემდეგ რაც ისინი ყველაფერს გააკეთებენ, ხოლო სახელმწიფო მთავრდება, რაც საშუალებას აძლევს თუ არა შემდეგ საფეხურს ბოლომდე და, თავის მხრივ, რეკ (char); ფუნქცია დასრულდეს. ამრიგად, სრული შეტყობინება ახლა მიიღეს.

ნაბიჯი 12: ჩაწერეთ მიმღების ქვეფუნქცია - ნაწილი 1

ჩვენ ახლა უნდა დავწეროთ ფუნქცია სახელწოდებით recAstringChar (char); რა თქვენ ხედავთ კომენტარიდან 50 სტრიქონს აქ, მის ზედა ნაწილში, რომ მისი ამოცანაა ორი ბუფერის განახლება შემომავალი სერიული შეტყობინების ასლებით. [აღმოჩნდა, რომ მე ვცდილობდი ამ ყველაფრის მუშაობას, ერთი რაც შევიტყვე ის იყო, რომ მე მჭირდებოდა ორი განსხვავებული ბუფერი - ან ყოველ შემთხვევაში ეს იყო უმარტივესი გზა ზოგიერთი პრობლემის გადასაჭრელად, ამიტომ ის გარკვეულწილად გადაიზარდა 2 ბუფერის საჭიროებად, ასე რომ მე უბრალოდ შევქმენი ისინი.] მე დავურეკე ერთ ბუფერს:

ბუფერები გლობალური ცვლადია, ამიტომ ისინი გამოცხადებულია მოდულის დონეზე, იხილეთ საერთო ჩანართის მე -9 და მე -10 სტრიქონები. ამ ფუნქციის შიგნით გამოცხადებულია სხვა ცვლადები, რომელთაც აქვთ ადგილობრივი დიაპაზონი- ნაჩვენებია აქ 51-54 სტრიქონებში. ეს არ არის ადგილი გლობალებსა და ადგილობრივებს შორის განსხვავებების ასახსნელად, მაგრამ ამის შესახებ მეტი ინფორმაციაა https://www.arduino.cc/glossary/en/ ლოკალური და გლობალური.

თქვენ ასევე შეგიძლიათ გაიგოთ ყველაფერი მონაცემთა ტიპებისა და ტიპის მოდიფიკატორების შესახებ: სტატიკური, ლოგიკური, ბაიტი, const, char https://www.arduino.cc/reference/en/#variables, აქ ნაჩვენები.

ამ პროგრამის ძირითადი პროგრამის ნაკადს აკონტროლებს if აქ 56 ხაზი და მისი სხვა დანარჩენი 74 ხაზი. ეს ეხება ორ სცენარს

ა) [74 -ე სტრიქონიდან] როდესაც მიღებული შეტყობინება იწყება. ეს ხდება მაშინ, როდესაც startMarker გამოჩნდება - ეს განისაზღვრება, როგორც '<' სიმბოლო, რის გამოც, როდესაც ჩვენ ვამოწმებთ ესკიზს, ჩვენ ყოველთვის ვიწყებთ ჩვენს სტრიქონს ამ სიმბოლოთი. თუ ჩვენ ასე არ ვიქნებით, მიღებული არაფერი დამუშავდება, ეს ყველაფერი იგნორირებული იქნება ისე, თითქოს სისულელეებს ვწერთ "სერიული მონიტორის" კლავიატურის მოთხოვნაზე.

ბ) [სტრიქონები 56 -დან 73 -მდე] რომელიც იღებს ყველა სხვა სიმბოლოს, როგორიც არ უნდა იყოს ისინი, მაგრამ ისინი მხოლოდ პერსონაჟებს ეხება მას შემდეგ, რაც მოხდა სწორი დასაწყისი (a '>' მიღებულია როგორც ა) ზემოთ.)

ამ სტრიქონებში (74 – დან 78 – მდე) ჩვენ ვიღებთ მიღებულს <ერთ - ერთ ბუფერში (მიღებული მონაცემები [0]), მაგრამ არა მეორეში. ჩვენ ვარეგულირებთ ბუფერულ მაჩვენებელს (ცვლადი: char ndx) მიუთითებს მომდევნო სათადარიგო ბუფერულ პოზიციაზე (მიღებული მონაცემები [1]) შემდგომი ზრდის ბრძანების (++) გამოყენებით ხაზში ndx ++;, და ჩვენ ვაყენებთ მიმდინარე დროშას true.

პროგრამის ნაკადი ფუნქციის ამ ნაწილში კონტროლდება if –ის 57 -ე ხაზით და მისი შესაბამისი სხვა 65 -ე ხაზით. ეს ეხება ორ სცენარს

ა) [65 -ე სტრიქონიდან] როდესაც მიღებული შეტყობინება დასრულდება. ეს ხდება მაშინ, როდესაც endMarker გამოჩნდება - განისაზღვრება როგორც>, სწორედ ამიტომ, როდესაც ჩვენ ვამოწმებთ ჩვენს ესკიზს, ჩვენ ყოველთვის ვამთავრებთ ჩვენს სტრიქონს ამ სიმბოლოთი. ერთ-ერთი რამ, რაც ხდება საბოლოო სიმბოლოს მიღებისას, არის ის, რომ გლობალური დროშა (ტექნიკურად ცვალებადი) newData არის დაყენებული, როგორც ფუნქცია მთავრდება, ისე ფუნქცია, რომელიც ჩვენს ქვე-ფუნქციას იძახებს (გამოძახების ფუნქცია: recv (char);) შეუძლია "იცოდეს", რომ მოქმედი ახალი მონაცემები დასრულებულია.

ბ) [სტრიქონები 57 -დან 64 -მდე], რომელიც იღებს ყველა სხვა სიმბოლოს, როგორიც არ უნდა იყოს ისინი. ის უბრალოდ მჭიდროდ აჩერებს მათ რიგებად ორივე ბუფერში.

ნაბიჯი 13: ჩაწერეთ მიმღების ქვეფუნქცია - ნაწილი 2

ეს შეიძლება დაეხმაროს მაგალითის მოყვანას, თუ როგორ გამოიყურება 2 ბუფერი, როდესაც ისინი დასახლდებიან. თუ ჩვენ უნდა ჩავწეროთ enter, ბუფერებს ექნებათ სიმბოლოები ნაჩვენები მათში:

ასე რომ, ახლა თქვენ ხედავთ, რომ ჩვენ გვაქვს ერთი ბუფერი, რომელიც ზუსტად იგივე სიმბოლოებია, როგორც ჩვენ პირველად ჩავწერეთ და ერთი ბუფერი, რომელსაც აქვს მხოლოდ ორი მნიშვნელობა და გამყოფი მძიმით. ახლა ჩვენ გვაქვს რაღაც კოდი, რომელსაც შეუძლია მიიღოს სიმბოლოები, რომლებსაც ჩვენ ვწერთ სერიული მონიტორის კლავიატურაზე, ჩვენ შეგვიძლია გადავიდეთ CDIO ფაზიდან I– ზე O– ზე, ჩავწეროთ რამდენიმე სტრიქონი და ვნახოთ რა ხდება. ატვირთეთ კოდი Master Arduino– ში, გახსენით სერიული მონიტორი და სცადეთ ჩაწეროთ რაიმე სწორი, მაგალითად enter. იღებთ ექოს სერიული მონიტორის ეკრანზე, როგორც აქ ნაჩვენები?

ნაბიჯი 14: დაწერეთ გადაცემის და გაანალიზების ფუნქციები

ჯერ გადაცემისათვის

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

შეიყვანეთ ეს ფუნქცია, როგორც ნაჩვენებია აქ 117 -დან 133 -მდე. როგორც თქვენ აღიარებთ, მას აქვს ორი ნაწილი, ერთი USB არხზე (აპარატურის UART) გადასაცემად და ერთი მეორე Arduino- ზე (პროგრამული უზრუნველყოფა UART.) ამან უნდა შეადგინოს შეცდომა -უფასოდ, და თქვენ შეგიძლიათ დაუყოვნებლივ ატვირთოთ ესკიზი და ნახოთ რა ხდება. ამჯერად გამოგიგზავნით. იღებთ ნაჩვენებ შედეგს?

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

ნაბიჯი 15: დაწერეთ გადაცემის და გაანალიზების ფუნქციები

შემდეგ პარსისთვის

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

ჩაანაცვლეთ ამობეჭდვის სტატუსი 98 - 113 სტრიქონებში ნაჩვენები კოდით. ატვირთეთ იგი და ვნახოთ, არის თუ არა გამოსწორებული პრობლემა, რომელიც გვქონდა 2 მთელ მნიშვნელობასთან. Მოდი ვცადოთ.

დიახ, ის მუშაობს, როგორც ნაჩვენებია, ნაპოვნი მთელი რიცხვებია 49 და 98.

ნაბიჯი 16: ფინალი

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