CAN პროტოკოლი - დიახ, ჩვენ შეგვიძლია !: 24 ნაბიჯი

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

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

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

ნაბიჯი 1: გამოყენებული რესურსები

• ორი მოდული ESP WROOM 32 NodeMcu
• ორი CAN გადამცემი WaveShare– დან
• მხტუნავები კავშირებისთვის
• ლოგიკური ანალიზატორი დაჭერისთვის
• სამი USB კაბელი ESP– ებისთვის და ანალიზატორისთვის
• 10 მეტრი გადაუგრიხეს წყვილი ავტობუსისთვის

ნაბიჯი 2: CAN (კონტროლერის არეალი)

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

ნაბიჯი 3: CAN - მახასიათებლები

• ორი მავთულის სერიული კომუნიკაცია
• მაქსიმუმ 8 ბაიტი სასარგებლო ინფორმაცია კადრზე, ფრაგმენტაციით შესაძლებელია
• მისამართი მიმართულია შეტყობინებაზე და არა კვანძზე
• პრიორიტეტების მინიჭება შეტყობინებებზე და გადაცემა "შეყოვნებული" შეტყობინებებისათვის
• შეცდომების გამოვლენისა და სიგნალის ეფექტური უნარი
• მრავალ სამაგისტრო შესაძლებლობა (ყველა კვანძს შეუძლია მოითხოვოს ავტობუსზე წვდომა)
• Multicast შესაძლებლობა (ერთი შეტყობინება ერთდროულად რამდენიმე მიმღებისთვის)
• გადაცემის სიჩქარე 1 მბიტ / წმ-მდე 40 მეტრიან ავტობუსში (განაკვეთის შემცირება ავტობუსის სიგრძის ზრდასთან ერთად)
• კონფიგურაციის მოქნილობა და ახალი კვანძების დანერგვა (120 კვანძამდე ავტობუსში)
• სტანდარტული აპარატურა, დაბალი ღირებულება და კარგი ხელმისაწვდომობა
• რეგულირებული პროტოკოლი: ISO 11898

ნაბიჯი 4: წრე გამოიყენება

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

ნაბიჯი 5: გადამცემი ხაზის ძაბვები (დიფერენციალური გამოვლენა)

CAN– ში დომინანტი ბიტი არის ნული.

ხაზის დიფერენციალური გამოვლენა ამცირებს ხმაურის მგრძნობელობას (EFI)

ნაბიჯი 6: CAN სტანდარტებისა და ჩარჩოების ფორმატი

სტანდარტული ფორმატი 11 ბიტიანი იდენტიფიკატორით

ნაბიჯი 7: CAN სტანდარტებისა და ჩარჩოების ფორმატი

გაფართოებული ფორმატი 29 ბიტიანი იდენტიფიკატორით

ნაბიჯი 8: CAN სტანდარტებისა და ჩარჩოების ფორმატი

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

ნაბიჯი 9: ოთხი სახის ჩარჩო (ჩარჩო)

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

ოთხი სახის ჩარჩო (ჩარჩო)

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

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

ნაბიჯი 10: წრე - კავშირების დეტალები

ნაბიჯი 11: წრე - მონაცემთა გადაღება

სტანდარტული CAN– ისთვის მიღებული ტალღის სიგრძე 11 ბიტიანი ID– ით

ნაბიჯი 12: წრე - მონაცემთა გადაღება

ტალღის სიგრძე მიღებულია გაფართოებული CAN– ისთვის 29 ბიტიანი ID– ით

ნაბიჯი 13: წრე - მონაცემთა გადაღება

მონაცემები მიღებული ლოგიკური ანალიზატორით

ნაბიჯი 14: Arduino ბიბლიოთეკა - CAN

აქ მე ვაჩვენებ ორ ვარიანტს, სადაც შეგიძლიათ დააინსტალიროთ CAN Driver Library

Arduino IDE ბიბლიოთეკის მენეჯერი

ნაბიჯი 15: Github

github.com/sandeepmistry/arduino-CAN

ნაბიჯი 16: გადამცემის წყაროს კოდი

წყაროს კოდი: მოიცავს და აყენებს ()

ჩვენ ჩავრთავთ CAN ბიბლიოთეკას, დავიწყებთ გამართვის სერიას და დავიწყებთ CAN ავტობუსს 500 kbps.

#მოიცავს // შეიტანეთ ბიბლიოთეკა CAN void setup () {Serial.begin (9600); // inicia serial para debug while (! Serial); Serial.println ("გადამცემი CAN"); // Inicia o barramento CAN a 500 kbps if (! CAN.begin (500E3)) {Serial.println ("Falha ao iniciar o controlador CAN"); // დროებითი კონტროლის შესაძლებლობა (1); }}

ნაბიჯი 17: კოდის კოდი: Loop (), სტანდარტული CAN 2.0 პაკეტის გაგზავნა

სტანდარტული CAN 2.0 გამოყენებით, ჩვენ ვაგზავნით პაკეტს. 11-ბიტიანი ID განსაზღვრავს შეტყობინებას. მონაცემთა ბლოკს უნდა ჰქონდეს 8 ბაიტი. ის იწყებს პაკეტს ID 18 თექვსმეტობით. ის ათავსებს 5 ბაიტს და ხურავს ფუნქციას.

void loop () {// Usando o CAN 2.0 padrão // Envia um pacote: o id tem 11 bits e identifica a mensagem (prioridade, evento) // o bloco de dados deve possuir até 8 bytes Serial.println ("Enviando pacote … "); CAN.beginPacket (0x12); // id 18 em თექვსმეტობითი CAN.write ('h'); // 1º ბაიტი CAN.write ('e'); // 2º ბაიტი CAN.write ('l'); // 3º ბაიტი CAN.write ('l'); // 4º ბაიტი CAN.write ('o'); // 5º ბაიტი CAN.endPacket (); // encerra o pacote para envio Serial.println ("ენვიადო"); დაგვიანება (1000);

ნაბიჯი 18: კოდის კოდი: მარყუჟი (), გაფართოებული CAN 2.0 პაკეტის გაგზავნა

ამ ეტაპზე ID- ს აქვს 29 ბიტი. ის იწყებს 24 ბიტიანი პირადობის მოწმობის გაგზავნას და კიდევ ერთხელ ათავსებს 5 ბაიტს და წყვეტს.

// Usando CAN 2.0 Estendido // Envia um pacote: o id tem 29 bits e identifica a menagemem (prioridade, evento) // o bloco de dados deve possuir até 8 bytes Serial.println ("Enviando pacote estendido…"); CAN.beginExtendedPacket (0xabcdef); // id 11259375 ათობითი (abcdef em hexa) = 24 ბიტი preenchidos até aqui CAN.write ('w'); // 1º ბაიტი CAN.write ('o'); // 2º ბაიტი CAN.write ('r'); // 3º ბაიტი CAN.write ('l'); // 4º ბაიტი CAN.write ('d'); // 5º ბაიტი CAN.endPacket (); // encerra o pacote para envio Serial.println ("ენვიადო"); დაგვიანება (1000); }

ნაბიჯი 19: მიმღების საწყისი კოდი

წყაროს კოდი: მოიცავს და აყენებს ()

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

#მოიცავს // შეიტანეთ ბიბლიოთეკა CAN void setup () {Serial.begin (9600); // inicia serial para debug while (! Serial); Serial.println ("რეცეპტორი CAN"); // Inicia o barramento CAN a 500 kbps if (! CAN.begin (500E3)) {Serial.println ("Falha ao iniciar o controlador CAN"); // როდესაც თქვენ გაქვთ შესაძლებლობა გამოიყენოთ კონტროლი (1); }}

ნაბიჯი 20: კოდის კოდი: Loop (), პაკეტის მიღება და ფორმატის შემოწმება

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

void loop () {// Tenta verificar o tamanho do acote recebido int packetSize = CAN.parsePacket (); if (packetSize) {// Se temos um pacote Serial.println ("Recebido pacote."); if (CAN.packetExtended ()) {// verifica se o pacote é estendido Serial.println ("ესტენდიდო"); }

ნაბიჯი 21: წყარო: Loop (), ამოწმებს, არის თუ არა დისტანციური პაკეტი

აქ ჩვენ ვამოწმებთ არის თუ არა მიღებული პაკეტი მონაცემთა მოთხოვნა. ამ შემთხვევაში მონაცემები არ არსებობს.

თუ (CAN.packetRtr ()) {// Verifica se o pacote é um pacote remoto (Requisição de dados), neste caso não há dados Serial.print ("RTR"); }

ნაბიჯი 22: წყაროს კოდი: მარყუჟი (), მონაცემთა სიგრძე მოთხოვნილი ან მიღებული

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

Serial.print ("Pacote com id 0x"); Serial.print (CAN.packetId (), HEX); if (CAN.packetRtr ()) {// se o pacote recebido é de requisição, indicamos o comprimento solicitado Serial.print ("e requsitou o comprimento"); Serial.println (CAN.packetDlc ()); // obtem o DLC (Data Length Code, que indica o comprimento dos dados)} else {Serial.print ("e comprimento"); // aqui somente indica o comprimento recebido Serial.println (packetSize);

ნაბიჯი 23: წყაროს კოდი: მარყუჟი (), თუ მონაცემები მიღებულია, ის შემდეგ ბეჭდავს

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

// Imprime os dados somente se o pacote Recebido não foi de requisição while (CAN.available ()) {Serial.print ((char) CAN.read ()); } Serial.println (); } Serial.println (); }}

ნაბიჯი 24: ჩამოტვირთეთ ფაილები

PDF

ინო