AVRSH: ბრძანების თარჯიმანი Shell არდუინოსთვის/AVR .: 6 ნაბიჯი (სურათებით)

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

ოდესმე გსურდათ "შესვლა" თქვენს AVR მიკროკონტროლერში? ოდესმე გიფიქრიათ, რომ მაგარი იქნებოდა რეგისტრაციის "კატა" მისი შინაარსის სანახავად? ყოველთვის გსურდათ თქვენი AVR ან Arduino– ს ინდივიდუალური პერიფერიული ქვესისტემების * რეალურ დროში * გააქტიურების და გათიშვის საშუალება? მეც, ასე დავწერე AVR Shell, UNIX- ის მსგავსი ჭურვი. ის UNIX- ის მსგავსია, რადგან ის მოგაგონებთ იმ ჭურვის ანგარიშს, რომელიც თქვენ წადით და იყიდეთ თქვენი irc nick შეჯახების ბოტების გასაშვებად, ასევე ერთი ან ორი საერთო ბრძანების მქონე. მას ასევე აქვს ფაილური სისტემა, რომელიც წააგავს UNIX extfs– ს, გარე EEPROM– ის გამოყენებით, მაგრამ ეს გახდა პროექტი თავისთავად, ამიტომ მე გამოვუშვებ ამ მოდულს ცალკე, სხვა ინსტრუქციის მიხედვით, როდესაც ის მზად იქნება წარმოებისთვის. აქ არის ჩამონათვალი იმისა, რისი გაკეთებაც ამჟამად შეგიძლიათ AVR Shell– ით:

• წაიკითხეთ ყველა თქვენი მონაცემთა მიმართულების რეგისტრატორი (DDRn), პორტები და ქინძისთავები რეალურ დროში
• დაწერეთ თქვენი ყველა DDRn, პორტი და ქინძისთავი, რომ ჩართოთ ძრავები, LED- ები ან წაიკითხოთ სენსორები რეალურ დროში
• ჩამოთვალეთ ყველა ცნობილი რეგისტრი სისტემაში
• შექმენით და შეინახეთ ღირებულებები მომხმარებლის მიერ განსაზღვრულ ცვლადებში, რომლებსაც აქვს EEPROM მხარდაჭერა.
• შექმენით ძირეული პაროლი და დაადასტურეთ მის წინააღმდეგ (გამოიყენება ტელნეტზე წვდომისთვის)
• წაიკითხეთ კონფიგურირებული პროცესორის საათის სიჩქარე
• შეცვალეთ თქვენი პროცესორის საათის სიჩქარე წინასწარი გამომცემლის დაყენებით
• დაიწყეთ და შეაჩერეთ 16-ბიტიანი ქრონომეტრები სხვადასხვა საგნების დროზე
• გააქტიურეთ და/ან გამორთეთ პერიფერიული ქვესისტემები: ანალოგური ციფრული გადამყვანები (ADC), სერიული პერიფერიული ინტერფეისი (SPI), ორ მავთულის ინტერფეისი (TWI/I2C), UART/USART. სასარგებლოა მაშინ, როდესაც გსურთ მიკროკონტროლერის ენერგიის მოხმარების შემცირება ან გარკვეული ფუნქციების ჩართვა.
• დაწერილია C ++ - ზე მრავალჯერადი გამოყენების ობიექტებით.

ეს ინსტრუქცია გაივლის avrsh– ის ინსტალაციას, გამოყენებას და პერსონალიზაციას.

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

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

• გქონდეთ Arduino ან ATmega328P. სხვა AVR– ებმა შეიძლება იმუშაონ, მაგრამ შეიძლება დაგჭირდეთ კოდის შეცვლა, რათა ჩამოთვალოთ ნებისმიერი რეგისტრი, რომელიც უნიკალურია თქვენი MCU– სთვის. სახელები მხოლოდ უნდა ემთხვეოდეს იმას, რაც ჩამოთვლილია სათაურის ფაილში უნიკალური თქვენი MCU– სთვის. ბევრი რეგისტრის სახელი ერთნაირია AVR– ებს შორის, ასე რომ თქვენი გარბენი შეიძლება განსხვავდებოდეს პორტირებისას.
• გქონდეთ საშუალება დაუკავშირდეთ თქვენი Arduino/AVR– ის სერიულ USART– ს. სისტემა ყველაზე ფართოდ იქნა გამოცდილი AVR ტერმინალით, Windows პროგრამით, რომელიც ახორციელებს სერიულ კავშირს თქვენი USB ან COM პორტის საშუალებით. მუშაობს Arduinos– თან USB კავშირის და ნებისმიერი AVR– ის გამოყენებით USB-BUB– დან Moderndevice.com– დან. სხვა ტერმინალის ვარიანტებია: Putty, minicom (Linux და FreeBSD), ეკრანი (Linux/FreeBSD), Hyperterminal, Teraterm. მე აღმოვაჩინე, რომ ბოთლი და ტერატერმი ნაგავს აგზავნიან დაკავშირებისას, რათა თქვენი პირველი ბრძანება გაფუჭდეს.
• დააინსტალირეთ და გაუშვით AVR Shell firmware, რომელიც შეგიძლიათ გადმოწეროთ ამ გვერდებიდან, ან ყოველთვის მიიღოთ უახლესი ვერსია BattleDroids.net– ზე.

AVR ტერმინალის ინსტალაციისთვის, უბრალოდ გახსენით იგი და გაუშვით. AVR Shell- ის პროგრამული უზრუნველყოფის ინსტალაციისთვის გადმოწერეთ იგი ან ატვირთეთ პირდაპირ ექვსკუთხა ფაილი და დააკავშირეთ თქვენი სერიული ტერმინალი 9600 baud– ზე, ან თავად შეადგინეთ ის „make“- ით და შემდეგ „შექმენით პროგრამა“ჰექსექსუსის ასატვირთად. გაითვალისწინეთ, შეიძლება დაგჭირდეთ AVRDUDE პარამეტრების შეცვლა თქვენი COM პორტის ასახვის მიზნით. შენიშვნა: PROGMEM ატრიბუტი გატეხილია AVR GCC ახლანდელ განხორციელებაში C ++ - ზე და ეს არის ცნობილი შეცდომა. თუ მას ადგენთ, ველით, რომ მიიღებთ ბევრ გამაფრთხილებელ შეტყობინებას, სადაც ნათქვამია: „გაფრთხილება: მხოლოდ ინიციალიზებული ცვლადები შეიძლება მოთავსდეს პროგრამის მეხსიერების არეში“. გარდა იმისა, რომ შემაშფოთებელი სანახავია, ეს გაფრთხილება უვნებელია. რადგან ჩადგმულ პლატფორმაზე C ++ არ არის მაღალი AVR GCC პრიორიტეტების სიაში, უცნობია როდის დაფიქსირდება ეს. თუ შეამოწმებთ კოდს, დაინახავთ, სადაც მე გავაკეთე სამუშაოები ამ გაფრთხილების შესამცირებლად ჩემი საკუთარი ატრიბუტის განცხადებების განხორციელებით. საკმაოდ მარტივია. გადმოწერეთ და დააინსტალირეთ ყველაფერი რაც შეიძლება დაგჭირდეთ გვერდის გადასაბრუნებლად და მოდით დავიბენი.

ნაბიჯი 2: რეგისტრების კითხვა და წერა

AVR Shell დაიწერა პირველ რიგში იმ სენსორების შესასვლელად, რომლებიც მე ჩემს AVR- თან მქონდა დაკავშირებული. იგი დაიწყო მარტივი LED- ით, შემდეგ გადავიდა სინათლის სენსორებზე, ტემპერატურის სენსორებზე და ბოლოს ორ ულტრაბგერითი გადამყვანზე. avrsh- ს შეუძლია ამ სენსორების ციფრული კომპონენტების დაყენება მათ კონტროლის ქვეშ მყოფ რეგისტრებზე წერილობით. გაშვებისას AVR რეგისტრებით მანიპულირება თქვენი Arduino– ზე ყველა ცნობილი რეგისტრის სიის მისაღებად ჩაწერეთ:

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

მე ვიცი შემდეგი რეგისტრების შესახებ:

TIFR0 PORTC TIFR1 PORTD TIFR2 DDRD PCIFR DDRB EIFR DDRC EIMSK PINB EECR პინკი EEDR PIND Sreg EEARL GPIOR0 EEARH GPIOR1 GTCCR GPIOR2 TCCR0A TCCR0B TCNT0 OCR0A OCR0B SPCR SPDR ACSR SMCR MCUSR MCUCR SPMCSR WDTCSR CLKPR PRR OSCCAL PCICR EICRA PCMSK0 PCMSK1 TIMSK0 TIMSK1 TIMSK2 ADCL ADCH ADCSRA ADCSRB ADMUX DIDR0 DIDR1 TCCR1A TCCR1B TCCR1C TCNT1L TCNT1H ICR1L ICR1H OCR1AL OCR1AH OCR1BL OCR1BH TCCR2A TCCR2B TCNT2 OCR2A OCR2B ასსრ TWBR TWSR twar TWDR TWCR TWAMR UCSR0A UCSR0B UCSR0C UBRR0L UBRR0H UDR0 PORTB root @ ATmega328p> იმის სანახავად, თუ როგორ არის დაყენებული ინდივიდუალური ბიტები ნებისმიერ რეგისტრში, გამოიყენეთ კატის ან ექოს ბრძანება

კატა %GPIOR0 აქ მე ვთხოვ ბრძანების თარჯიმანს აჩვენოს ან ეხმიანოს ზოგადი დანიშნულების I/O რეესტრის შინაარსი #0. გაითვალისწინეთ პროცენტის ნიშანი (%) რეგისტრაციის სახელის წინ. თქვენ გჭირდებათ ეს, რომ მიუთითოთ გარსზე, რომ ეს არის დაცული საკვანძო სიტყვა, რომელიც განსაზღვრავს რეგისტრს. Echo ბრძანების ტიპიური გამომავალი ასე გამოიყურება

GPIOR0 (0x0) დაყენებულია [00000000] გამომავალი აჩვენებს რეგისტრატორის სახელს, რეგისტრში ნაპოვნი თექვსმეტობით მნიშვნელობას და რეგისტრის ორობითი გამოსახულებას (თითოეული ბიტის ჩვენება 1 ან 0). ნებისმიერი ბიუსტის რეესტრში დასაყენებლად გამოიყენეთ ოპერატორი "ინდექსი" . მაგალითად, ვთქვათ, მინდა მე –3 ბიტი 1 – ზე

%GPIOR0 [3] = 1 და ჭურვი მოგცემთ პასუხს, რომელიც მიუთითებს მის მოქმედებაზე და შედეგზე

GPIOR0 (0x0) დაყენებულია [00000000] (0x8) დაყენებულია [00001000] ნუ დაგავიწყდებათ პროცენტის ნიშანი, რომ უთხრათ გარსს, რომ თქვენ მუშაობთ რეესტრში. ასევე გაითვალისწინეთ, რომ მე –3 ბიტის დაყენებით, ეს არის 4 ბიტი, რადგან ჩვენი AVR იყენებს ნულოვან ინდექსს. სხვა სიტყვებით რომ ვთქვათ, მე –3 ბიტამდე დათვლისას თქვენ ითვლით 0, 1, 2, 3, რაც მე –4 ადგილია, მაგრამ მე –3 ბიტი. თქვენ შეგიძლიათ გაწმინდოთ ცოტათი იმავე გზით, ოდნავ ნულის დაყენებით. მსგავსი ბიტების დაყენებით თქვენ შეგიძლიათ შეცვალოთ თქვენი AVR ფუნქციონირება ფრენის დროს. მაგალითად, OCR1A- ში ნაპოვნი CTC ტაიმერის შესატყვისი მნიშვნელობის შეცვლით. ის ასევე გაძლევთ საშუალებას გადახედოთ კონკრეტულ პარამეტრებს, რომელთა პროგრამული შემოწმება მოგიწევთ თქვენს კოდში, როგორიცაა UBBR მნიშვნელობა თქვენი ბოდის მაჩვენებლისთვის. DDRn, PORTn და PINn– ით მუშაობა I/O ქინძისთავები ასევე ენიჭება რეგისტრებს და მათი დაყენება შესაძლებელია ზუსტად იგივე გზით, მაგრამ შეიქმნა სპეციალური სინტაქსი ამ ტიპის რეგისტრებთან მუშაობისთვის. კოდში არის ნორმალური პროცესი, ვთქვათ, LED- ის ან სხვა მოწყობილობის ჩართვისთვის, რომელიც მოითხოვს ციფრულ მაღალს ან დაბალს. ის მოითხოვს მონაცემთა მიმართულების რეესტრის დაყენებას, რათა მიუთითოს, რომ pin არის გამომავალი, შემდეგ კი 1 ან 0 დაწეროს კონკრეტულ ბიტზე სწორ პორტში. დავუშვათ, რომ ჩვენ გვაქვს LED დაკავშირებული ციფრულ პინ 13 -თან (PB5) და ჩვენ გვინდა მისი ჩართვა, აი როგორ გავაკეთოთ ეს სანამ თქვენი AVR მუშაობს

დააყენეთ pin pb5 გამოწერა ჩაწერეთ pin pb5 მაღალი გამომავალი, გარდა იმისა, რომ თქვენ ხედავთ თქვენი LED- ს ჩართვას, ასე გამოიყურება

root@ATmega328p> დააყენეთ pin pb5 გამომავალი Set pb5 for outputroot@ATmega328p> ჩაწერეთ pin pb5 მაღალი დაწერეთ ლოგიკა მაღალი pin pb5 "Root@ATmega328p>" არის ჭურვის მოთხოვნა, რომელიც მიუთითებს, რომ ის მზად არის მიიღოს თქვენგან ბრძანებები. LED- ის გამორთვის მიზნით, თქვენ უბრალოდ დაწერთ დაბალ პინზე. თუ გსურთ ციფრული შეყვანის წაკითხვა პინიდან, გამოიყენეთ წაკითხვის ბრძანება. ჩვენი ზემოთ მოყვანილი მაგალითის გამოყენებით

root@ATmega328p> წაიკითხეთ pin pb5 pin: pb5 არის მაღალი გარდა ამისა, უბრალოდ გაიმეორეთ pin რეგისტრი, რომელიც აკონტროლებს ამ pin პორტს. მაგალითად, თუ ჩვენ გვაქვს ციფრული პინ 7 და 8 (PD7 და PD8) ციფრულ პინებთან დაკავშირებული დიპლომატიური გადამრთველები, შეგიძლიათ ბრძანება გაგზავნოთ

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

ნაბიჯი 3: კითხულობს და წერს დაუკრავენ

დაუკრავენ სპეციალური ტიპის რეგისტრებს. ისინი აკონტროლებენ ყველაფერს თქვენი მიკროკონტროლის საათის სიჩქარედან დაწყებული, თუ რა პროგრამირების მეთოდებია ხელმისაწვდომი EEPROM- ის დასაწერად. ზოგჯერ თქვენ დაგჭირდებათ ამ პარამეტრების შეცვლა, განსაკუთრებით იმ შემთხვევაში, თუ თქვენ შექმნით დამოუკიდებელ AVR სისტემას. დარწმუნებული არ ვარ, რომ თქვენ უნდა შეცვალოთ თქვენი დაუკრავენ პარამეტრები Arduino– ზე. იყავით ფრთხილად თქვენს დაუკრავეებთან; თქვენ შეგიძლიათ ჩაკეტოთ საკუთარი თავი, თუ მათ არასწორად დააყენებთ. წინა ინსტრუქციებში მე ვაჩვენე, თუ როგორ შეგიძლიათ წაიკითხოთ და დააყენოთ თქვენი დამცავი პროგრამისტი და avrdude. აქ მე გაჩვენებთ, თუ როგორ უნდა წაიკითხოთ თქვენი დამცავები გაშვების დროს, რომ ნახოთ როგორ დააყენა რეალურად მათმა MCU– მ. გაითვალისწინეთ, რომ ეს არ არის შედგენის დროის პარამეტრი, რომელსაც თქვენ იღებთ განმარტებებისგან, არამედ ფაქტობრივი დაუკრავენ, რადგან MCU მათ კითხულობს გაშვების დროს. ცხრილი 27-9 ATmega328P მონაცემთა ცხრილში (მონაცემთა ბაზა, უფრო მეტად) Fuse Low Byte- ის ბიტი შემდეგია:

CKDIV8 CKOUT SUT1 SUT0 CKSEL3 CKSEL2 CKSEL1 CKSEL0საინტერესოა, რომ დაუკრავენ, 0 ნიშნავს დაპროგრამებულს, ხოლო 1 ნიშნავს, რომ ეს ბიტი დაუპროგრამებულია. გარკვეულწილად კონტრ-ინტუიციურია, მაგრამ მას შემდეგ რაც შეიტყობთ, იცით.

• CKDIV8 ადგენს თქვენს პროცესორის საათს 8 -ზე გაყოფაზე. ATmega328P მოდის ქარხნიდან დაპროგრამებული გამოიყენოს თავისი შიდა ოსცილატორი 8MHz– ზე CKDIV8 დაპროგრამებული (ანუ 0 – ზე დაყენებული), რაც მოგცემთ საბოლოო F_CPU ან CPU სიხშირეს 1 MHz. Arduino– ზე, ეს იცვლება მას შემდეგ, რაც ისინი კონფიგურებულია გამოიყენონ გარე ოსცილატორი 16 MHz– ზე.
• CKOUT პროგრამირებისას გამოუშვებს თქვენს პროცესორის საათს PB0- ზე, რომელიც ციფრული პინ 8 -ია Arduinos– ზე.
• SUT [1..0] განსაზღვრავს თქვენი AVR გაშვების დროს.
• CKSEL [3..0] ადგენს საათის წყაროს, როგორიცაა შიდა RC ოსცილატორი, გარე ოსცილატორი და ა.

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

root@ATmega328p> წაიკითხეთ lfuse ქვედა დაუკრავენ: 0xffასე რომ, ყველა ბიტი მითითებულია 1. მე იგივე პროცედურა გავაკეთე არდუინოს კლონზე და მივიღე იგივე მნიშვნელობა. ერთი ჩემი დამოუკიდებელი AVR სისტემის შემოწმებისას მე მივიღე 0xDA, რომელიც არის ის მნიშვნელობა, რომელიც ჩიპის კონფიგურაციის დროს გარკვეული დროის განმავლობაში დაყენებული მქონდა. იგივე პროცედურა გამოიყენება High Fuse Byte, Extended Fuse Byte და Lock fuses შემოწმების მიზნით. კალიბრაცია და ხელმოწერა დაუკრავენ ბაიტებს კოდში გამორთული აქვს #if 0 წინასწარი დამუშავების დირექტივა, რომელიც შეგიძლიათ შეცვალოთ, თუ თავს დამცირებულად იგრძნობთ.

ნაბიჯი 4: სხვა ბრძანებები

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

root@ATmega328p> fcpuCPU სიხშირე: 16000000ეს არის 16 მილიონი, ანუ 16 მილიონი ჰერცი, უფრო ხშირად ცნობილია როგორც 16 MHz. თქვენ შეგიძლიათ შეცვალოთ ეს ფრენის დროს, ნებისმიერი მიზეზის გამო, საათის ბრძანებით. ეს ბრძანება იღებს ერთ არგუმენტს: წინასწარი გამომცემელი, რომელიც უნდა გამოიყენოთ საათის სიჩქარის გაყოფისას. საათის ბრძანებას ესმის წინამორბედი მნიშვნელობები:

• ckdiv2
• ckdiv4
• ckdiv8
• ckdiv16
• ckdiv32
• ckdiv64
• ckdiv128
• ckdiv256

ბრძანების გამოყენებით:

საათი ckdiv2 როდესაც თქვენი პროცესორის სიჩქარე 16 MHz იქნება, თქვენი საათის სიჩქარე შეიცვლება 8 MHz– მდე. Ckdiv64– ის წინასწარი გამრიცხველიანების გამოყენებით საწყისი საათის სიჩქარე 16 MHz გამოიწვევს საბოლოო საათის სიჩქარეს 250 KHz. რატომ გსურთ დედამიწაზე თქვენი MCU გახადოთ ნელი? ერთი, საათის უფრო დაბალი სიჩქარე მოიხმარს ნაკლებ ენერგიას და თუ თქვენ გაქვთ MCU ბატარეა დამთავრებული პროექტის შენობაში, შეიძლება არ დაგჭირდეთ მისი მაქსიმალური სიჩქარით გაშვება და, შესაბამისად, შეამციროს სიჩქარე და შეამციროს მისი ენერგიის მოხმარება, გაზრდის ბატარეის ხანგრძლივობას. ასევე, თუ თქვენ იყენებთ საათს სხვა სახის MCU– სთან დაკავშირებული დროის საკითხებთან დაკავშირებით, ვთქვათ, პროგრამული უზრუნველყოფის UART– ის დანერგვისას ან რაიმე მსგავსი, შეიძლება დაგჭირდეთ მისი დაყენება კონკრეტულ მნიშვნელობაზე, რომლის საშუალებითაც ადვილია კარგი თანაბარი სიჩქარის მიღება შეცდომის დაბალი მაჩვენებლები. პერიფერიული ქვესისტემების გააქტიურება და გათიშვა იმავე შენიშვნის მსგავსად, როგორც ზემოთ ნახსენები ენერგიის მოხმარება, შეიძლება დაგჭირდეთ ენერგიის შემდგომი შემცირება ზოგიერთი ბორტ პერიფერიული მოწყობილობის გამორთვით, რომელსაც თქვენ არ იყენებთ. ბრძანების თარჯიმანს და გარსს შეუძლია გააძლიეროს და გამორთოს შემდეგი პერიფერიული მოწყობილობები:

• ანალოგური ციფრული გადამყვანი (ADC). ეს პერიფერიული გამოიყენება მაშინ, როდესაც თქვენ გაქვთ ანალოგური სენსორი, რომელიც აწვდის მონაცემებს (როგორიცაა ტემპერატურა, შუქი, აჩქარება და ა. შ.) და გჭირდებათ მისი ციფრულ მნიშვნელობად გადაყვანა.
• სერიული პერიფერიული ინტერფეისი (SPI). SPI ავტობუსი გამოიყენება სხვა SPI მოწყობილობებთან კომუნიკაციისთვის, როგორიცაა გარე მეხსიერება, LED დრაივერი, გარე ADC და ა.შ. თუ თქვენ პროგრამირებას აკეთებთ ინტერნეტ პროვაიდერის საშუალებით.
• ორი მავთულის ინტერფეისი. ზოგიერთი გარე მოწყობილობა იყენებს I2C ავტობუსს კომუნიკაციისთვის, თუმცა ეს სწრაფად იცვლება SPI- ჩართული მოწყობილობებით, რადგან SPI– ს აქვს უფრო დიდი გამტარუნარიანობა.
• USART. ეს არის თქვენი სერიული ინტერფეისი. თქვენ ალბათ არ გსურთ ამის გამორთვა, თუ თქვენ დაკავშირებული ხართ AVR– თან სერიული კავშირის საშუალებით! თუმცა, მე დავამატე ეს აქ, როგორც ჩონჩხი იმ მოწყობილობებზე გადასატანად, რომლებსაც აქვთ მრავალი USART მსგავსი ATmega162 ან ATmega644P.
• ყველა ეს არგუმენტი powerup ან powerdown ბრძანებაზე ჩართავს ყველა აღნიშნულ პერიფერიულ მოწყობილობას ან გამორთავს მათ ყველა ერთი ბრძანებით. კიდევ ერთხელ, გამოიყენეთ ეს ბრძანება გონივრულად.

root@ATmega328p> powerdown twi Powerdown of twi complete.root@ATmega328p> powerup twi Powerup of twi სრული.

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

ტაიმერის დაწყებადა შეაჩერე ტაიმერი გაჩერების არგუმენტით

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

root@ATmega328p> ტაიმერის დაწყება დაიწყო timer.root@ATmega328p> ტაიმერის გაჩერება გასული დრო: ~ 157 წამი ავთენტიფიკაცია ჭურვს შეუძლია შეინახოს 8-სიმბოლოიანი პაროლი EEPROM– ში. პაროლის ეს მექანიზმი შეიქმნა ტელნეტში შესვლის შესაძლებლობების მხარდასაჭერად, მაგრამ შეიძლება გაფართოვდეს სხვა ნივთების დასაცავად. მაგალითად, თქვენ შეიძლება მოითხოვოთ გარკვეული ბრძანებები, როგორიცაა რეგისტრაციის მნიშვნელობების შეცვლა, ავტორიზაციის მექანიზმის მეშვეობით. პაროლის დაყენება პაროლის ბრძანებით

root@ATmega328p> passwd blah დაწერეთ root პაროლი EEPROM– შიავტორიზაცია გაუწიეთ პაროლს (ან მოითხოვეთ პროგრამულად ავტორიზაცია კოდის საშუალებით), ავტორიზაციის ბრძანებით. გაითვალისწინეთ, რომ თუ თქვენ ცდილობთ შეცვალოთ ძირეული პაროლი და უკვე არის დაყენებული ძირეული პაროლი, თქვენ უნდა იყოთ ავტორიზებული ძველი პაროლის წინააღმდეგ, სანამ მის ახალ პაროლზე შეცვლის უფლებას მიიღებთ

root@ATmega328p> passwd blinky თქვენ უნდა მიანიჭოთ საკუთარ თავს უფლება.რა თქმა უნდა, თქვენ დაგჭირდებათ avrsh.eep ფაილის ჩატვირთვა, თუ წაშლით firmware- ს თქვენი ძველი მნიშვნელობებისა და ცვლადების აღსადგენად. Makefile შექმნის თქვენთვის EEPROM ფაილს. ცვლადები Shell- ს ესმის მომხმარებლის მიერ განსაზღვრული ცვლადების ცნება. კოდი ზღუდავს ამას 20 -მდე, მაგრამ შეგიძლიათ შეცვალოთ ის თუ გსურთ, განსაზღვრეთ MAX_VARIABLES- ის სკრიპტში. H. თქვენ შეგიძლიათ შეინახოთ ნებისმიერი 16-ბიტიანი მნიშვნელობა (ანუ ნებისმიერი რიცხვი 65-მდე, 536-მდე) ცვლადში, რომელიც მოგვიანებით გაიხსენება. სინტაქსი მსგავსია რეგისტრებისა, გარდა იმისა, რომ დოლარის ნიშანი ($) გამოიყენება გარსში ცვლადების აღსანიშნავად. ჩამოთვალეთ ყველა თქვენი ცვლადი ბეჭდვის ცვლადების ბრძანებით

ბეჭდვის ცვლადები მომხმარებლის მიერ განსაზღვრული ცვლადები: ინდექსის სახელი -> მნიშვნელობა (01): $ FREE $ -> 0 (02): $ FREE $ -> 0 (03): $ FREE $ -> 0 (04): $ FREE $ -> 0 (05): $ FREE $ -> 0 (06): $ FREE $ -> 0 (07): $ FREE $ -> 0 (08): $ FREE $ -> 0 (09): $ FREE $ -> 0 (10): $ FREE $ -> 0 (11): $ FREE $ -> 0 (12): $ FREE $ -> 0 (13): $ FREE $ -> 0 (14): $ FREE $ -> 0 (15): $ FREE $ -> 0 (16): $ FREE $ -> 0 (17): $ FREE $ -> 0 (18): $ FREE $ -> 0 (19): $ FREE $ -> 0 (20): $ უფასო $ -> 0 დასრულებულია.დააყენეთ ცვლადი

$ newvar = 25 $ ვადა = 23245მიიღეთ მოცემული ცვლადის მნიშვნელობა

root@ATmega328p> echo $ newvar $ newvar 25თქვენ ხედავთ, თუ რა ცვლადები გაქვთ გაკეთებული ინსტალაციისთვის უკვე ცნობილი ბეჭდვის ბრძანებით

მომხმარებლის მიერ განსაზღვრული ცვლადები: ინდექსის სახელი -> მნიშვნელობა (01): newvar -> 25 (02): დროის გასვლა -> 23245 (03): $ FREE $ -> 0 (04): $ FREE $ -> 0 (05): $ FREE $ -> 0 (06): $ FREE $ -> 0 (07): $ FREE $ -> 0 (08): $ FREE $ -> 0 (09): $ FREE $ -> 0 (10): $ FREE $ -> 0 (11): $ FREE $ -> 0 (12): $ FREE $ -> 0 (13): $ FREE $ -> 0 (14): $ FREE $ -> 0 (15): $ FREE $ -> 0 (16): $ FREE $ -> 0 (17): $ FREE $ -> 0 (18): $ FREE $ -> 0 (19): $ FREE $ -> 0 (20): $ უფასო $ -> 0 დასრულებულია.$ FREE $ სახელი უბრალოდ მიუთითებს იმაზე, რომ ცვლადის მდებარეობა თავისუფალია და მას ჯერ არ აქვს მინიჭებული ცვლადის სახელი.

ნაბიჯი 5: შელის მორგება

თქვენ თავისუფლად შეგიძლიათ გატეხოთ კოდი და შეცვალოთ იგი თქვენს საჭიროებებზე, თუ გნებავთ. რომ მცოდნოდა მე გამოვაქვეყნებ ამ კოდს, გავაკეთებდი ცალკე ბრძანების თარჯიმნის კლასს და ბრძანების სტრუქტურას და უბრალოდ ვიმეორებდი ამ გამოძახების ფუნქციის მაჩვენებლის საშუალებით. ეს შეამცირებს კოდის რაოდენობას, მაგრამ როგორც ის დგას, გარსი აანალიზებს ბრძანების ხაზს და იძახებს შესაბამის გარსის მეთოდს. საკუთარი მორგებული ბრძანებების დასამატებლად გააკეთეთ შემდეგი: 1. დაამატეთ თქვენი ბრძანება ანალიზის სიაში გაანალიზეთ ბრძანების ხაზი და მოგცემთ ბრძანებას და ნებისმიერ არგუმენტს ცალკე. არგუმენტები გადაეცემა როგორც მიმანიშნებელს, ისე მითითების მასივს, თუმცა მოგწონთ მათთან მუშაობა. ეს ნაპოვნია shell.cpp- ში. გახსენით shell.cpp და იპოვეთ AVRShell კლასის ExecCmd მეთოდი. შეიძლება დაგჭირდეთ ბრძანების დამატება პროგრამის მეხსიერებაში. თუ ასეა, დაამატეთ ბრძანება progmem.h და progmem.cpp. თქვენ შეგიძლიათ დაამატოთ ბრძანება პროგრამის მეხსიერებაში პირდაპირ PSTR () მაკროს გამოყენებით, მაგრამ თქვენ შექმნით სხვა გაფრთხილებას ადრე ნახსენები ტიპის შესახებ. ისევ და ისევ, ეს არის ცნობილი შეცდომა C ++ - თან მუშაობისას, მაგრამ ამის თავიდან აცილება შეგიძლიათ ბრძანების დამატებით უშუალოდ პროგრამაში.* ფაილებში, როგორც მე გავაკეთე. თუ არ გაწუხებთ SRAM გამოყენების დამატება, შეგიძლიათ დაამატოთ ბრძანება, როგორც მე ილუსტრირებული ვარ "საათის" ბრძანებით. თქვით, რომ გსურთ დაამატოთ ახალი ბრძანება სახელწოდებით "newcmd". გადადით AVRShell:: ExecCmd და იპოვეთ მოსახერხებელი ადგილი შემდეგი კოდის ჩასასმელად:

სხვაგან თუ (! strcmp (c, "newcmd")) cmdNewCmd (args);ეს დაამატებს თქვენს ბრძანებას და დაურეკავს cmdNewCmd მეთოდს, რომელსაც თქვენ დაწერთ შემდეგ ეტაპზე. 2. ჩაწერეთ თქვენი პერსონალური ბრძანების კოდი იმავე ფაილში, დაამატეთ თქვენი მორგებული ბრძანების კოდი. ეს არის მეთოდის განმარტება. თქვენ კვლავ მოგინდებათ დეკლარაციის დამატება shell.h. უბრალოდ დაამატეთ იგი სხვა ბრძანებებს. წინა მაგალითში, კოდი შეიძლება ასე გამოიყურებოდეს

voidAVRShell:: cmdNewCmd (char ** args) {sprintf_P (buff, PSTR ("შენი ბრძანება არის %s / r / n", args [0]); WriteRAM (buff);}აქ რამდენიმე რამაა. პირველი, "buff" არის 40-სიმბოლოიანი მასივის ბუფერი, რომელიც მოცემულია თქვენს კოდში. ჩვენ ვიყენებთ პროგრამის მეხსიერების ვერსიას sprintf რადგან ჩვენ მას PSTR გავლით. თუ გსურთ, შეგიძლიათ გამოიყენოთ ჩვეულებრივი ვერსია, მაგრამ დარწმუნდით, რომ ფორმატს არ გადასცემთ PSTR- ში. ასევე, არგუმენტები არის args მასივში. თუ აკრიფეთ "newcmd arg1 arg2", შეგიძლიათ მიიღოთ ეს არგუმენტები args [0] და args [1] ხელმოწერებით. თქვენ შეგიძლიათ გაიაროთ მაქსიმუმ MAX_ARGS არგუმენტი, როგორც ეს განსაზღვრულია კოდში. მოგერიდებათ შეცვალოთ ეს მნიშვნელობა, როდესაც ხელახლა ადგენთ, თუ გჭირდებათ კიდევ ბევრი არგუმენტის გადატანა ერთდროულად. ამ ფუნქციის მე -2 არგუმენტი ნაგულისხმევია. თუ არაფერს გადააცილებთ, ამის შემდეგ დაიწერება ბრძანების სტრიქონი. თუ მე –2 არგუმენტად მიიღებთ 0 – ს, მოთხოვნა არ დაიწერება. ეს გამოსადეგია, როდესაც გსურთ ჩაწეროთ რამდენიმე ცალკეული სტრიქონი გამოსაყვანად, სანამ ბრძანების სტრიქონი დაუბრუნდება მომხმარებელს. 3. შელი უნდა შეასრულოს ბრძანების კოდი თქვენ უკვე უთხარით გარს შემსრულებელს, განახორციელოს მეთოდი cmdNewCmd ახალი ბრძანების დაყენებისას, მაგრამ დაამატეთ იგი shell.h ფაილში, რათა ის გასაგები იყოს ჭურვის ობიექტისთვის. უბრალოდ დაამატეთ იგი ბოლო ბრძანების ქვემოთ ან პირველი ბრძანების წინ, ან სადმე იქ. და ეს არის ის. ხელახლა შეადგინეთ და ატვირთეთ firmware თქვენს Arduino– ში და თქვენი ახალი ბრძანება ხელმისაწვდომია ჭურვიდან მოთხოვნისთანავე.

ნაბიჯი 6: შეჯამება

თქვენ უნდა იცოდეთ როგორ დააინსტალიროთ და დაუკავშირდეთ თქვენს AVR/Arduino– ს და მიიღოთ ცოცხალი მოთხოვნა თქვენს გაშვებულ მიკროკონტროლერზე. თქვენ იცით რამდენიმე ბრძანება, რომელიც ამოიღებს დროის მონაცემებს MCU– დან ან დააყენებს მნიშვნელობებს MCU– ში. თქვენ ასევე გაჩვენეთ, თუ როგორ უნდა დაამატოთ თქვენი პერსონალური კოდი, რომ შექმნათ თქვენი უნიკალური ბრძანებები ჭურვიზე, რათა შემდგომში მოახდინოთ მისი მორგება თქვენს საჭიროებებზე. თქვენ შეგიძლიათ ბრძანების თარჯიმანიც კი შეიტანოთ, რომ ის შეიცავდეს მხოლოდ თქვენს პერსონალურ ბრძანებებს, თუ ეს თქვენს მოთხოვნილებებს შეესაბამება. ვიმედოვნებ, რომ თქვენ ისიამოვნეთ ამ ინსტრუქციებით და რომ AVR Shell შეიძლება იყოს თქვენთვის სასარგებლო, როგორც რეალურ დროში ბრძანების თარჯიმანი, ან როგორც სასწავლო პროცესი საკუთარი თავის განხორციელებაში. როგორც ყოველთვის, მე ველი ნებისმიერ კომენტარს ან წინადადებას, თუ როგორ შეიძლება გაუმჯობესდეს ეს სასწავლო! გაერთეთ თქვენი AVR- ით!