საბაჟო Arduino- ს შეუძლია შეინარჩუნოს საჭის ღილაკები ახალი მანქანის სტერეოთი: 9 ნაბიჯი (სურათებით)

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

მე გადავწყვიტე შეცვალო ორიგინალური მანქანის სტერეო ჩემს Volvo V70 -02– ში ახალი სტერეოთი, ასე რომ მე შევძლებ ისარგებლო ისეთი ნივთებით, როგორიცაა mp3, bluetooth და handsfree.

ჩემს მანქანას აქვს საჭის კონტროლი სტერეოსთვის, რომლის გამოყენებაც მაინც მსურს. არ ველოდი, რომ ეს იქნებოდა პრობლემა, რადგან ბაზარზე არის რამდენიმე გადამყვანი, რომლებიც უნდა შეესაბამებოდეს ჩემს მანქანას. თუმცა მალევე აღმოვაჩინე, რომ ისინი არ იყვნენ! (როგორც ჩანს, V70– ის გადამყვანებს შეიძლება ჰქონდეთ პრობლემები –02 მანქანაზე ოდნავ განსხვავებული CAN პროტოკოლის გამო.)

მერე რა ვქნათ? შეინარჩუნე ძველი სტერეო? იცხოვრე არასამუშაო ღილაკებით? Რათქმაუნდა არა! თუ ბაზარზე არ არის სამუშაო ადაპტერი, ჩვენ უნდა ავაშენოთ ის!

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

ნაბიჯი 1: გაარკვიეთ როგორ გაგზავნოთ ბრძანებები სტერეოზე

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

პულტი ჩემი ახალი სტერეოსთვის (კენვუდი) შედგება ერთი მავთულისგან და მე ვერ მოვიძიე ინფორმაცია იმის შესახებ, თუ როგორ მუშაობს იგი. ამასთან, მას აქვს 3.5 მმ ბუდე დისტანციური შეყვანისთვის. მეც ვერაფერი გავიგე ამის შესახებ. მაგრამ არსებობს ინფორმაცია 3.5 მმ -იანი ჯეკის შესახებ სხვა ბრენდებისთვის, რომელიც ვარაუდობს, რომ განსხვავებული ბრძანებები იდენტიფიცირებულია წვერსა და ყდის შორის სპეციფიკური წინააღმდეგობის გამოყენებით (და სურვილისამებრ ბეჭედსა და ყდის შორის). Მაგალითად. https://forum.arduino.cc/index.php?topic=230068.0. ასე რომ, მე გადავწყვიტე, გამეცადა, რომელიც აღჭურვილი იყო პურის დაფით, რამოდენიმე რეზისტორით და 3.5 მმ -იანი დანამატით, რომელიც ჩართული იყო სტერეოზე და უკავშირდებოდა პურის დაფას. თავიდან არაფერი იყო აღიარებული, მაგრამ სტერეოს აქვს "სწავლის რეჟიმი" მენიუ და იქ ბრძანებების წარმატებით დაყენება შესაძლებელია სხვადასხვა წინააღმდეგობის გამოყენებისას. წარმატებები!

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

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

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

ნაბიჯი 2: გაარკვიეთ სად დაუკავშირდეთ CAN ავტობუსს

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

ნაბიჯი 3: CAN შეტყობინებების საპირისპირო ინჟინერია

თუ Google არ გეტყვით რა CAN შეტყობინებებს უნდა მოუსმინოთ, მაშინ დაგჭირდებათ CAN ავტობუსთან დაკავშირება და საპირისპირო ინჟინერიის გაკეთება. მე გამოვიყენე Arduino Uno და CAN ფარი. (თქვენ ნამდვილად არ გჭირდებათ CAN ფარი, როგორც მოგვიანებით ნახავთ, ამის ნაცვლად შეგიძლიათ გამოიყენოთ იაფი კომპონენტები პურის დაფაზე.)

გაიარეთ კონსულტაცია Google- თან, რომ გაარკვიოთ რა სიჩქარე უნდა გამოიყენოთ მანქანასთან დაკავშირებისას. (როგორც წესი, თქვენ აღმოაჩენთ, რომ არსებობს მაღალი სიჩქარით და დაბალი სიჩქარით CAN ქსელი. თქვენ აერთებთ დაბალი სიჩქარის ქსელს.)

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

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

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

აწყობა()

{init სერიული კავშირი init CAN ბიბლიოთეკა} მარყუჟი () {თუ CAN შეტყობინება მიიღება {წაიკითხეთ CAN შეტყობინების ფორმატი ჟურნალი შესვლა ჩაწერეთ ჟურნალში შესვლა სერიალზე}}

მინიშნებები:

თქვენ გამოიყენებთ MCP_CAN კლასის მაგალითს CAN ბიბლიოთეკის ფუნქციონირებაზე წვდომისათვის:

MCP_CAN m_can;

ინიციატივა შეიძლება:

ხოლო (m_can.bain ()! = CAN_OK)

{დაგვიანება (1000); }

შეამოწმეთ და წაიკითხეთ CAN შეტყობინებები:

ხოლო (m_can.checkReceive () == CAN_MSGAVAIL)

{// მიიღეთ CAN id, შეტყობინების სიგრძე და შეტყობინების მონაცემები m_can.readMsgBufID (& m_canId, & m_msgLen, m_msgBuf); // გააკეთე რამე შეტყობინების მონაცემებით აქ}

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

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

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

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

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

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

თუ თქვენ გექნებათ Volvo V70 -02, ეს არის ის, რისკენაც ხართ:

• შეტყობინების ID: 0x0400066 ბიტი 0: 0x00, 0x40, 0x80 ან 0xc0 (არ მაინტერესებს)
• ბაიტი 1: 0x00 (არ მაინტერესებს)
• ბაიტი 2: 0x00 (არ მაინტერესებს)
• ბაიტი 3: 0x00-0x07 (არ მაინტერესებს)
• ბაიტი 4: 0x1f (არ მაინტერესებს)
• ბაიტი 5: 0x40 (არ მაინტერესებს)
• ბაიტი 6: 0x40 (არ მაინტერესებს)
• Byte7: ღილაკის იდენტიფიკატორი: 0x77 = მოცულობა გაზრდილი, 0x7b = მოცულობა შემცირებული, 0x7d = შემდეგი სიმღერა, 0x7e = წინა ჩანაწერი.

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

ნაბიჯი 4: აპარატურის პროტოტიპი

თქვენს აპარატურას უნდა შეეძლოს:

1. განსაზღვრეთ CAN ავტობუსში მიღებული ბრძანებები
2. გაგზავნეთ ბრძანებები სხვა ფორმატში სტერეოზე

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

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

ამის ნაცვლად, მე გამოვიყენე შემდეგი:

• ატმეგა 328, "არდუინოს ტვინი". (არსებობს რამდენიმე ვარიანტი, მიიღეთ ის, რაც უდრის Arduino Uno– ს. თქვენ შეგიძლიათ შეიძინოთ იგი Arduino ჩატვირთვის ჩამტვირთვით ან მის გარეშე.)
• 16 MHz კრისტალი + კონდენსატორები საათის სიგნალისთვის.
• MCP2551 CAN გადამცემი.
• MCP2515 CAN კონტროლერი.
• TSR1-2450, გარდაქმნის 6.5-36V 5V. (არ გამოიყენება პროტოტიპში, რადგან პროგრამული უზრუნველყოფა არ აინტერესებს კვების ბლოკს.)
• CD4066B გადამრთველი, რომელიც გამოყენებული იქნება სტერეოზე ბრძანებების გაგზავნისას.
• რამოდენიმე რეზისტორი. (ღირებულებები შეგიძლიათ იხილოთ არწივის სქემაში შემდგომ საფეხურზე.)

ამ კონფიგურაციის კარგი მხარე ის არის, რომ ის სრულად შეესაბამება Arduino– ს და CAN ფარის ბიბლიოთეკას.

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

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

პროტოტიპი გამოსახულია სურათის ქვედა პურის დაფით. ელექტროენერგიის მიწოდებისთვის, პროგრამირებისთვის და სერიული ჟურნალისთვის იგი ერთვის Arduino Uno- ს, სადაც Atmega ჩიპი ამოღებულია.

ზედა დაფა არის მანქანა + სტერეო სიმულატორი, რომელიც გამოყენებული იქნება პროტოტიპის პირველადი შესამოწმებლად.

პროტოტიპი + სიმულატორი განკუთვნილია ასე მუშაობისთვის:

• დააჭირეთ ერთ -ერთ გადამრთველ ღილაკს სიმულატორის დაფაზე. (ეს არის თქვენი საჭის ღილაკები.)
• როდესაც სიმულატორის პროგრამა ამოიცნობს ღილაკს დააჭირეთ ის გამოაგზავნის შესაბამის CAN შეტყობინებას თითოეული 70 ms სანამ ღილაკს დააჭერთ. (იმის გამო, რომ ჟურნალები, რომლებიც ადრე ავიღე, მიუთითებდა, რომ ასე მუშაობს ჩემს მანქანაში.) ის ასევე გაგზავნის უამრავ "უსარგებლო" CAN შეტყობინებას ავტობუსში სხვა მოძრაობის სიმულაციისთვის.
• CAN შეტყობინებები იგზავნება CAN ავტობუსში.
• CAN შეტყობინებებს იღებს პროტოტიპი.
• MCP2515 ისვრის ყველა დაუკავშირებელ შეტყობინებას, რომელიც ემყარება შეტყობინების id- ს.
• როდესაც MCP2515 მიიღებს შეტყობინებას, რომელიც უნდა იქნას დამუშავებული, ეს მიუთითებს, რომ მას აქვს შეტყობინება.
• ატმეგა წაიკითხავს შეტყობინებას და გადაწყვეტს რომელი ღილაკი უნდა ჩაითვალოს აქტიურად.
• ატმეგა ასევე თვალყურს ადევნებს ბოლო შეტყობინების მიღებას, გარკვეული დროის შემდეგ ღილაკი გათავისუფლებულად ჩაითვლება. (CAN შეტყობინებები მხოლოდ მიუთითებს იმაზე, რომ ღილაკი არ არის ჩართული და არა ის, რომ ის დაჭერილი ან გაშვებული იქნა.)
• თუ ღილაკი ჩაითვლება აქტიურად, CD4066B– ში ერთი ან მეტი კონცენტრატორი გააქტიურდება.
• სიმულატორი (ახლა მოქმედებს როგორც თქვენი სტერეო) აღმოაჩენს, რომ წინააღმდეგობა გამოიყენება წვერსა და ყდის შორის. (წვერი უკავშირდება 3.3 ვ -ს და რეზისტორის საშუალებით ანალოგურ შეყვანის პინს. როდესაც არცერთი ბრძანება არ არის აქტიური, ეს პინი წაიკითხავს 3.3 ვ -ს, როდესაც ბრძანება აქტიურია, მნიშვნელობა უფრო დაბალი გახდება და იდენტიფიცირებს ბრძანებას.
• სანამ ბრძანება აქტიურია შესაბამისი led ასევე გააქტიურდება. (ექვსი led არის, რადგან მე ვგეგმავდი სხვადასხვა გრძელი / მოკლე პრესის გამოყენებას ჩემი ორი ღილაკისთვის.)

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

დამატებითი დეტალები სიმულატორის დაფის ტექნიკის შესახებ:

• კრისტალი 16 MHz
• 22 pF კონდენსატორი
• LED რეზისტორები უნდა შეირჩეს LED თვისებების საფუძველზე
• რეზისტორი დაკავშირებული A7 და 3.3V, აირჩიეთ მაგ. 2 კმ (არ არის კრიტიკული).
• MCP2551 და MCP2515- თან დაკავშირებული რეზისტორები არიან გასაწევი / ჩამოწეული. აირჩიეთ მაგ. 10 kOhm.

(ან თქვენ შეგიძლიათ გამოიყენოთ CAN ფარი სიმულატორის "CAN ნაწილისთვის", თუ გირჩევნიათ.)

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

(არ დაუკავშიროთ რაიმე led პირდაპირ CD 4066B- ს, მას შეუძლია მხოლოდ დაბალი დენის დამუშავება. მე შევეცადე ეს, როდესაც მე პირველად გამოვცადე გამომავალი და ჩიპი უსარგებლო გახდა. კარგი ის არის, რომ მე ვიყიდე რამდენიმე მათგანი მხოლოდ იმიტომ ძალიან იაფია)

ნაბიჯი 5: დაუკრავენ პროგრამირებას

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

(თუ გირჩევნიათ, შეგიძლიათ გამოტოვოთ ეს ნაბიჯი და დაამატოთ საათის დამატებითი აპარატურა.)

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

პირველი თქვენ უნდა იპოვოთ ფაილი სახელწოდებით "boards.txt", რომელიც გამოიყენება თქვენი Arduino IDE- ს მიერ. თქვენ უნდა დააკოპიროთ ჩანაწერი Arduino Uno– სთვის, დაარქვათ მას ახალი სახელი და შეცვალოთ მნიშვნელობა low_fuses– ისთვის.

ჩემი ახალი დაფა ასე გამოიყურება:

#################################################### #############დაფუძნებულია Arduino Uno#ცვლილებები:#დაბალი_ფუჟები შეიცვალა 0xff– დან 0xbf– მდე 16 MHz საათის ჩართვა#გარეთ Atmega PB0/pin 14 = Arduino D8

clkuno.name = გათიშვა (Arduino Uno)

clkuno.upload.protocol = arduino clkuno.upload.maximum_size = 32256 clkuno.upload.speed = 115200 clkuno.bootloader.low_fuses = 0xbf clkuno.bootloader.high_fuses = 0xde clkuno.bootloadererxxxxxxxxxxxx.bootloader.file = optiboot_atmega328.hex clkuno.bootloader.unlock_bits = 0xff clkuno.bootloader.lock_bits = 0xcf clkuno.build.mcu = atmega328p clkuno.build.f_cpu = 16000000L clkunobuild.build = cl.

##############################################################

გაითვალისწინეთ, რომ საათი გამორთულია მისი საკონტროლო ბიტის 0 -ზე დაყენებით.

დაფების კონფიგურაციის ფაილში ახალი დაფის შექმნისას თქვენ უნდა ჩაწეროთ ახალი ჩამტვირთავი ატმეგა. ამის გაკეთების სხვადასხვა გზა არსებობს, მე გამოვიყენე https://www.arduino.cc/en/Tutorial/ArduinoToBreadboard- ში აღწერილი მეთოდი.

მას შემდეგ რაც ამას გააკეთებთ, გახსოვდეთ, რომ შეარჩიოთ დაფის ახალი ტიპი და არა Arduino Uno, როდესაც ატმეგაზე ატვირთავთ პროგრამას.

ნაბიჯი 6: პროგრამული უზრუნველყოფა

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

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

lastReceivedTime = 0

lastReceivedCmd = არცერთი cmdTimeout = 100 კონფიგურაცია () {ჩართეთ watchdog კონფიგურაცია ქინძისთავები D4-D7 როგორც გამომავალი ქინძისთავები CAN setup CAN filter} მარყუჟი () {აღადგინეთ watchdog if (CAN შეტყობინება მიიღება) {თითოეული ღილაკის ბრძანებისთვის {თუ CAN შეტყობინება ეკუთვნის ღილაკის ბრძანება {lastReceivedTime = ახლა lastReceivedCmd = cmd}}} თუ ახლა> lastReceivedTime + cmdTimeout {lastReceivedCmd = არცერთი} თითოეული ღილაკის ბრძანებისთვის {if lastReceivedCmd არის ღილაკის ბრძანება {set command pin output = on} else {set command pin output = off }}}

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

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

ბათილად დაყენება ()

{// დაუშვას მაქსიმუმ 250 ms მარყუჟისთვის wdt_enable (WDTO_250MS); // სხვა init პერსონალი} void loop () {wdt_reset (); // გააკეთე საქმე}

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

ხელმოუწერელი გრძელი ნიღაბი = 0x1fffffff; // შეიყვანეთ ნიღაბში 29 -ე სათაურის ბიტი

ხელმოუწერელი გრძელი ფილტრიId = 0x0400066; // ჩვენ ვზრუნავთ მხოლოდ ამ CAN შეტყობინების id m_can.init_Mask (0, CAN_EXTID, ნიღაბი); // ნიღაბი 0 ვრცელდება ფილტრზე 0-1 m_can.init_Mask (1, CAN_EXTID, ნიღაბი); // ნიღაბი 1 ვრცელდება ფილტრზე 2-5 m_can.init_Filt (0, CAN_EXTID, filterId); m_can.init_Filt (1, CAN_EXTID, filterId); m_can.init_Filt (2, CAN_EXTID, filterId); m_can.init_Filt (3, CAN_EXTID, filterId); m_can.init_Filt (4, CAN_EXTID, filterId); m_can.init_Filt (5, CAN_EXTID, filterId);

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

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

ეს იყო პროგრამის პროტოტიპი შეჯამებით. ჩვენ ასევე გვჭირდება კოდი სიმულატორის დაფისთვის:

lastSentTime = 0

minDelayTime = 70 setup () {დააინსტალირეთ ქინძისთავები A0-A5 როგორც გამომავალი ქინძისთავები დააკონფიგურირეთ ქინძისთავები D4-D7, როგორც შეყვანის ქინძისთავები შიდა ამოღებით. init CAN} loop () {send "junk" can msg set activeButton = none for each button {if button is a pressed {set activeButton = button}} if activeButton! = არცერთი {if now> lastSentTime + minDelayTime {გაგზავნის ღილაკს შეუძლია შეტყობინების გაგზავნა } set lastSentTime = now} inval = წაიკითხეთ pin A7 foreach (cmd) {if (min <inval <max) {led on} else {led off}} დაელოდეთ 1 ms}

ეს განუწყვეტლივ გაგზავნის "უსარგებლო" CAN შეტყობინებებს დაახლოებით ყოველ ms და სანამ ღილაკს დააჭერთ შესაბამის ბრძანებას თითოეული 70 ms.

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

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

თუ გსურთ შეამოწმოთ ჩემი პროგრამები, მათი გადმოწერა შესაძლებელია აქ:

• CAN შეტყობინებების ჟურნალის პროგრამა
• პროგრამა სიმულატორის დაფისთვის
• პროგრამა პროტოტიპის / საბოლოო დაფისთვის

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

ნაბიჯი 7: საბოლოო აპარატურა

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

აქ თქვენ გაქვთ სამი ვარიანტი:

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

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

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

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

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

შემდეგ შეუკვეთეთ მაგ. https://www.seeedstudio.com/fusion_pcb.html. მიჰყევით ინსტრუქციას Gerber ფაილების გენერირებისათვის თქვენი დიზაინიდან. თქვენ ასევე შეგიძლიათ მიიღოთ შედეგის წინასწარი გადახედვა, რათა დარწმუნდეთ რომ ის კარგადაა.

(ბოლოს მე უნდა ავირჩიო სხვა რეზისტორები R4-R7– ისთვის, ვიდრე ეს მოცემულია სქემატურ სურათში. სამაგიეროდ გამოვიყენე 2k, 4.7k, 6.8k და 14.7k.)

და დაიმახსოვრე - არ აურიო Atmega პინ ნუმერაცია Arduino პინ ნუმერაციით!

მე გირჩევთ, რომ არ გააკვალოთ Atmega ჩიპი პირდაპირ, არამედ გამოიყენოთ ბუდე. შემდეგ შეგიძლიათ მარტივად ამოიღოთ ის, თუ დაგჭირდებათ მისი გადაპროგრამება.

ნაბიჯი 8: მანქანის დამონტაჟება

ახლა ყველაზე სახალისო ნაწილზე - დააინსტალირეთ იგი თქვენს მანქანაში და დაიწყეთ მისი გამოყენება! (მას შემდეგ რაც თქვენ გააკეთეთ / იყიდეთ საქმე ამისთვის.)

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

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

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

საბოლოოდ ჩემი ღილაკები ისევ მუშაობს! როგორ გავძლებდი მათ გარეშე ორი თვის განმავლობაში?

ნაბიჯი 9: მომავალი გაუმჯობესება

როგორც აღვნიშნე, თუ ამ ვერსიის 2.0 ვერსიას გავაკეთებ, 4066B სხვა რამით შევცვლი (ალბათ ციფრული პოტენომეტრი) უფრო დიდი მოქნილობისთვის.

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