AVR: การเขียนโปรแกรมในสภาพแวดล้อม AVR Studio สภาพแวดล้อมการดีบักแบบรวม AVR Studio จากสตูดิโอ Atmel Avr
หากต้องการทำงานกับ AVR Studio 4 คุณต้องติดตั้งด้วยตัวเอง หากมีการติดตั้งไว้แล้ว คุณสามารถข้ามขั้นตอนนี้ได้
การติดตั้ง:
สร้างไดเร็กทอรี c:/avr/ - นี่คือตำแหน่งของโปรแกรมการทำงาน
สร้างไดเร็กทอรี เช่น c:/works/ ซึ่งเป็นที่จัดเก็บผลงานของคุณ
จำเป็นต้องมีทางลัดเพื่อไม่ให้เกิดปัญหา
โดยทั่วไปจะมี AVRStudio5 แต่ AVRStudio4 ยังค่อนข้างเพียงพอ
งานทั้งหมดจะเกิดขึ้นใน AVRStudio4 จำเป็นต้องใช้ WinAVR เท่านั้นเนื่องจากไลบรารี AVR-GCC (เพื่อให้คุณสามารถเขียนเป็นภาษา C)
แต่! คุณต้องติดตั้ง WinAVR ก่อน ไม่เช่นนั้นไลบรารี AVR-GCC จะไม่ถูกหยิบขึ้นมา
ฉันคิดว่าคุณจะเข้าใจมันที่นี่
AVR-GCC สำหรับการเขียนในภาษาซี
Atmel Avr Assembler ตามลำดับสำหรับแอสเซมเบลอร์
เป็นการดีกว่าที่จะเริ่มทำความเข้าใจ MK ตั้งแต่เริ่มต้น และนี่หมายถึงจาก Assembler ซึ่งหมายความว่าคุณสร้างอันที่เป็น Atmel AVR Assembler
จากนั้นเลือกไมโครคอนโทรลเลอร์ Atmega8
เมื่อสร้างโครงการแล้วจะมีกระดานชนวนสีขาวขนาดใหญ่ว่างเปล่า จะมีรหัสอยู่ที่นี่
เล็กน้อยเกี่ยวกับเนื้อหาของเอกสารนี้
“ความคิดเห็น” คือข้อความที่คอมไพเลอร์ข้ามเมื่อคอมไพล์
ก่อนเริ่มคอมเม้นท์จะต้องมีสัญลักษณ์พิเศษ ผมใช้สัญลักษณ์นั้น “อัฒภาค” นอกจากนี้ยังมี “เครื่องหมายทับคู่” (//)
นี่คือตัวอย่างความคิดเห็น
/* * ความคิดเห็นประเภทนี้ (หลายบรรทัด) * มักใช้สำหรับ * ข้อมูลประกอบ * เกี่ยวกับซอร์สโค้ด เช่น * ชื่อ ผู้พัฒนา ฯลฯ */ NOP // ความคิดเห็นนี้ใช้เพื่ออธิบายวัตถุประสงค์ของคำสั่งหรือโค้ด SLEEP เป็นหลัก ความคิดเห็นนี้เหมือนกับความคิดเห็นก่อนหน้า สามารถใช้เพื่ออธิบาย (สำหรับบันทึกย่อ) ในโค้ดได้
คำสั่งจะถูกเขียนในแต่ละบรรทัด เหล่านั้น. หนึ่งคำสั่ง - หนึ่งบรรทัด
สมมติว่ามีคำสั่งที่มี "พารามิเตอร์" สองรายการ โดยมีหนึ่งรายการหรือไม่มีเลย
โมฟ R16, R17 ; พารามิเตอร์สองตัว INC R16 ; พารามิเตอร์ SEI หนึ่งตัว โดยไม่มีพารามิเตอร์
โมฟ R16, R17 ; สามไบต์ INC R16; SEI สองไบต์; หนึ่งไบต์
คุณเห็นความเชื่อมโยงระหว่างขนาดทีมและพารามิเตอร์หรือไม่?
ไมโครคอนโทรลเลอร์แต่ละตัวมีแอสเซมเบลอร์ของตัวเอง แม้ว่าตัวช่วยจำจะคล้ายกันก็ตาม เช่น คำสั่ง MOV สำหรับ MK ของซีรีย์หนึ่งจะดูในรหัสเครื่อง เช่น 0x12 และอีก 0x55
เพื่อที่ในระหว่างการคอมไพล์มันจะถูกคอมไพล์ในโค้ดที่เราต้องการเราต้องบอกคอมไพเลอร์ว่าเรากำลังเขียนโปรแกรมไมโครคอนโทรลเลอร์ตัวไหน
โดยทั่วไปจะถูกเลือกเมื่อสร้างโปรเจ็กต์
ด้วยเหตุนี้ เราจึงเลือกไมโครคอนโทรลเลอร์ Atmega8
แต่นั่นไม่ใช่ทั้งหมด เพื่อให้ชีวิตของเราง่ายขึ้น AVRStudio4 มีชุดค่าคงที่ซึ่งเรียกว่า "Macroassembler"
หากต้องการโหลด คุณจะต้องแทรกบรรทัดที่จุดเริ่มต้นของโค้ด
รวม "m8def.inc" // โดยใช้คำสั่ง .include เราโหลดไฟล์ m8def.inc และตอนนี้มันจะง่ายขึ้นสำหรับเรา;)
ที่จุดเริ่มต้นของโค้ด ตารางขัดจังหวะจะถูกวางไว้ ฉันจะอธิบายว่ามันคืออะไรและทำงานอย่างไรในโพสต์อื่น แต่สำหรับตอนนี้ เรามาเขียนดังนี้:
รีเซ็ต RJMP ; รีเซ็ตตัวจัดการ RETI; RJMP EXT_INT0 ; IRQ0 ตัวจัดการ RETI; RJMP EXT_INT1 ; IRQ1 ตัวจัดการ RETI; RJMP TIM2_COMP ; Timer2 เปรียบเทียบตัวจัดการ RETI; RJMP TIM2_OVF ; ตัวจัดการโอเวอร์โฟลว์ Timer2 RETI; RJMP TIM1_CAPT ; ตัวจัดการการจับภาพ Timer1 RETI; RJMP TIM1_COMPA ; ตัวจับเวลา 1 เปรียบเทียบตัวจัดการ RETI; RJMP TIM1_COMPB ; ตัวจับเวลา 1 เปรียบเทียบตัวจัดการ B RETI; RJMP TIM1_OVF ; ตัวจัดการโอเวอร์โฟลว์ Timer1 RETI; RJMP TIM0_OVF ; ตัวจัดการโอเวอร์โฟลว์ Timer0 RETI; RJMP SPI_STC ; SPI Transfer ตัวจัดการที่สมบูรณ์ RETI; RJMP USART_RXC ; USART RX ตัวจัดการที่สมบูรณ์ RETI; RJMP USART_UDRE ; UDR ตัวจัดการว่างเปล่า RETI; RJMP USART_TXC ; USART TX ตัวจัดการที่สมบูรณ์ RETI; RJMP ADC ; ตัวจัดการการแปลง ADC เสร็จสมบูรณ์ RETI; RJMP EE_RDY ; EEPROM พร้อมตัวจัดการ RETI; RJMP ANA_COMP ; ตัวจัดการเปรียบเทียบแบบอะนาล็อก RETI; RJMP TSI ; ตัวจัดการอินเทอร์เฟซแบบอนุกรมสองสาย RETI; RJMP SPM_RDY ; จัดเก็บโปรแกรมจัดการหน่วยความจำพร้อม
หลังจากนี้โค้ดก็มาเอง
เริ่มต้นใหม่: ; โทเค็นการเริ่มต้น MAIN: NOP ; เครื่องหมายวนรอบหลัก RJMP MAIN
แต่มีคุณลักษณะหนึ่ง (หรือไม่ใช่อย่างใดอย่างหนึ่ง แต่มีหลายอย่าง)
เพื่อความสะดวกในการเขียนโค้ด เพื่อความชัดเจนและอำนวยความสะดวกในการเปลี่ยนผ่าน เราจึงได้รับเครื่องหมาย พวกมันมีลักษณะอย่างไร? “RESET:” และ “MAIN:” เป็นเครื่องหมาย โดยชื่อสามารถมีอักขระละตินและตัวเลขได้เกือบทุกตัว เครื่องหมายไม่สามารถมีชื่อของฟังก์ชันและคำสั่งได้ เช่น “NOP”
เราจะไปหาพวกเขาได้อย่างไร? สมมติว่าคำสั่ง RJMP
นอกจากนี้ จาก Markers เราสามารถสร้างรูทีนย่อย (ขั้นตอน) ได้ เมื่อเสร็จสิ้นแล้วเราจะกลับไปยังตำแหน่งที่ถูกเรียก หากต้องการเรียกให้ใช้คำสั่ง "RCALL (รูทีนย่อย)" และหากต้องการกลับจากรูทีนย่อย (ขั้นตอน) คุณจะต้องลงท้ายด้วยคำสั่ง "RET" เราควรจะได้โค้ดดังนี้:
รีสตาร์ท: หลัก: NOP RCALL PPP1 ; เรียกรูทีนย่อย RJMP MAIN PPP1: NOP RET ; ออกจากรูทีนย่อย
วิธีการทำงานของคำสั่ง "RCALL" เมื่อถูกเรียก ที่อยู่ที่ถูกเรียกจะถูกวางไว้บน STACK และเมื่อมีการเรียกใช้คำสั่ง "RET" ก็จะถูกลบออกจากการลงทะเบียน "stack" STACK จำเป็นต้องเริ่มต้น
เพื่อให้เราสามารถทำงานร่วมกับ MK ของเราได้ เราจำเป็นต้องเริ่มต้นมัน เพราะ mk อุปกรณ์นี้เป็นอุปกรณ์สากล โดยมีพอร์ตอินพุต/เอาท์พุตและอุปกรณ์ต่อพ่วงมากมาย เช่น USART, PWM, DAC, ADC เป็นต้น ขั้นตอนแรกในการเริ่มต้นไมโครคอนโทรลเลอร์คือการระบุจุดเริ่มต้นของ "สแต็ก" เราดำเนินการเริ่มต้นหลังจากเครื่องหมาย "RESET:"
LDI R16, สูง (RAMEND) ออก SPH, R16 LDI R16, ต่ำ (RAMEND) ออก SPL, R16
หากเราไม่ได้ป้อนคำสั่ง .include “m8def.inc” ที่ตอนต้นของโค้ด เราจะต้องเขียนดังนี้:
LDI R16,0x04 ออก SPH,R16 LDI R16,0x5f ออก SPL,R16
ความแตกต่างนั้นสำคัญมากในความคิดของฉัน
STACK เป็นหน่วยความจำประเภทร้านค้า: (เข้าสุดท้าย ออกก่อน)
ประเภทร้านค้าไม่ใช่ซูเปอร์มาร์เก็ต แต่เป็นแตรจากปืนกล ฉันหวังว่าทุกคนจะจินตนาการได้ว่าตลับหมึกถูกบรรจุเข้าไปอย่างไรและถูกถอดออกจากที่นั่นอย่างไร
คุณต้องให้ความสนใจกับหน่วยความจำ STACK เป็นอย่างมาก เพราะ... ข้อผิดพลาดเล็กๆ น้อยๆ ในการทำงานกับมันอาจนำไปสู่ความล้มเหลวของสแต็กได้ นี่เป็นหัวข้อสำคัญที่ฉันตัดสินใจอุทิศทั้งหัวข้อให้กับหัวข้อนี้และจะเขียนในบันทึกแยกต่างหาก
ดังนั้นเราจึงได้รหัสต่อไปนี้:
รวม "m8def.inc" RJMP RESET; รีเซ็ตตัวจัดการ RETI; RJMP EXT_INT0 ; IRQ0 ตัวจัดการ RETI; RJMP EXT_INT1 ; IRQ1 ตัวจัดการ RETI; RJMP TIM2_COMP ; Timer2 เปรียบเทียบตัวจัดการ RETI; RJMP TIM2_OVF ; ตัวจัดการโอเวอร์โฟลว์ Timer2 RETI; RJMP TIM1_CAPT ; ตัวจัดการการจับภาพ Timer1 RETI; RJMP TIM1_COMPA ; ตัวจับเวลา 1 เปรียบเทียบตัวจัดการ RETI; RJMP TIM1_COMPB ; ตัวจับเวลา 1 เปรียบเทียบตัวจัดการ B RETI; RJMP TIM1_OVF ; ตัวจัดการโอเวอร์โฟลว์ Timer1 RETI; RJMP TIM0_OVF ; ตัวจัดการโอเวอร์โฟลว์ Timer0 RETI; RJMP SPI_STC ; SPI Transfer ตัวจัดการที่สมบูรณ์ RETI; RJMP USART_RXC ; USART RX ตัวจัดการที่สมบูรณ์ RETI; RJMP USART_UDRE ; UDR ตัวจัดการว่างเปล่า RETI; RJMP USART_TXC ; USART TX ตัวจัดการที่สมบูรณ์ RETI; RJMP ADC ; ตัวจัดการการแปลง ADC เสร็จสมบูรณ์ RETI; RJMP EE_RDY ; EEPROM พร้อมตัวจัดการ RETI; RJMP ANA_COMP ; ตัวจัดการเปรียบเทียบแบบอะนาล็อก RETI; RJMP TSI ; ตัวจัดการอินเทอร์เฟซแบบอนุกรมสองสาย RETI; RJMP SPM_RDY ; เก็บหน่วยความจำโปรแกรมพร้อมตัวจัดการ รีเซ็ต: LDI R16, สูง (RAMEND) OUT SPH, R16 LDI R16, ต่ำ (RAMEND) OUT SPL, R16 RGMP รีเซ็ตหลัก: NOP ; เครื่องหมายวนรอบหลัก RJMP MAIN
ในขั้นตอนนี้ เราสามารถคอมไพล์โปรเจ็กต์และรันเพื่อการดีบักได้ แต่เนื่องจากโค้ดของเราไม่ได้ทำอะไรเลย จึงเป็นไปได้ที่จะระบุข้อผิดพลาดทางไวยากรณ์ในโค้ดเท่านั้น
สำหรับกระบวนการแก้ไขข้อบกพร่องที่ถูกต้องคุณจะต้องตั้งค่าความถี่ที่ MK จะทำงานให้กับโปรแกรมจำลองซึ่งจะทำได้หลังจากการคอมไพล์และเริ่มการดีบักเท่านั้น
ซึ่งหมายความว่าเราพบ "Build" ในแถบเมนู เปิดขึ้นมาแล้วดู "Build and Run" หลังจากนั้นเราจะเห็นลูกศรสีเหลืองตรงข้ามคำสั่งแรกในรายการโค้ดของเรา ตอนนี้เรามองหา "Debug" ในแถบเมนูแล้วคลิก "AVR Simulator Options" หน้าต่างต่อไปนี้จะเปิดขึ้น:
ซึ่งเราสามารถเปลี่ยน MK และความถี่ของมันได้บนแผงทางด้านขวาเราจะเห็นข้อมูลบางอย่างเกี่ยวกับ MK ของเรา: ความถี่สูงสุด, ความจุหน่วยความจำ (EEPROM, RAM, FLASH) ตอนนี้ให้เปิดเอกสารข้อมูลบน Atmega8 ในหน้า 203 (รายการรีจิสเตอร์ทั่วไป) และ 205 (รายการคำสั่งทั่วไป) แล้วเริ่มเขียนโปรแกรมของคุณ
และจำไว้ว่าอย่ากลัวที่จะทดลองกับเครื่องจำลอง มันจะไม่พัง!
สวัสดี
บทความนี้จะดึงดูดผู้ที่เชื่อว่าตนเอง "เติบโต" จาก Arduino และพร้อมที่จะก้าวเข้าสู่โลกแห่งการเขียนโปรแกรมไมโครคอนโทรลเลอร์ที่ "จริงจัง" นอกเหนือจากข้อเท็จจริงที่ว่า คุณจะ "เพิ่มพูนทักษะของโปรแกรมเมอร์" คุณจะมีโอกาสเลือกไมโครคอนโทรลเลอร์สำหรับโปรเจ็กต์ของคุณ และแน่นอน คุณจะประทับใจกับความเร็วของโปรแกรมและขนาดของหน่วยความจำที่โปรแกรมเหล่านั้นครอบครอง
ทุกสิ่งจะอธิบายไว้ (สำหรับ )ตั้งแต่ต้นจนจบ - การติดตั้งและการเตรียมซอฟต์แวร์ที่จำเป็นการประกอบโปรแกรมเมอร์ "Gromov" ที่ง่ายที่สุด (ไม่ต้องกลัว มีเพียงสามไดโอดและตัวต้านทานเจ็ดตัว), เฟิร์มแวร์ MK และการเขียนโค้ดใน AVR Studio กระบวนการทั้งหมดจะมาพร้อมกับภาพประกอบและตัวอย่าง
ผมขอจองทันที คอมพิวเตอร์ต้องมีพอร์ต COM (อะแดปเตอร์ USB เป็น COM ใช้งานได้ไม่ดี) หากคอมพิวเตอร์ของคุณไม่มีขั้วต่อดังกล่าวที่ด้านหลัง แสดงว่าอาจอยู่บนเมนบอร์ด (ในรูปของพิน) จากนั้นทุกอย่างสามารถแก้ไขได้ด้วยการ "ดีดออก" แบบนี้
อนิจจาสำหรับเจ้าของแล็ปท็อปที่ไม่มี COM บทความนี้มีประโยชน์ทางวิชาการเท่านั้น
เอาล่ะ มาเริ่มกันเลย…
คุณต้องการอะไร?
"อ่อนนุ่ม"
ยูนิโปรฟ- โปรแกรมสากลสำหรับการแฟลชไมโครคอนโทรลเลอร์ ATmega ต่างๆ ง่ายและสะดวกและที่สำคัญที่สุดคือทำงานได้อย่างสมบูรณ์แบบกับโปรแกรมเมอร์ของเรา ผู้เขียนคือ Mikhail Nikolaev ผู้พัฒนาชาวรัสเซีย
แน่นอนคุณสามารถแฟลช MK จาก AVR Studio ได้ แต่สำหรับสิ่งนี้คุณต้องมีโปรแกรมเมอร์พิเศษ ดังนั้นเราจะเขียนโค้ดในสตูดิโอและแฟลชไฟล์ hex ที่เป็นผลลัพธ์ด้วย UniProf โดยใช้โปรแกรมเมอร์ทำเองของเรา นอกจากนี้จะอธิบายวิธีการแฟลชเฟิร์มแวร์จากบรรทัดคำสั่ง
ผู้ใช้ Linux จะต้องใช้เครื่องเสมือนหรือไวน์ มันไม่ได้ผลสำหรับฉันเมื่อใช้ Wine ฉันไม่เห็นพอร์ตเลย และฉันไม่ได้ลองใช้กับเครื่องเสมือน
ทำงานได้อย่างไร้ที่ติในไวน์ (เดเบียน 8.5, ไวน์1.6).
ซอฟต์แวร์ทั้งหมดฟรี
"เหล็ก"
เราจะทำการทดลองเกี่ยวกับ อาร์ดูโน่ โปร มินิพร้อมชิป ATmega328 ความถี่ควอตซ์ (8/16เมกะเฮิรตซ์)ตลอดจนแรงดันไฟฟ้า (3.3/5โวลต์), ไม่เป็นไร. (ดูด้านล่าง)
ในอนาคตคุณจะเขียนโปรแกรมไมโครคอนโทรลเลอร์ Atmel ต่างๆ แต่เป็นครั้งแรกที่บอร์ดนี้เหมาะสม เป็นเรื่องที่ดีเพราะเป็นคอนโทรลเลอร์เปล่าที่มีการเดินสายไฟและหมุดบัดกรีน้อยที่สุด สิ่งที่คุณต้องการ
เกี่ยวกับการทำเครื่องหมายบนไมโครคอนโทรลเลอร์
หลังชื่อจะมีตัวเลขซึ่งส่วนใหญ่มักระบุจำนวนหน่วยความจำ
ตัวอักษรหลังตัวเลขระบุถึงพารามิเตอร์แรงดันไฟฟ้า
ไม่มีจดหมาย- แรงดันไฟฟ้าของตัวควบคุมอยู่ระหว่าง 4.5-5.5 โวลต์
ล- เวอร์ชันของคอนโทรลเลอร์ทำงานลดลง (ต่ำ)แรงดันไฟฟ้า (2.7 - 5.5 โวลต์)
วี- เวอร์ชันของตัวควบคุมที่ทำงานด้วยแรงดันไฟฟ้าต่ำ (1.8-5.5 โวลต์).
ยู- เวอร์ชันของตัวควบคุมที่ทำงานด้วยแรงดันไฟฟ้าที่ต่ำมาก (0.7-5.5 โวลต์).
ป- รุ่นพลังงานต่ำ (สูงสุด 100 nA ในโหมดปิดเครื่อง).
ก- ลดการใช้กระแสไฟ ครอบคลุมช่วงความถี่สัญญาณนาฬิกาทั้งหมดของทุกรุ่น แรงดันไฟจ่าย 1.8-5.5 โวลต์ (ในบางรุ่นมีการเพิ่มคุณสมบัติใหม่และรีจิสเตอร์ใหม่ในขณะที่ยังคงความเข้ากันได้อย่างสมบูรณ์กับเวอร์ชั่นก่อนหน้า).
ไมโครคอนโทรลเลอร์ « ก" และไม่- ก" มักจะมีลายเซ็นเดียวกัน ซึ่งทำให้เกิดปัญหาบางประการ เนื่องจากบิตฟิวส์นั้นแตกต่างกัน
ตัวอย่าง:
เอทีเมก้า8- ความจุหน่วยความจำโปรแกรม 8 กิโลไบต์ แรงดันไฟจ่าย 4.5-5.5 โวลต์
ATmega8L- ความจุหน่วยความจำโปรแกรม 8 กิโลไบต์ แรงดันไฟจ่าย 2.7-5.5 โวลต์
เอทีนี่43ยู- ความจุหน่วยความจำ 4 กิโลไบต์, การดัดแปลง - 3, แรงดันไฟฟ้า - 0.7-5.5 โวลต์
เอทีนี่44เอ- ความจุหน่วยความจำ 4 กิโลไบต์, การดัดแปลง - 4, ลดการใช้กระแสไฟ, แรงดันไฟจ่าย 1.8-5.5 โวลต์
มันเกิดขึ้นที่ตัวควบคุมที่ไม่มีตัวอักษรอาจมีแรงดันไฟฟ้าลดลง (1.7 หรือ 1.8 โวลต์) สิ่งนี้จะต้องมีการชี้แจงในแผ่นข้อมูล
เอทีนี่841- ความจุหน่วยความจำ 8 กิโลไบต์, การดัดแปลง - 41, แรงดันไฟฟ้า - 1.7-5.5 โวลต์
หลังจากเครื่องหมายยัติภังค์ จะมีการระบุเวอร์ชันของไมโครคอนโทรลเลอร์ ซึ่งประกอบด้วยตัวเลขที่ระบุความถี่สูงสุดของคอนโทรลเลอร์ (ที่แรงดันไฟฟ้าที่เหมาะสม)และจากตัวอักษรที่ระบุตัวเลือกตัวเรือน ช่วงอุณหภูมิการทำงาน และคุณลักษณะการผลิต
ตัวอักษรหนึ่งหรือสองตัวที่ตามความถี่ระบุประเภทตัวเรือน:
ยูนิโปรฟ
การเขียนโปรแกรมมีชัยไปกว่าครึ่ง คุณยังคงต้องอัดมันเข้าไปในคอนโทรลเลอร์ด้วย เรามาใส่ใจเรื่องนี้ให้มากขึ้นคงจะดีไม่น้อยถ้า Arduino ของคุณโหลดด้วย Blink มาตรฐาน (มาพร้อมกับมันจากโรงงาน)
มาเปิดตัว UniProf... บางทีหน้าต่างต่อไปนี้จะปรากฏขึ้น:
สิ่งนี้เชื่อมต่อกับพอร์ต LPT ดังนั้นเพียงคลิก ตกลง.
หน้าต่างโปรแกรมจะเปิดขึ้น:
หากเลือกพอร์ตไม่ถูกต้อง หน้าต่างจะปรากฏขึ้นเพื่อถาม...
คลิกตกลงและเลือกพอร์ตที่ต้องการ
หากตรวจไม่พบ MK โดยอัตโนมัติ หน้าต่างพร้อมการเลือกด้วยตนเองจะปรากฏขึ้น:
น่าเสียดายที่ไม่อยู่ในรายการ atmega328ดังนั้นเราจึงเลือก เมกะ32 (มีจำนวนหน่วยความจำแฟลชเท่ากัน) และกด ตกลง.
หลังจากนี้ แทนที่จะเป็นคำว่า ไม่รู้จัก คอนโทรลเลอร์ที่เชื่อมต่ออยู่จะปรากฏขึ้น...
32กคือจำนวนหน่วยความจำแฟลช และ 1024 - ระดับเสียง EEPROM
ตอนนี้หากทุกอย่างเป็นไปตามภาพ ให้เปิดส่วนช่วยเหลือ และอ่านสิ่งที่เขียนไว้ที่นั่นอย่างละเอียด ผู้เขียนกระชับมากจึงไม่ใช้เวลามากนัก อย่าเพิ่งกดปุ่มใดๆ
เจอกันแล้วใช่ไหม? เยี่ยมมาก ตอนนี้เราเดินหน้าต่อไปได้แล้ว ยกเลิกการทำเครื่องหมายที่ช่องถัดจาก EEPROM แล้วคุณจะเห็นอินเทอร์เฟซที่เปลี่ยนแปลง:
หลังจากยกเลิกการเลือกช่องทำเครื่องหมาย EEPROM การอ่านและการเขียนพื้นที่หน่วยความจำนี้จะไม่ทำงาน
เนื่องจากเราจะดำเนินการกับไฟล์ hex เราจะลบ "เครื่องหมายถูก" ออก ทั่วไปและ ถังขยะและทำเครื่องหมายในช่องด้วย เบรค!สิ่งนี้จะเพิ่มเวลาในการอ่าน/เขียน แต่จะเพิ่มความเสถียร
กระบวนการไม่รวดเร็วดังนั้นคุณจะต้องรอ สี่เหลี่ยมสีน้ำเงินจะคลานด้านล่างและตัวเลขจะถูกนับที่มุมขวาล่าง รอบแรกจะอ่านพื้นที่ PROGRAM และรอบที่สองจะอ่าน EEPROM
ฉันมี Arduino ใหม่พร้อม Blink มาตรฐานในตัว (เมื่อต่อโปรแกรมเมอร์แล้วไดโอดจะหยุดกระพริบ). หากคุณมีสิ่งเดียวกัน รูปภาพต่อไปนี้จะปรากฏขึ้น:
ด้านขวาเราจะเห็นว่าไม่มีใน EEPROM และด้านซ้ายใน PROGRAM มีโปรแกรมที่บันทึกไว้ (อย่างที่บอกนี่คือบลิ๊งค์). ตอนนี้ใช้ลูกศรลงเพื่อเลื่อนแถบเลื่อนจนกว่าข้อมูลจะหมด...
...ตอนนี้เลื่อนไปจนสุด คุณจะเห็นข้อมูลเพิ่มเติม - นี่คือ Arduino bootloader
ตอนนี้ฉันขอเสนอให้หยุดพักจากบทความของฉันและอ่านเกี่ยวกับโครงสร้างของ MK ซึ่งจะช่วยเพิ่มความเข้าใจในเนื้อหาของคุณได้อย่างมาก ทุกอย่างเขียนได้ดีและชัดเจนมาก อ่านจบแล้วกลับมาลุยต่อครับ...
ยกเลิกการเลือก อีพรอม. เราไม่ต้องการมันจริงๆ แต่จะชัดเจนว่ามี "ติ๊ก" เบรค!
ตอนนี้เรามาบันทึกทุกอย่างที่เป็นเฟิร์มแวร์ไว้ในคอนโทรลเลอร์เพื่อว่าหลังจากการทดลองเราสามารถคืนสถานะดั้งเดิมได้
กดปุ่ม และบันทึกเฟิร์มแวร์ เรียกมันว่า - origProMini328.hex. เพียงเท่านี้คุณก็สำรองข้อมูลแล้ว
... จากนั้นคลิกปุ่มอ่านที่คุ้นเคยอยู่แล้ว หลังจากนั้นจะเห็นว่าทุกเซลล์ใน PROGRAM ว่างเปล่า ไม่เพียงแต่โปรแกรมจะถูกลบออกเท่านั้น แต่ยังรวมถึง Arduino bootloader ด้วย
นั่นคือตอนนี้คุณจะไม่สามารถอัปโหลดภาพร่างโดยใช้วิธีการแบบเดิมได้ จากนั้นหากคุณต้องการ เพียงโบกมือเล็กน้อย ให้กู้คืนทุกอย่างจากข้อมูลสำรอง
ตอนนี้เราจะแฟลชคอนโทรลเลอร์ด้วย "กะพริบ" แบบเดียวกับที่เขียนใน AVR Studio เท่านั้น
นี่คือลักษณะของโค้ด:
#กำหนด F_CPU 16000000UL #รวม
หากคุณใช้ Arduino กับควอตซ์ 8 MHz ก็ไม่มีอะไรผิดปกติ ไดโอดจะกะพริบบ่อยเพียงครึ่งเดียว
ใช้พื้นที่เท่าใด:
AVRDude
Uniprof ก็เหมือนกับโปรแกรมอื่นๆ ที่คล้ายกัน เป็นเพียงส่วนเสริมแบบกราฟิกเหนือโปรแกรม AVRDude (AVR ดาวน์โหลด-อัพโหลด)ซึ่งจากนั้นจะดำเนินการตามที่อธิบายไว้ข้างต้นทั้งหมดบนไมโครคอนโทรลเลอร์
เพราะว่า AVRDudeไม่มีอินเทอร์เฟซแบบกราฟิกของตัวเอง คุณต้องใช้งานจากบรรทัดคำสั่ง สิ่งนี้อาจดูไม่สะดวกสำหรับบางคน แต่มันตรงกันข้าม การทำงานจากคอนโซลนั้นยอดเยี่ยมมาก สะดวก เรียบง่าย และไม่ผูกติดกับระบบปฏิบัติการใดๆ เนื่องจาก avrdude อาจมีอยู่ในทุกสิ่ง ตอนนี้คุณจะเห็นสิ่งนี้
สำหรับผู้ใช้
อาวร์ดู๊ดรวมอยู่ใน toolchain ของ AVR ดังนั้นให้ทำการติดตั้ง (หลังจากติดตั้ง AVR Studio)ตามที่เขียนไว้ตอนต้นบทความ
ซีดี\
...ไปที่รูทของดิสก์ กับ.
โดยป้อนคำสั่ง:
ถ้าเป็นเช่นนั้นแล้ว แย่จังพร้อมที่จะไปและดำเนินการต่อ
ตอนนี้เราต้องเพิ่มโปรแกรมเมอร์ของเราลงในไฟล์กำหนดค่า แย่จัง (C:\Program Files (x86)\Atmel\AVR Tools\AVR Toolchain\bin\ avrdude.conf) . เปิดมันในโปรแกรม กระดาษจดบันทึก++และหลังคำจารึก “PROGRAMMER DEFINITIONS” ให้เพิ่มบรรทัดเหล่านี้:
รหัสโปรแกรมเมอร์ = "gromov"; desc = "การกระแทกพอร์ตอนุกรม, รีเซ็ต = dtr sck = rts mosi = txd miso = cts"; ประเภท = เซอร์เบีย; รีเซ็ต = 4; สซีค = 7; โมซี่ = 3; มิโซะ = 8; ;
กระแทกเล็กน้อย
บันทึกและปิดไฟล์ ไม่จำเป็นอีกต่อไป
กลับไปที่เทอร์มินัลและให้คำสั่งตรวจสอบการสื่อสารระหว่าง MK และโปรแกรมเมอร์:
Avrdude -n -c gromov -P com1 -p m328p
คุณอาจมีพอร์ต com อื่น
ติดตั้ง แย่จัง
Sudo apt ติดตั้ง avrdude
โดยป้อนคำสั่ง:
คุณควรเห็นข้อมูลความช่วยเหลือ
ถ้าเป็นเช่นนั้นแล้ว แย่จังพร้อมสำหรับการทำงาน
กำหนดค่าพอร์ต:
Sudo stty 9600 ignbrk -brkint -icrnl -imaxbel -opost -isig -icanon -iexten -echo noflshซึ่งจะต้องทำหลังจากรีบูตคอมพิวเตอร์แต่ละครั้ง หรือเพิ่มลงใน rc.local
โดยที่ /dev/ttyS0 อยู่ คอม1, /dev/ttyS1 - คอม2ฯลฯ
ในอนาคตฉันจะเขียนในทีม /dev/ttyS0, คุณอาจจะมี /dev/ttyS1ฯลฯ
เพิ่มโปรแกรมเมอร์ลงในไฟล์กำหนดค่า /etc/avrdude.conf
Sudo นาโน /etc/avrdude.conf
หลังจาก “PROGRAMMER DEFINITIONS” ให้เพิ่มบรรทัดต่อไปนี้:
รหัสโปรแกรมเมอร์ = "gromov"; desc = "การกระแทกพอร์ตอนุกรม, รีเซ็ต = dtr sck = rts mosi = txd miso = cts"; type = "เซอร์บบ์"; รีเซ็ต = 4; สซีค = 7; โมซี่ = 3; มิโซะ = 8; ;
โปรแกรมเมอร์ใช้เทคโนโลยี Bit-banging
ตรวจสอบให้แน่ใจว่าเมื่อคัดลอก เครื่องหมายคำพูดยังคงเป็นเพียงเครื่องหมายคำพูด มิฉะนั้นอาจมีการเปลี่ยนแปลง (เนื่องจากความแตกต่างในการเข้ารหัส) และ avrdude จะสาบาน
บันทึกและปิดไฟล์
ให้คำสั่งตรวจสอบการเชื่อมต่อระหว่าง MK และโปรแกรมเมอร์:
คำสั่ง Sudo avrdude -n -c gromov -P /dev/ttyS0 -p m328p
หากมีการเชื่อมต่อคำตอบจะเป็นดังนี้:
นี่คือจุดที่ความแตกต่างระหว่างระบบปฏิบัติการสิ้นสุดและคำสั่งซ้ำกัน
เพิ่มอาร์กิวเมนต์ให้กับคำสั่ง -vหรือ -วี -วี (สามารถเพิ่มลงในคำสั่งใดก็ได้)เพื่อแสดงข้อมูลที่ครบถ้วน:
Avrdude -n -v -c gromov -P com1 -p m328p ###ชนะ###
sudo avrdude -n -v -c gromov -P /dev/ttyS0 -p m328p ###Linux###
ข้อสรุปของ Avrdude คือทั้งใน Windows และ Linux เหมือนกัน ดังนั้นจากนี้ไปฉันจะจับภาพหน้าจอใน Win เท่านั้น
มีข้อมูลเพิ่มเติมที่นี่ เช่น คุณสามารถดูว่ามีการติดตั้งฟิวส์ใดบ้าง ที่นี่พวกเขาจะส่งออกเป็นเลขฐานสิบหก (ฐานสิบหก)ตัวเลข ตัวอย่างเช่น hfuse 0xDA ในไบนารี่จะมีลักษณะเช่นนี้ - นั่นคือบิตเหล่านี้เป็นบิตเดียวกับที่ถูกทำเครื่องหมายในส่วนต่อประสานกราฟิก
เมื่อคุณจัดการกับฟิวส์ โปรดจำไว้ว่าในไมโครคอนโทรลเลอร์ ATmega ฟิวส์จะกลับด้าน นั่นคือ 0 - นี้ บนยูเชโนะ และ 1 - ปิดยูเชโน. สิ่งนี้ทำให้เกิดความสับสนในเครื่องคิดเลขออนไลน์ (ดูด้านล่าง)
มาอ่านเฟิร์มแวร์จากพื้นที่กัน แฟลช (เหมือนกับ PROGRAM ใน uniprof)สั่งการ:
Avrdude -c gromov -P com1 -p m328p -U แฟลช:r:readfl.txt:h ###WIN###
sudo avrdude -c gromov -P /dev/ttyS0 -p m328p -U แฟลช:r:readfl.txt:h ###Linux###
ใน Uniprof รหัสจะแสดงในโปรแกรม แต่ที่นี่จะถูกเขียนลงในไฟล์
เฟิร์มแวร์อ่านและเขียนลงไฟล์ readfl.txt. จดหมาย ชม. (ฐานสิบหก)ในตอนท้ายแสดงว่าข้อมูลควรเขียนในรูปแบบเลขฐานสิบหก ถ้าคุณเขียนจดหมาย ข (ไบนารี่)จะถูกเขียนในระบบไบนารี่ และถ้า ร (ดิบ)จากนั้นข้อมูลจะอยู่ในรูปแบบ "ดิบ" (ไครยาโคซีบร้า).
จากนี้ไปจะถือว่าผู้ใช้ที่ชนะอยู่ในรูทของดิสก์ กับ (ค:\)และผู้ใช้ Linux ทำงานจากโฟลเดอร์หลัก ดังนั้นไฟล์ต่างๆ จะถูกบันทึกไว้ที่นั่น (เว้นแต่จะระบุไว้เป็นอย่างอื่น). เฟิร์มแวร์ที่จะอัปโหลดไปยัง MK ควรอยู่ที่นั่น
หากต้องการ win ไฟล์จะอยู่ที่นี่ C:\readfl.txt และสำหรับ linux ใน /home/user/readfl.txt คุณสามารถเปิดไฟล์นี้และดูได้
อ่าน EEPROM:
Avrdude -c gromov -P com1 -p m328p -U eeprom:r:reader.txt:h ###WIN###
sudo avrdude -c gromov -P /dev/ttyS0 -p m328p -U eeprom:r:reader.txt:h ###Linux###
อ่านแฟลชและ eeprom ด้วยกัน:
Avrdude -c gromov -P com1 -p m328p -U แฟลช:r:readfl.txt:h -U eeprom:r:reader.txt:h ###WIN###
sudo avrdude -c gromov -P /dev/ttyS0 -p m328p -U แฟลช:r:readfl.txt:h -U eeprom:r:reader.txt:h ###Linux###
การลบตัวควบคุม:
Avrdude -e -c gromov -P com1 -p m328p ###ชนะ###
sudo avrdude -e -c gromov -P /dev/ttyS0 -p m328p ###Linux###
ปลดพิน "รีเซ็ต" - ไดโอดจะไม่กะพริบโปรแกรมจะถูกลบ
มาแฟลช MK ด้วยไฟล์ที่ดาวน์โหลดมาก่อนหน้านี้ 328test.hex. อยู่ที่รากของดิสก์ ค(c:\328test.hex) ใน windows หรือในโฮมโฟลเดอร์ (/home/user/328test.hex) ใน linux
Avrdude -c gromov -P com1 -p m328p -U แฟลช:w:328test.hex ###WIN###
sudo avrdude -c gromov -P /dev/ttyS0 -p m328p -U แฟลช:w:328test.hex ###Linux###
ตอนนี้ถ้าคุณปิด "รีเซ็ต" คอนโทรลเลอร์จะกลับมามีชีวิตอีกครั้ง
บันทึก. เมื่อกระพริบ MK ผ่าน แย่จังไม่จำเป็นต้องลบคอนโทรลเลอร์ โปรแกรมจะทำเอง อย่างไรก็ตามหากคุณระบุพารามิเตอร์ -Dจากนั้น MK จะไม่ถูกทำความสะอาดโดยอัตโนมัติ
เฟิร์มแวร์ EEPROM:
Avrdude -c gromov -P com1 -p m328p -U eeprom:w:eeprom.hex ###WIN###
sudo avrdude -c gromov -P /dev/ttyS0 -p m328p -U eeprom:w:eeprom.hex ###Linux###
อ่านฟิวส์ทั้งหมด:
Avrdude -c gromov -P com1 -p m328p -U hfuse:r:hfuse.txt:h -U lfuse:r:lfuse.txt:h -U ล็อค:r:lock.txt:h -U efuse:r:efuse .txt:h ###ชนะ###
sudo avrdude -c gromov -P /dev/ttyS0 -p m328p -U hfuse:r:hfuse.txt:h -U lfuse:r:lfuse.txt:h -U ล็อค:r:lock.txt:h -U efuse :r:efuse.txt:h ###Linux###
คอนโทรลเลอร์บางตัวอาจไม่มีฟิวส์
อ่านอย่างเดียว ฟิวส์ต่ำ:
Avrdude -c gromov -P com1 -p m328p -U lfuse:r:lfuse.txt:h ###ชนะ###
sudo avrdude -c gromov -P com1 -p m328p -U lfuse:r:lfuse.txt:h ###Linux###
ฟิวส์ต่ำมีหน้าที่รับผิดชอบในการเลือกแหล่งสัญญาณนาฬิกา (ภายใน, ภายนอก) ความถี่และการหยุดชั่วคราวก่อนที่คอนโทรลเลอร์จะเริ่มทำงานหลังจากจ่ายไฟเข้าไป ตอนนี้คุณมีค่าเขียนอยู่ตรงนั้น - 0xffซึ่งสอดคล้องกับควอตซ์ภายนอกตั้งแต่ 8 MHz ขึ้นไป
ตอนนี้เราจะแฟลชฟิวส์อีกตัวซึ่งจะถ่ายโอน ATmeg ของคุณไปทำงานจากเครื่องกำเนิด 8 MHz ภายใน
Avrdude -c gromov -P com1 -p m328p -U lfuse:w:0xe2:m ###ชนะ###
sudo avrdude -c gromov -P /dev/ttyS0 -p m328p -U lfuse:w:0xe2:m ###Linux###
หากคุณมี Arduino 16 MHz ไดโอดจะกะพริบช้ากว่าสองเท่า
ในอนาคต เมื่อเข้ารหัสใน AVR Studio คุณสามารถระบุความถี่ 8 MHz และคลายควอตซ์ได้ ซึ่งจะทำให้คุณได้รับพินดิจิทัลฟรีอีกสองตัวตามที่คุณต้องการ
แต่หลังจากนั้น และตอนนี้เราจะคืนทุกอย่างเหมือนเดิมด้วยการกระพริบฟิวส์ก่อนหน้า:
Avrdude -c gromov -P com1 -p m328p -U lfuse:w:0xff:m ###ชนะ###
sudo avrdude -c gromov -P /dev/ttyS0 -p m328p -U lfuse:w:0xff:m ###Linux###
ไดโอดจะกะพริบอย่างถูกต้อง
ฟิวส์สามารถกะพริบแยกกันหรือรวมกันได้:
Avrdude -c gromov -P com1 -p m328p -U hfuse:w:0xda:m -U lfuse:w:0xff:m -U efuse:w:0x05:m ###WIN###
sudo avrdude -c gromov -P /dev/ttyS0 -p m328p -U hfuse:w:0xda:m -U lfuse:w:0xff:m -U efuse:w:0x05:m ###Linux###
ไม่จำเป็นต้องได้รับคำสั่งเหล่านี้ ฉันนำเสนอเพื่อความชัดเจน
ในอนาคต เมื่อคุณจำเป็นต้องใช้ตัวควบคุมอื่น คุณจะต้องทำเครื่องหมายที่ช่องในเครื่องคิดเลขออนไลน์และรับค่าต่างๆ (ลิงค์อยู่ที่มุมซ้ายบน)ในรูปแบบเลขฐานสิบหกแล้วแฟลช
ตอนนี้สิ่งที่เหลืออยู่คือการหาพารามิเตอร์ แย่จังและคุณสามารถไปยังส่วนสุดท้ายได้
-ค กรอมอฟ- ประเภทของโปรแกรมเมอร์หรือชื่อที่เขียนไว้ในการกำหนดค่า (avrdude.conf).
-พีคอม1- ทุกอย่างชัดเจนที่นี่
-pm328p- ประเภทการกำหนด MK
-ยู- หลังจากตัวเลือกนี้ พื้นที่หน่วยความจำจะถูกระบุ (แฟลช, อีพรอม, xfuse)ซึ่งจะดำเนินการใดๆ (r - อ่าน w - เขียน).
เครื่องหมายทวิภาคทำหน้าที่เป็นตัวคั่น
ต่อไปนี้เป็นชื่อของไมโครคอนโทรลเลอร์และนามแฝง โปรแกรมเมอร์ และตัวเลือกอื่นๆ
ชื่อเล่น เอ็มเค
uc3a0512- AT32UC3A0512
c128- AT90CAN128
c32- AT90CAN32
c64- AT90CAN64
pwm2- AT90PWM2
pwm2b- AT90PWM2B
pwm3- AT90PWM3
pwm316- AT90PWM316
pwm3b- AT90PWM3B
1200
- AT90S1200 (****)
2313
- AT90S2313
2333
- AT90S2333
2343
- AT90S2343 (*)
4414
- AT90S4414
4433
- AT90S4433
4434
- AT90S4434
8515
- AT90S8515
8535
- AT90S8535
ยูเอสบี1286- AT90USB1286
ยูเอสบี1287- AT90USB1287
ยูเอสบี162- AT90USB162
ยูเอสบี646- AT90USB646
usb647- AT90USB647
usb82- AT90USB82
ม103- เอทีเมก้า103
ม128- เอทีเมก้า128
ม1280- เอทีเมก้า1280
m1281- เอทีเมก้า1281
m1284p- ATmega1284P
m1284rfr2- ATmega1284RFR2
m128rfa1- ATmega128RFA1
m128rfr2- ATmega128RFR2
ม16- เอทีเมก้า16
ม161- เอทีเมก้า161
ม162- เอทีเมก้า162
ม163- เอทีเมก้า163
m164p- ATmega164P
ม168- เอทีเมก้า168
m168p- ATmega168P
ม169- เอทีเมก้า169
m16u2- ATmega16U2
ม.2560- ATmega2560 (**)
ม.2561- ATmega2561 (**)
m2564rfr2- ATmega2564RFR2
m256rfr2- ATmega256RFR2
ม32- เอทีเมก้า32
m324p- ATmega324P
m324pa- ATmega324PA
m325- ATmega325
m3250- ATmega3250
ม328- ATmega328
m328p- ATmega328P
ม329- ATmega329
m3290- ATmega3290
m3290p- ATmega3290P
m329p- ATmega329P
m32u2- ATmega32U2
m32u4- ATmega32U4
ม406- ATMEGA406
ม48- เอทีเมก้า48
m48p- เอทีเมก้า48พี
ม64- ATmega64
ม640- ATmega640
ม644- ATmega644
m644p- ATmega644P
m644rfr2- ATmega644RFR2
ม645- ATmega645
m6450- ATmega6450
ม649- ATmega649
m6490- ATmega6490
m64rfr2- ATmega64RFR2
ม8- ATmega8
m8515- ATmega8515
m8535- ATmega8535
ม88- เอทีเมก้า88
m88p- ATmega88P
m8u2- ATmega8U2
t10-ATtiny10
t11- เอทีนี่11
ที12- เอทีนี่12
T13- เอทีนี่13
T15-เอททินี่15
t1634- เอทีนี่1634
T20- เอทีนี่20
t2313- ATtiny2313
ที24- เอทีนี่24
T25- เอทีนี่25
T26- เอทีนี่26
t261- เอทีนี่261
ที4- เอทีนี่4
t40- เอทีนี่40
t4313-ATtiny4313
t43u- เอทีนี่43ยู
ที44- เอทีนี่44
ที45- เอทีนี่45
t461- เอทีนี่461
ที5- เอทีนี่5
t84- เอทีนี่84
t85- เอทีนี่85
t861- ATtiny861
ที88- เอทีนี่88
ที9- เอทตินี่9
x128a1- ATxmega128A1
x128a1d- ATxmega128A1revD
x128a1u- ATxmega128A1U
x128a3- ATxmega128A3
x128a3u- ATxmega128A3U
x128a4- ATxmega128A4
x128a4u- ATxmega128A4U
x128b1- ATxmega128B1
x128b3- ATxmega128B3
x128c3- ATxmega128C3
x128d3- ATxmega128D3
x128d4- ATxmega128D4
x16a4- ATxmega16A4
x16a4u- ATxmega16A4U
x16c4- ATxmega16C4
x16d4- ATxmega16D4
x16e5- ATxmega16E5
x192a1- ATxmega192A1
x192a3- ATxmega192A3
x192a3u- ATxmega192A3U
x192c3- ATxmega192C3
x192d3- ATxmega192D3
x256a1- ATxmega256A1
x256a3- ATxmega256A3
x256a3b- ATxmega256A3B
x256a3bu- ATxmega256A3BU
x256a3u- ATxmega256A3U
x256c3- ATxmega256C3
x256d3- ATxmega256D3
x32a4- ATxmega32A4
x32a4u- ATxmega32A4U
x32c4- ATxmega32C4
x32d4- ATxmega32D4
x32e5- ATxmega32E5
x384c3- ATxmega384C3
x384d3- ATxmega384D3
x64a1- ATxmega64A1
x64a1u- ATxmega64A1U
x64a3- ATxmega64A3
x64a3u- ATxmega64A3U
x64a4- ATxmega64A4
x64a4u- ATxmega64A4U
x64b1- ATxmega64B1
x64b3- ATxmega64B3
x64c3- ATxmega64C3
x64d3- ATxmega64D3
x64d4- ATxmega64D4
x8e5- ATxmega8E5
ผู้ใช้ Linux สามารถใช้ไวน์ได้
ฉันหวังว่าคุณจะติดตั้งทุกอย่างเรียบร้อยแล้ว มาเปิดตัว AVR Studio กันดีกว่า...
ที่นี่เราถูกขอให้สร้างโปรเจ็กต์ใหม่หรือเปิดโปรเจ็กต์เก่า คลิก โครงการใหม่…
เลือก เอวีอาร์ จีซีซีเนื่องจากเราจะเขียนใน SI ไม่ใช่ในแอสเซมเบลอร์
เราตั้งชื่อโครงการและทำเครื่องหมายในช่อง
เลือก ที่ตั้ง (ฉันสร้างโฟลเดอร์ AVR บนไดรฟ์ C:\)โฟลเดอร์ที่มีโปรเจ็กต์จะถูกสร้างขึ้นโดยอัตโนมัติ
คลิก ต่อไป…
เลือก เครื่องจำลองเอวีอาร์เนื่องจากเราไม่มีโปรแกรมเมอร์พิเศษที่อนุญาตให้ทำการดีบั๊กได้และไมโครคอนโทรลเลอร์ของเราก็คือ ATmega328p.
คลิก เสร็จ.
หลังจากการยักย้ายเหล่านี้สตูดิโอก็พร้อมสำหรับการทำงาน
ด้านซ้ายเป็นทางเข้าสู่โครงการ ตรงกลางคือโปรแกรมแก้ไขข้อความที่เขียนโค้ด ทางด้านขวาคือการลงทะเบียนคอนโทรลเลอร์ ที่ด้านล่างซ้ายคือข้อมูลการดีบัก
จากปุ่มที่เราสนใจในปัจจุบัน -
สร้างโครงการ
สร้างโปรเจ็กต์และเริ่มการดีบัก
กำลังรวบรวมไฟล์.
การทำความสะอาด
การตั้งค่าโครงการ ดังนั้นคลิกที่มัน...
ที่นี่คุณสามารถเปลี่ยนประเภทของ MK ตั้งค่าความถี่สัญญาณนาฬิกาได้ (เราจะเขียนมันโดยตรงในโค้ด)ระดับการปรับให้เหมาะสมตลอดจนกำหนดไฟล์ที่จะถูกสร้างขึ้น
คลิกที่ไอคอนด้านซ้ายเพื่อสนใจและคลิก ยกเลิก.
ฉันจะไม่อธิบายสิ่งเหล่านี้และตัวเลือกอื่นๆ แต่ฉันจะให้ลิงก์พร้อมคำอธิบายที่มีความสามารถในภายหลัง
ตอนนี้ให้คัดลอกโค้ดที่เขียนไว้ตอนต้นของบทความและวางลงในโปรแกรมแก้ไข:
เราระบุความถี่สัญญาณนาฬิกาในโค้ดเนื่องจากไลบรารีต้องการ ความล่าช้า.h.
การสร้างสำเร็จแล้ว ไม่มีข้อผิดพลาดหรือคำเตือน
ตอนนี้เราไปตามทางของเรากันเถอะ C:\AVR\my328\default\เราจะพบไฟล์ hex ที่เราสร้างขึ้นที่นั่น - my328.hexและแฟลชเข้าไปในคอนโทรลเลอร์ สิ่งที่จะแฟลช (avrdude หรือ uniprof)เลือกเพื่อตัวคุณเอง
ใน avrdude มันจะมีลักษณะเช่นนี้:
Avrdude -c gromov -P com1 -p m328p -U แฟลช:w:\AVR\my328\default\my328.hex ###WIN###
avrdude -c gromov -P /dev/ttyS0 -p m328p -U แฟลช:w:my328.hex ###Linux###
ปิดการใช้งาน "รีเซ็ต" และเห็นไดโอดกะพริบหนึ่งครั้งต่อวินาที ฉันหวังว่าฉันจะทำให้คุณมั่นใจในความเรียบง่ายและความสะดวกสบายของบรรทัดคำสั่ง
หากต้องการเปลี่ยน Arduino กลับเป็น Arduino คุณต้องมีข้อมูลสำรอง
ตามที่เขียนไว้ข้างต้น ฉันจะไม่อธิบายการทำงานกับ AVR Studio และจะไม่ให้บทเรียนเกี่ยวกับภาษา SI ก่อนอื่นนี่ไม่ใช่แผนของฉัน (ฉันแค่อยากจะช่วยเปลี่ยนจาก Arduino เป็น AVR Studio)
IDE คือสภาพแวดล้อมการพัฒนาแบบรวมที่มีเทมเพลต ไลบรารี และฟังก์ชันดีบักเกอร์ต่างๆ หากเราพูดถึงตั้งแต่ปี 2547 เป็นต้นมา AVR studio ก็ได้รับการพัฒนาแพ็คเกจซอฟต์แวร์ที่ทรงพลังสำหรับพวกเขา
รุ่นแรก
สตูดิโอเวอร์ชันแรกมีแอสเซมเบลอร์สำหรับ คุณสามารถแยกออกจากแอสเซมบลีแรกได้ แต่ต่อมาโปรเจ็กต์นี้ก็ถูกยกเลิก และเลือก C AVR เป็นภาษาหลัก คอมไพเลอร์เป็นผลิตภัณฑ์ IAR ที่ต้องเสียเงินและจริงจังมาก คุณสามารถดาวน์โหลด WINAVR ได้ฟรี โดยต้องติดตั้งสตูดิโอหลังจากติดตั้งสตูดิโอแล้ว
บันทึก! ควรทำหลังจากติดตั้ง AVR studio 4 และเวอร์ชันอื่น ๆ เท่านั้น
AVR studio 4 (ภาพด้านบน) มีจุดเด่นมานานแล้ว นักพัฒนาไมโครคอนโทรลเลอร์หลายรายประสบปัญหานี้ ต่อมา IDE ได้รับการอัปเกรดเป็น AVR studio 5 นอกเหนือจากอินเทอร์เฟซแล้ว ไม่มีการเปลี่ยนแปลงพิเศษใดๆ และมีเพียงบริษัทผู้พัฒนาเท่านั้นที่เปลี่ยนชื่อผลิตภัณฑ์และเปลี่ยนชื่อเป็น Atmel studio 6
สภาพแวดล้อม AVR studio 5 รองรับไมโครคอนโทรลเลอร์ต่อไปนี้:
- AVR32;
- เอ็กซ์เมก้า
Atmel studio 6 แตกต่างจาก AVR studio 5 อย่างมีนัยสำคัญ นวัตกรรมที่เห็นได้ชัดเจนที่สุดในเวอร์ชันนี้คือ:
- Microsoft Visual Studio 2010 เริ่มทำงานร่วมกับตระกูล AVR
- ปรับปรุงการเน้นไวยากรณ์เมื่อเปรียบเทียบกับ AVR studio 5
- เพิ่มคำแนะนำและการเติมชุดคำสั่งให้สมบูรณ์โดยอัตโนมัติ ซึ่งจะช่วยเร่งกระบวนการพัฒนาให้เร็วขึ้น
- โดยทั่วไปแล้ว การดำเนินการทั้งหมดของสภาพแวดล้อมมีความน่าเชื่อถือมากขึ้น
- เพิ่มการรองรับ ARM Cortex-M
- ไม่จำเป็นต้องติดตั้ง WinAVR แยกต่างหากอีกต่อไป ตอนนี้ GCC ได้รับการติดตั้งแล้วในระหว่างขั้นตอนการติดตั้ง ไม่เหมือนเวอร์ชันที่อายุน้อยกว่า
ใน Atmel studio 6 มีการก้าวกระโดดไปสู่สิ่งที่ดีกว่าสำหรับผู้ใช้โปรแกรม ซึ่งส่งผลต่อความนิยมของตระกูล Atmel อย่างไรก็ตาม ไม่สามารถได้รับการสนับสนุนอักขระภาษารัสเซียในเส้นทางไฟล์อย่างเพียงพอ
เวอร์ชันปัจจุบัน - Atmel studio 7
สภาพแวดล้อมการพัฒนาที่ฉันใช้คือ Visual Studio Isolated Shell 2015; ในแง่หนึ่งโซลูชันนี้ไม่รองรับ Windows XP ในทางกลับกัน มาตรการเหล่านี้ถูกนำมาใช้เพื่อปรับปรุงทั้งรูปลักษณ์ของโปรแกรมและฟังก์ชันการทำงานของโปรแกรม
บางทีสิ่งที่สำคัญที่สุดคือการเพิ่มการรองรับ Arduino ใน Atmel studio 7 ซึ่งหมายความว่าคุณสามารถเปลี่ยนจากชุดภาพร่างง่ายๆ ไปเป็นการใช้ฟังก์ชัน C ทั้งหมด การดีบัก เครื่องจำลอง MCU และฟังก์ชันอื่นๆ การรวมกันของ Arduino และ Atmel studio 7 ทำให้เกิดการพัฒนาแพลตฟอร์มการเรียนรู้ที่เรียบง่ายนี้ขึ้นมาใหม่
การศึกษาสตูดิโอ Atmel กับ Arduino จะให้โอกาสในการก้าวไปสู่การเรียนรู้ที่สมบูรณ์และมีประสิทธิภาพและทำความรู้จักกับหัวใจของ Arduino อย่างลึกซึ้งมากขึ้นนั่นคือไมโครคอนโทรลเลอร์ Atmega
นอกจากนี้ คุณสามารถดาวน์โหลดแพ็คเกจสำหรับการใช้งานและการเชื่อมต่อ LCD ได้จากเว็บไซต์ Atmel เพื่อเป็นตัวอย่างในการเรียนรู้ คุณสามารถใช้ LCD 1602 ได้ มีบทเรียนมากมายบนอินเทอร์เน็ต และนักพัฒนามี 16 ตัวอักษรและ 2 บรรทัดบนจอแสดงผล
จะเริ่มเรียนรู้ได้ที่ไหน?
แน่นอนว่าคุณควรเริ่มต้นด้วยการซื้อโปรแกรมเมอร์ USBASP ที่เป็นมิตรกับงบประมาณมากที่สุด โปรแกรมเมอร์ USBASP ไม่รองรับ Atmel Studio 7
ดาวน์โหลดไดรเวอร์สำหรับโปรแกรมเมอร์และโปรแกรม AVRdude และเพื่อให้ทุกอย่างทำงานร่วมกัน คุณสามารถใช้คำสั่งผ่านทางบรรทัดคำสั่ง:
"avrdude -c usbasp -p atmega32 -U แฟลช:w: ชื่อของไฟล์เฟิร์มแวร์ ฐานสิบหก -U ฟิวส์:w:0x6a:m -U ฟิวส์:w:0xff:m"
และเปิดใช้งานการสนับสนุนโดยการสร้างโปรไฟล์ใน atmel studio 7 (ชื่อ – เครื่องมือภายนอก) และในรายการอาร์กิวเมนต์ ให้ป้อน “-c usbasp -p atmega32 -U flash:w:$(TargetName).hex” และอื่นๆ สำหรับแต่ละ ประเภทที่คุณใช้ไมโครคอนโทรลเลอร์
นี่เป็นวิธีเดียวในการเชื่อมต่อสตูดิโอและโปรแกรมเมอร์ USBASP ระวังเมื่อกระพริบ - คุณสามารถสร้างความเสียหายให้กับลายเซ็นของไมโครคอนโทรลเลอร์ได้ และสามารถกู้คืนได้ด้วยโปรแกรมเมอร์ 12 V (ไฟฟ้าแรงสูง) เท่านั้น
ฉันควรใช้วรรณกรรมอะไรในการฝึกอบรม?
ก่อนอื่น ให้ดาวน์โหลดคู่มือจากเว็บไซต์อย่างเป็นทางการสำหรับไมโครคอนโทรลเลอร์แต่ละตัว เป็นการยากที่จะแนะนำหนังสือเรียนเฉพาะเล่ม แต่มี “DI Halt - AVR” หลักสูตรการฝึกอบรม" คุณสามารถใช้ได้ - ผู้สร้างเนื้อหานี้คือผู้ประกอบวิชาชีพ ผู้เขียนบทความมากมายเกี่ยวกับแหล่งข้อมูลทางอินเทอร์เน็ตต่างๆ และเป็นบุคคลที่เคารพนับถือในแวดวงผู้เชี่ยวชาญ
ฉันบอกไปแล้วหลายครั้งว่าการเรียน MK ควรเริ่มจากแอสเซมเบลอร์ หลักสูตรทั้งหมดบนเว็บไซต์ทุ่มเทให้กับสิ่งนี้ (ถึงแม้ว่ามันจะไม่สอดคล้องกันมาก แต่ฉันก็ค่อย ๆ หวีมันเพื่อให้ได้รูปลักษณ์ที่เหมาะสม) ใช่ มันเป็นเรื่องยาก ผลลัพธ์จะไม่เกิดขึ้นในวันแรก แต่คุณจะได้เรียนรู้ที่จะเข้าใจสิ่งที่เกิดขึ้นในตัวควบคุมของคุณ คุณจะรู้ว่ามันทำงานอย่างไร และไม่คัดลอกแหล่งที่มาของผู้อื่นอย่างลิง และพยายามทำความเข้าใจว่าทำไมมันถึงหยุดทำงานกะทันหัน นอกจากนี้ C ยังง่ายกว่ามากในการสร้างโค้ดใจแคบที่จะออกมาพร้อมกับโกยในช่วงเวลาที่ไม่เหมาะสมที่สุด
น่าเสียดายที่ทุกคนต้องการผลลัพธ์ทันที ดังนั้นฉันจึงตัดสินใจไปทางอื่น - ทำแบบฝึกหัดเกี่ยวกับ C แต่ด้วยการโชว์ชุดชั้นในของเขา โปรแกรมเมอร์ฝังตัวที่ดีมักจะจับชิ้นส่วนฮาร์ดแวร์ของเขาไว้แน่นด้วยสลักเกลียว ไม่อนุญาตให้ดำเนินการขั้นตอนเดียวโดยไม่ได้รับอนุญาต ก่อนอื่นจะต้องมีโค้ด C จากนั้นคอมไพเลอร์ผลิตอะไรและมันทำงานอย่างไรจริง ๆ :)
ในทางกลับกัน จุดแข็งของ C คือการพกพาโค้ดได้ ถ้าแน่นอนคุณเขียนทุกอย่างถูกต้อง การแยกอัลกอริทึมการทำงานและการใช้งานฮาร์ดแวร์ออกเป็นส่วนต่างๆ ของโครงการ จากนั้นในการถ่ายโอนอัลกอริธึมไปยังไมโครคอนโทรลเลอร์อื่นก็เพียงพอแล้วที่จะเขียนใหม่เฉพาะเลเยอร์อินเทอร์เฟซซึ่งมีการเขียนการเรียกไปยังฮาร์ดแวร์ทั้งหมดและปล่อยให้รหัสการทำงานทั้งหมดเหมือนเดิม และแน่นอนว่าสามารถอ่านได้ง่าย ซอร์สโค้ด C นั้นง่ายต่อการเข้าใจตั้งแต่แรกเห็น (แม้ว่า... ตัวอย่างเช่น ฉันไม่สนใจว่าจะชี้ไปที่อะไร ไม่ว่าจะเป็น C หรือ ASM :)) แต่ขอย้ำอีกครั้งว่าหากทุกอย่างถูกต้อง ฉันจะใส่ใจกับประเด็นเหล่านี้ด้วย
บอร์ดตรวจแก้จุดบกพร่องของฉันจะทำหน้าที่เป็นฮาร์ดแวร์ทดลองซึ่งจะมีการติดตั้งตัวอย่างทั้งหมดเป็นจำนวนมาก
โปรแกรม C แรกสำหรับ AVR
การเลือกคอมไพเลอร์และการตั้งค่าสภาพแวดล้อม
มีคอมไพเลอร์ C มากมายสำหรับ AVR:
ก่อนอื่นนี้ ไอเออาร์ เอวีอาร์ ซี- เกือบจะได้รับการยอมรับว่าเป็นคอมไพเลอร์ที่ดีที่สุดสำหรับ AVR เพราะ ตัวควบคุมนั้นถูกสร้างขึ้นโดยความร่วมมืออย่างใกล้ชิดระหว่าง Atmel และผู้เชี่ยวชาญจาก IAR แต่คุณต้องจ่ายทุกอย่าง และคอมไพเลอร์นี้ไม่เพียง แต่เป็นซอฟต์แวร์เชิงพาณิชย์ราคาแพงเท่านั้น แต่ยังมีการตั้งค่ามากมายที่ต้องใช้ความพยายามอย่างมากในการคอมไพล์มัน ฉันไม่ได้พัฒนามิตรภาพกับเขาจริง ๆ โปรเจ็กต์เน่าเปื่อยเนื่องจากข้อผิดพลาดแปลก ๆ ในขั้นตอนการเชื่อมโยง (ต่อมาฉันพบว่ามันเป็นรอยร้าวที่คดเคี้ยว)
ครั้งที่สองมา WinAVR GCC- คอมไพเลอร์เพิ่มประสิทธิภาพอันทรงพลัง โอเพ่นซอร์สเต็มรูปแบบ ข้ามแพลตฟอร์ม โดยทั่วไป ทุกสิ่งคือความสุขของชีวิต นอกจากนี้ยังผสานรวมเข้ากับ AVR Studio ได้อย่างสมบูรณ์แบบ ทำให้คุณสามารถแก้ไขจุดบกพร่องได้ทันที ซึ่งสะดวกมาก โดยทั่วไปฉันเลือกมัน
นอกจากนี้ยังมี CodeVision AVR ซีเป็นคอมไพเลอร์ที่ได้รับความนิยมมาก มันได้รับความนิยมเนื่องจากความเรียบง่าย คุณสามารถรับโปรแกรมที่ใช้งานได้ภายในเวลาเพียงไม่กี่นาที - ตัวช่วยสร้างโค้ดเริ่มต้นช่วยอำนวยความสะดวกในเรื่องนี้อย่างมากโดยการประทับตรามาตรฐานสำหรับการเริ่มต้นสิ่งต่าง ๆ ทุกประเภท พูดตามตรง ฉันค่อนข้างสงสัย - เมื่อฉันต้องแยกโปรแกรมที่เขียนโดยคอมไพเลอร์นี้ มันกลับกลายเป็นว่ายุ่งเหยิงและไม่ใช่โค้ด การเคลื่อนไหวและการดำเนินการที่ไม่จำเป็นจำนวนมหาศาล ซึ่งส่งผลให้มีโค้ดจำนวนมากและประสิทธิภาพที่ช้า อย่างไรก็ตาม บางทีอาจมีข้อผิดพลาดใน DNA ของบุคคลที่เขียนเฟิร์มแวร์ดั้งเดิม แถมยังต้องการเงินอีกด้วย ไม่มากเท่ากับ IAR แต่สังเกตได้ชัดเจน และในโหมดสาธิตจะช่วยให้คุณสามารถเขียนโค้ดได้ไม่เกิน 2kb
แน่นอนว่ามีรอยร้าว แต่ถ้าคุณจะขโมย มันเป็นล้าน ในแง่ IAR :)
นอกจากนี้ยังมี อิมเมจ คราฟต์ AVR Cและ ไมโครซีจากไมโครอิเล็กทรอนิกส์ ฉันไม่จำเป็นต้องใช้อย่างใดอย่างหนึ่ง แต่ ส.ว.ก.น่ายกย่องมาก ไมโครปาสคาลพวกเขากล่าวว่าเป็นสภาพแวดล้อมการเขียนโปรแกรมและไลบรารีที่สะดวกอย่างยิ่ง ฉันคิดว่า MicroC จะไม่แย่ลง แต่ก็ได้รับค่าตอบแทนเช่นกัน
อย่างที่ผมบอกผมเลือก WinAVRด้วยเหตุผลสามประการ: ฟรี สามารถรวมเข้ากับ AVR Studio และมีโค้ดสำเร็จรูปมากมายที่เขียนขึ้นสำหรับทุกโอกาส
ดังนั้นดาวน์โหลดการติดตั้ง WinAVR ด้วย AVR Studio ถัดไป ติดตั้งสตูดิโอก่อน จากนั้น WinAVR จะถูกม้วนไว้ด้านบนและแนบกับสตูดิโอในรูปแบบของปลั๊กอิน ฉันขอแนะนำอย่างยิ่งให้ติดตั้ง WinAVR บนเส้นทางสั้น เช่น C:\WinAVR ด้วยวิธีนี้ คุณจะหลีกเลี่ยงปัญหามากมายเกี่ยวกับเส้นทาง
การสร้างโครงการ
ดังนั้นจึงติดตั้งสตูดิโอแล้ว C ถูกขันเข้าไปถึงเวลาที่จะพยายามเขียนโปรแกรมบางอย่าง เริ่มจากสิ่งที่ง่ายที่สุดและง่ายที่สุด เปิดสตูดิโอ เลือกโปรเจ็กต์ใหม่ที่นั่น เป็นคอมไพเลอร์ AVR GCC และป้อนชื่อของโปรเจ็กต์
ฟิลด์งานจะเปิดขึ้นพร้อมกับไฟล์ *.c ที่ว่างเปล่า
ตอนนี้การกำหนดค่าการแสดงเส้นทางในบุ๊กมาร์กของสตูดิโอจะไม่เสียหาย โดยไปที่:
เครื่องมือเมนู - ตัวเลือก - ทั่วไป - FileTabs และเลือก "ชื่อไฟล์เท่านั้น" จากรายการแบบเลื่อนลง มิฉะนั้นจะไม่สามารถทำงานได้ - แท็บจะมีเส้นทางแบบเต็มของไฟล์และจะไม่มีแท็บบนหน้าจอเกินสองหรือสามแท็บ
การตั้งค่าโครงการ
โดยทั่วไป การสร้างไฟล์ make ที่มีการอธิบายการขึ้นต่อกันทั้งหมดถือเป็นเรื่องคลาสสิก และนั่นอาจจะถูกต้อง แต่สำหรับผมที่โตมากับ IDE แบบครบวงจรอย่างผม ยูวิชั่นหรือ เอวีอาร์ สตูดิโอแนวทางนี้ช่างแตกต่างอย่างลึกซึ้ง ดังนั้นฉันจะทำตามแบบของฉัน ทุกอย่างใช้วิธีแบบสตูดิโอ
สะกิดปุ่มด้วยเกียร์
 |
นี่คือการตั้งค่าสำหรับโปรเจ็กต์ของคุณ หรือเป็นการตั้งค่าสำหรับการสร้างไฟล์ make อัตโนมัติ ในหน้าแรก คุณเพียงแค่ต้องป้อนความถี่ที่ MK ของคุณจะทำงาน ขึ้นอยู่กับบิตฟิวส์ ดังนั้นเราจึงถือว่าความถี่ของเราคือ 8000000Hz
ให้ความสนใจกับสายการเพิ่มประสิทธิภาพด้วย ขณะนี้มี -Os - นี่คือการเพิ่มประสิทธิภาพขนาด ปล่อยไว้เหมือนเดิมแล้วคุณสามารถลองเล่นกับพารามิเตอร์นี้ได้ -O0 ไม่มีการเพิ่มประสิทธิภาพเลย
ขั้นตอนต่อไปคือการกำหนดค่าเส้นทาง ก่อนอื่น เพิ่มไดเร็กทอรีโครงการของคุณที่นั่น - คุณจะเพิ่มไลบรารีบุคคลที่สามที่นั่น เส้นทาง “.\” จะปรากฏในรายการ
ไฟล์ Make ถูกสร้างขึ้นแล้ว คุณสามารถดูได้ในโฟลเดอร์เริ่มต้นในโครงการของคุณ เพียงลองดูว่ามีอะไรบ้าง
 |
นั่นคือทั้งหมดที่สำหรับตอนนี้. คลิกตกลงทุกที่และไปที่แหล่งที่มา
การกำหนดปัญหา
กระดาษเปล่าน่าดึงดูดใจที่จะใช้ความคิดอันชาญฉลาดเนื่องจากการกะพริบของไดโอดซ้ำ ๆ ไม่ทำงานอีกต่อไป เรามาจับวัวข้างเขาทันทีแล้วเชื่อมต่อกับคอมพิวเตอร์ - นี่คือสิ่งแรกที่ฉันทำ
มันจะทำงานเช่นนี้:
เมื่อมาถึงพอร์ต COM (รหัส 0x31) เราจะเปิดไดโอดและเมื่อถึงศูนย์ (รหัส 0x30) ก็จะปิด ยิ่งกว่านั้นทุกอย่างจะดำเนินการเมื่อมีการขัดจังหวะและงานพื้นหลังจะเป็นการกะพริบของไดโอดอื่น เรียบง่ายและมีความหมาย
การประกอบวงจร
เราจำเป็นต้องเชื่อมต่อโมดูลตัวแปลง USB-USART เข้ากับพิน USART ของไมโครคอนโทรลเลอร์ ในการทำเช่นนี้ให้นำจัมเปอร์จากสายไฟสองเส้นแล้ววางไว้บนหมุดตามขวาง นั่นคือเราเชื่อมต่อ Rx ของคอนโทรลเลอร์กับ Tx ของคอนเวอร์เตอร์ และ Tx ของคอนเวอร์เตอร์กับ Rx ของคอนโทรลเลอร์
ท้ายที่สุดนี่คือแผนภาพ:
 |
ฉันไม่คิดว่าจะเชื่อมต่อพิน พลังงาน หรือการรีเซ็ตที่เหลือ มันเป็นมาตรฐาน
การเขียนโค้ด
ผมขอจองไว้ก่อนว่าจะไม่เจาะลึกคำอธิบายภาษา C โดยเฉพาะครับ มีเนื้อหาจำนวนมหาศาลสำหรับสิ่งนี้ ตั้งแต่ "ภาษาการเขียนโปรแกรม C" แบบคลาสสิกจาก K&R ไปจนถึงคู่มือต่างๆ
ฉันพบวิธีการดังกล่าวในคลังของฉัน ครั้งหนึ่ง ฉันเคยใช้มันเพื่อศึกษาภาษานี้ ทุกอย่างสั้น ชัดเจน และตรงประเด็น ฉันค่อยๆ รวบรวมมันเข้าด้วยกันและลากมันมาไว้บนเว็บไซต์ของฉัน
เป็นเรื่องจริงที่บททั้งหมดยังไม่ถูกถ่ายโอน แต่ฉันคิดว่าคงอีกไม่นาน
ไม่น่าเป็นไปได้ที่ฉันจะอธิบายได้ดีขึ้น ดังนั้นจากหลักสูตรการฝึกอบรม แทนที่จะอธิบายรายละเอียดปลีกย่อย ฉันเพียงแต่ให้ลิงก์โดยตรงไปยังหน้าแต่ละหน้าของคู่มือนี้
การเพิ่มไลบรารี
ก่อนอื่น เราเพิ่มไลบรารีและส่วนหัวที่จำเป็นพร้อมคำจำกัดความ ท้ายที่สุดแล้ว C เป็นภาษาสากล และเราจำเป็นต้องอธิบายให้เขาฟังว่าเรากำลังทำงานกับ AVR โดยเฉพาะ ดังนั้นให้เขียนบรรทัดในซอร์สโค้ด:
| 1 | #รวม |
#รวม
ไฟล์นี้อยู่ในโฟลเดอร์ WinAVRและมีคำอธิบายของรีจิสเตอร์และพอร์ตทั้งหมดของคอนโทรลเลอร์ ยิ่งกว่านั้นทุกสิ่งที่มีไหวพริบโดยเชื่อมโยงกับคอนโทรลเลอร์เฉพาะซึ่งคอมไพเลอร์ส่งผ่าน ทำไฟล์ในพารามิเตอร์ มจรและขึ้นอยู่กับตัวแปรนี้ ไฟล์ส่วนหัวจะเชื่อมต่อกับโปรเจ็กต์ของคุณพร้อมคำอธิบายที่อยู่ของพอร์ตและรีจิสเตอร์ทั้งหมดสำหรับคอนโทรลเลอร์เฉพาะนี้ ว้าว! หากไม่มีสิ่งนี้ ก็เป็นไปได้เช่นกัน แต่หลังจากนั้น คุณจะไม่สามารถใช้ชื่อการลงทะเบียนเชิงสัญลักษณ์ เช่น SREG หรือ UDR ได้ และคุณจะต้องจำที่อยู่ของแต่ละรายการ เช่น "0xC1" ซึ่งจะทำให้ปวดหัว
ทีมงานเอง #รวม<имя файла> ช่วยให้คุณสามารถเพิ่มเนื้อหาของไฟล์ข้อความใด ๆ ในโครงการของคุณ เช่น ไฟล์ที่มีคำอธิบายฟังก์ชันหรือโค้ดอื่น ๆ และเพื่อให้คำสั่งสามารถค้นหาไฟล์นี้ได้ เราจึงระบุเส้นทางไปยังโปรเจ็กต์ของเรา (ไดเร็กทอรี WinAVR ได้รับการลงทะเบียนไว้แล้วตามค่าเริ่มต้น)
ฟังก์ชั่นหลัก.
โปรแกรม A C ประกอบด้วยฟังก์ชันทั้งหมด พวกเขาสามารถซ้อนกันและเรียกจากกันในลำดับใด ๆ และในรูปแบบที่แตกต่างกัน แต่ละฟังก์ชันมีพารามิเตอร์ที่จำเป็นสามตัว:
- ค่าส่งคืนคือเช่น บาป(x)ส่งคืนค่าไซน์ของ x เช่นเดียวกับในวิชาคณิตศาสตร์โดยสรุป
- พารามิเตอร์ที่ส่งจะเหมือนกัน X
- ฟังก์ชั่นร่างกาย
ค่าทั้งหมดที่ส่งและส่งคืนต้องเป็นค่าบางประเภทขึ้นอยู่กับข้อมูล
โปรแกรม C ใดๆ จะต้องมีฟังก์ชัน หลักเป็นจุดเข้าสู่โปรแกรมหลัก ไม่งั้นก็ไม่ใช่ C เลย :) การมี main ในซอร์สโค้ดของคนอื่นจากไฟล์กว่าล้านไฟล์ คุณสามารถเข้าใจได้ว่านี่คือส่วนหลักของโปรแกรมที่ทุกอย่างเริ่มต้นขึ้น ลองถามดูว่า:
| 1 2 3 4 5 | int main(เป็นโมฆะ) (ส่งคืน 0 ;) |
int main(เป็นโมฆะ) ( return 0; )
เพียงเท่านี้ โปรแกรมแรกที่ง่ายที่สุดก็เขียนขึ้นแล้ว ไม่สำคัญว่าจะไม่ทำอะไรเลย เราเพิ่งเริ่มต้น
ลองหาว่าเราทำอะไร
ภายในนี่คือชนิดข้อมูลที่ฟังก์ชันหลักส่งคืน
แน่นอนในไมโครคอนโทรลเลอร์ หลักโดยหลักการแล้ว ไม่มีอะไรสามารถคืนได้ และในทางทฤษฎีก็ควรจะเป็นเช่นนั้น เป็นโมฆะหลัก (เป็นโมฆะ)แต่เดิม GCC ได้รับการออกแบบมาสำหรับพีซี และที่นั่นโปรแกรมสามารถคืนค่าให้กับระบบปฏิบัติการได้เมื่อเสร็จสิ้น ดังนั้น GCC จึงเปิดอยู่ เป็นโมฆะหลัก (เป็นโมฆะ)สาบานด้วยคำเตือน
นี่ไม่ใช่ข้อผิดพลาด แต่จะได้ผล แต่ฉันไม่ชอบคำเตือน
เป็นโมฆะนี่คือประเภทของข้อมูลที่เราส่งไปยังฟังก์ชัน ในกรณีนี้ หลักอีกทั้งรับอะไรจากภายนอกไม่ได้ด้วย เป็นโมฆะ- หุ่นเชิด Stub จะใช้เมื่อไม่จำเป็นต้องส่งหรือส่งคืนสิ่งใดๆ
นี่พวกเขา { } วงเล็บปีกกาคือบล็อกโปรแกรม ในกรณีนี้คือส่วนเนื้อหาของฟังก์ชัน หลักโค้ดจะอยู่ที่นั่น
กลับ- นี่คือค่าที่ส่งคืนที่ฟังก์ชันหลักจะส่งคืนเมื่อเสร็จสิ้น เนื่องจากเรามี int นั่นคือตัวเลข เราจึงต้องส่งคืนตัวเลข แม้จะยังไม่สมเหตุสมผลก็ตาม เพราะ... บนไมโครคอนโทรลเลอร์เราไม่สามารถไปจากหลักได้เลย ฉันกลับเป็นโมฆะ เพราะมันไม่สำคัญ แต่คอมไพเลอร์มักจะฉลาดและไม่สร้างโค้ดสำหรับกรณีนี้
แม้ว่าถ้าในทางที่ผิดแล้วจาก หลักคุณสามารถไปที่ MK ได้ - ตัวอย่างเช่นตกอยู่ในส่วน bootloader และดำเนินการ แต่จะต้องใช้เฟิร์มแวร์ระดับต่ำเพื่อแก้ไขที่อยู่การเปลี่ยนแปลง ด้านล่างนี้คุณจะเห็นด้วยตัวคุณเองและเข้าใจวิธีการทำ เพื่ออะไร? นี่เป็นอีกคำถามหนึ่ง ใน 99.999% ของกรณีนี้ไม่จำเป็น :)
เราทำมันและเดินหน้าต่อไป มาเพิ่มตัวแปรกัน เราไม่ต้องการมันจริงๆ และไม่มีประโยชน์ที่จะแนะนำตัวแปรหากไม่มีมัน แต่เรากำลังเรียนรู้ หากมีการเพิ่มตัวแปรภายในเนื้อความของฟังก์ชัน ตัวแปรเหล่านั้นจะเป็นแบบโลคัลและมีอยู่ในฟังก์ชันนี้เท่านั้น เมื่อคุณออกจากฟังก์ชัน ตัวแปรเหล่านี้จะถูกลบ และหน่วยความจำ RAM จะถูกจัดสรรสำหรับความต้องการที่สำคัญกว่า .
| 1 2 3 4 5 6 | int main(void) ( char i ที่ไม่ได้ลงชื่อ; return 0 ; ) |
int main(void) ( char i ที่ไม่ได้ลงชื่อ; return 0; )
ไม่ได้ลงนามหมายถึงไม่ได้ลงนาม ความจริงก็คือในการแทนค่าไบนารี่ บิตที่สำคัญที่สุดจะถูกจัดสรรให้กับเครื่องหมาย ซึ่งหมายความว่าตัวเลข +127/-128 จะพอดีกับหนึ่งไบต์ (อักขระ) แต่ถ้าเครื่องหมายถูกทิ้งไป เครื่องหมายนั้นจะพอดีตั้งแต่ 0 ถึง 255. โดยปกติแล้วไม่จำเป็นต้องใช้ป้าย ดังนั้น ไม่ได้ลงนาม.
ฉันเป็นเพียงชื่อตัวแปร ไม่มีอีกแล้ว
ตอนนี้เราต้องเริ่มต้นพอร์ตและ ยูอาร์ที. แน่นอนคุณสามารถใช้และเชื่อมต่อห้องสมุดและโทรหา UartInit(9600) บางประเภทได้ แต่แล้วคุณจะไม่รู้ว่าเกิดอะไรขึ้นจริงๆ
เราทำสิ่งนี้:
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | int main(void) ( char i ที่ไม่ได้ลงนาม; #define XTAL 8000000L #define baudrate 9600L #define บอดดิวิเดอร์ (XTAL/(16*baudrate)-1)#define HI(x) ((x)>>8) #define LO(x) ((x)& 0xFF) UBRRL = LO(ตัวแบ่งบอด) ; UBRRH = HI(ตัวแบ่งบอด) ; สสส. = 0 ; สสส. = 1<< RXEN| 1 << TXEN| 1 << RXCIE| 0 << TXCIE; UCSRC = 1 << URSEL| 1 << UCSZ0| 1 << UCSZ1; } |
int main(void) ( char i ที่ไม่ได้ลงนาม; #define XTAL 8000000L #define baudrate 9600L #define bauddivider (XTAL/(16*baudrate)-1) #define HI(x) ((x)>>8) #define LO( x) ((x)& 0xFF) UBRRL = LO(บอดดิวิเดอร์); UBRRH = HI(บอดดิวิเดอร์); UCSRA = 0; UCSRB = 1< น่ากลัว? ในความเป็นจริงมีโค้ดจริงเพียงห้าบรรทัดสุดท้ายเท่านั้น ทุกสิ่งทุกอย่างนั้น #กำหนดมันเป็นภาษามาโครตัวประมวลผลล่วงหน้า เกือบจะเหมือนกับใน Assembly แต่ไวยากรณ์แตกต่างกันเล็กน้อย พวกเขาจะอำนวยความสะดวกในการดำเนินงานประจำของคุณในการคำนวณค่าสัมประสิทธิ์ที่จำเป็น ในบรรทัดแรกเราพูดอย่างนั้นแทน เอ็กซ์ตอลคุณสามารถทดแทน 8000000 ได้อย่างปลอดภัยและ ล- การระบุประเภทโดยบอกว่ายาวคือความถี่สัญญาณนาฬิกาของโปรเซสเซอร์ เหมือน บอดเรต— ความถี่ในการส่งข้อมูลผ่าน UART bauddividerซับซ้อนกว่าอยู่แล้ว แต่แทนที่นิพจน์ที่คำนวณโดยใช้สูตรจากสองรายการก่อนหน้าจะถูกแทนที่ ดังนั้นทุกสิ่งที่ทำก็เป็นเช่นนั้น #กำหนดคุณสามารถทิ้งมันไปได้อย่างปลอดภัยและคำนวณตัวเลขที่จำเป็นบนเครื่องคิดเลขแล้วป้อนลงในบรรทัด UBBRL = …. ทันที และ UBBRH = ….. สามารถ. แต่! ทำเช่นนี้ เป็นไปไม่ได้อย่างแน่นอน! มันจะทำงานแบบนี้หรือแบบนั้นแต่คุณจะมีสิ่งที่เรียกว่า ตัวเลขมหัศจรรย์- ค่านิยมที่นำมาจากที่ไหนเลยและไม่ทราบสาเหตุ และหากคุณเปิดโครงการดังกล่าวในอีกไม่กี่ปีข้างหน้า มันจะยากที่จะเข้าใจว่าค่าเหล่านี้คืออะไร แม้กระทั่งตอนนี้ หากคุณต้องการเปลี่ยนความเร็วหรือเปลี่ยนความถี่ของควอตซ์ ทุกอย่างจะต้องถูกคำนวณใหม่อีกครั้ง แต่คุณเปลี่ยนตัวเลขสองสามตัวในโค้ด เท่านี้ก็เรียบร้อย โดยทั่วไป หากคุณไม่ต้องการถูกแบรนด์ว่าเป็นผู้เขียนโค้ด ให้สร้างโค้ดของคุณเพื่อให้อ่านง่าย เข้าใจง่าย และแก้ไขได้ง่าย จากนั้นทุกอย่างก็ง่าย: ประเภทการบันทึก 1< เสร็จแล้วได้เวลาดูว่าเกิดอะไรขึ้น คลิกที่การคอมไพล์และเริ่มการจำลอง (Ctrl+F7) การดีบัก ความจริงก็คือในตอนแรกมันอยู่ในบรรทัด UBRRL = LO(bauddivider); ท้ายที่สุดแล้ว สิ่งที่เรากำหนดไว้ไม่ใช่โค้ด แต่เป็นเพียงการคำนวณเบื้องต้น ซึ่งเป็นเหตุผลว่าทำไมโปรแกรมจำลองจึงดูน่าเบื่อเล็กน้อย แต่ตอนนี้เขาตระหนักได้ว่า คำสั่งแรกเสร็จสิ้นแล้วและถ้าคุณปีนขึ้นไปบนต้นไม้ มุมมอง I/Oไปที่ส่วน USART และดูที่ไบต์ UBBRL ที่นั่น คุณจะเห็นว่าค่านั้นอยู่ที่นั่นแล้ว! 0x33. ก้าวไปอีกขั้นหนึ่ง ดูว่าเนื้อหาของรีจิสเตอร์อื่นเปลี่ยนแปลงอย่างไร ดังนั้นให้อ่านทั้งหมดโดยใส่ใจกับความจริงที่ว่าบิตที่ระบุทั้งหมดได้รับการตั้งค่าตามที่ฉันบอกคุณและบิตเหล่านั้นจะถูกตั้งค่าพร้อมกันสำหรับทั้งไบต์ มันจะไม่ไปไกลกว่า Return - โปรแกรมจบลงแล้ว กำลังเปิด อันดับแรกจะมีท็อปจากซีรีส์นี้: 00000000: 940C002A JMP 0x0000002A กระโดด +00000002: 940C0034 JMP 0x00000034 กระโดด +00000004: 940C0034 JMP 0x00000034 กระโดด +00000006: 940C0034 JMP 0x0 0000034 กระโดด +00000008: 940C0034 JMP 0x00000034 กระโดด +0000000A: 940C0034 JMP 0x00000034 กระโดด +0000000C: 940C0034 JMP 0x00000034 กระโดด +0000000E : 940C0034 JMP 0x00000034 กระโดด +00000010: 940C0034 JMP 0x00000034 กระโดด +00000012: 940C0034 JMP 0x00000034 กระโดด +00000014: 940C0034 JMP 0x000000 34 กระโดด +00000016: 940C0034 JMP 0x00000034 กระโดด +00000018: 940C0034 JMP 0x00000034 กระโดด +0000001A: 940C0034 JMP 0x00000034 กระโดด +0000001C : 940C0034 JMP 0x00000034 กระโดด +0000001E: 940C0034 JMP 0x00000034 กระโดด +00000020: 940C0034 JMP 0x00000034 กระโดด +00000022: 940C0034 JMP 0x00000034 กระโดด + 00000024: 940C0034 JMP 0x00000034 กระโดด +00000026: 940C0034 JMP 0x00000034 กระโดด +00000028: 940C0034 JMP 0x00000034 กระโดด นี่คือตารางเวกเตอร์อินเทอร์รัปต์ เราจะกลับมาหามันในภายหลัง แต่ตอนนี้แค่มองและจำไว้ว่ามันมีอยู่จริง คอลัมน์แรกคือที่อยู่ของเซลล์แฟลชซึ่งมีคำสั่งอยู่ คอลัมน์ที่สองคือรหัสคำสั่ง คอลัมน์ที่สามคือคำสั่งช่วยในการจำ คำสั่งแอสเซมบลีเดียวกัน คอลัมน์ที่สามคือตัวถูกดำเนินการของคำสั่ง ดีแสดงความคิดเห็นอัตโนมัติ 0000002B: BE1F OUT 0x3F,R1 ออกไปยังตำแหน่ง I/O บันทึกศูนย์นี้ที่ที่อยู่ 0x3F หากคุณดูคอลัมน์มุมมอง I/O คุณจะเห็นว่าที่อยู่ 0x3F คือที่อยู่ของรีจิสเตอร์ SREG ซึ่งเป็นแฟล็กรีจิสเตอร์ของคอนโทรลเลอร์ เหล่านั้น. เรารีเซ็ต SREG เพื่อรันโปรแกรมโดยไม่มีเงื่อนไข 0000002C: E5CF LDI R28,0x5F โหลดทันที +0000002D: E0D4 LDI R29,0x04 โหลดทันที +0000002E: BFDE OUT 0x3E,R29 ออกไปที่ตำแหน่ง I/O +0000002F: BFCD OUT 0x3D,R28 ออกไปที่ตำแหน่ง I/O นี่คือการโหลดตัวชี้สแต็ก คุณไม่สามารถโหลดเข้าสู่รีจิสเตอร์ I/O ได้โดยตรง แต่จะผ่านรีจิสเตอร์ระดับกลางเท่านั้น ดังนั้น LDI แรกถึงระดับกลาง จากนั้นจึง OUT ไปยัง I/O ฉันจะบอกคุณเพิ่มเติมเกี่ยวกับสแต็กในภายหลัง สำหรับตอนนี้ โปรดทราบว่านี่คือพื้นที่หน่วยความจำแบบไดนามิกที่แฮงค์ที่ส่วนท้ายของ RAM และจัดเก็บที่อยู่และตัวแปรระดับกลาง ตอนนี้เราได้ระบุแล้วว่าสแต็กของเราจะเริ่มต้นจากที่ใด 00000032: 940C0041 JMP 0x00000041 กระโดด ข้ามไปที่ส่วนท้ายสุดของโปรแกรม และที่นั่นเรามีข้อห้ามในการขัดจังหวะและการวนซ้ำอย่างแน่นหนากับตัวมันเอง: 00000041: 94F8 CLI Global Interrupt ปิดการใช้งาน +00000042: CFFF RJMP PC-0x0000 การข้ามแบบสัมพันธ์ นี่เป็นกรณีที่เกิดเหตุการณ์ไม่คาดฝัน เช่น การออกจากหน้าที่หลัก ตัวควบคุมสามารถนำออกจากลูปดังกล่าวได้โดยการรีเซ็ตฮาร์ดแวร์ หรืออาจเป็นไปได้มากกว่าด้วยการรีเซ็ตจากโปรแกรมเฝ้าระวัง หรืออย่างที่ผมบอกไปข้างต้น ให้แก้ไขสิ่งนี้ในโปรแกรมแก้ไข hex แล้วพุ่งไปยังทุกที่ที่ใจเราต้องการ โปรดทราบว่าการเปลี่ยนมีสองประเภท: JMP และ RJMP แบบแรกคือการเปลี่ยนโดยตรงไปยังที่อยู่ มันกินพื้นที่สี่ไบต์และสามารถข้ามผ่านพื้นที่หน่วยความจำทั้งหมดได้โดยตรง การเปลี่ยนแปลงประเภทที่สองคือ RJMP - แบบสัมพันธ์ คำสั่งของเขาใช้เวลาสองไบต์ แต่เขาย้ายจากตำแหน่งปัจจุบัน (ที่อยู่) 1,024 ก้าวไปข้างหน้าหรือข้างหลัง และพารามิเตอร์ระบุออฟเซ็ตจากจุดปัจจุบัน มีการใช้บ่อยขึ้นเพราะว่า ใช้พื้นที่ครึ่งหนึ่งในการฟลัช และแทบไม่จำเป็นต้องมีการเปลี่ยนผ่านเป็นเวลานาน 00000034: 940C0000 JMP 0x00000000 กระโดด และนี่คือการข้ามไปยังจุดเริ่มต้นของโค้ด การรีบูตประเภทต่างๆ คุณตรวจสอบได้ว่าเวกเตอร์ทั้งหมดกระโดดตรงนี้ ข้อสรุปจากเรื่องนี้ก็คือหากคุณเปิดใช้งานการขัดจังหวะ (ถูกปิดใช้งานโดยค่าเริ่มต้น) และการขัดจังหวะของคุณเกิดขึ้น แต่ไม่มีตัวจัดการ จะมีการรีเซ็ตซอฟต์แวร์ - โปรแกรมจะถูกส่งกลับไปยังจุดเริ่มต้น ฟังก์ชั่นหลัก ทุกอย่างคล้ายกัน คุณไม่จำเป็นต้องอธิบายด้วยซ้ำ เพียงดูหมายเลขที่คำนวณแล้วซึ่งถูกป้อนลงในทะเบียน พรีโปรเซสเซอร์ของคอมไพเลอร์สั่นสะเทือน!!! ดังนั้นจึงไม่มีตัวเลข "มหัศจรรย์"! 00000036: E383 LDI R24,0x33 โหลดทันที +00000037: B989 OUT 0x09,R24 ออกไปที่ตำแหน่ง I/O 15: UBRRH = HI (ตัวแบ่งบอด); +00000038: BC10 OUT 0x20,R1 ออกไปที่ตำแหน่ง I/O 16: UCSRA = 0; +00000039: B81B OUT 0x0B,R1 ออกไปที่ตำแหน่ง I/O 17: UCSRB = 1< และนี่คือจุดบกพร่อง: 0000003E: E080 LDI R24.0x00 โหลดทันที +0000003F: E090 LDI R25.0x00 โหลดทันที +00000040: 9508 RET การส่งคืนรูทีนย่อย คำถามคือ เหตุใดคอมไพลเลอร์จึงเพิ่มยอดดังกล่าว? และนี่ไม่ใช่อะไรมากไปกว่า Return 0 เรากำหนดฟังก์ชันเป็น int main(void) และดังนั้นเราจึงเสียอีกสี่ไบต์โดยเปล่าประโยชน์เลย :) และถ้าคุณทำให้ void main(void) แล้ว RET เท่านั้นที่จะยังคงอยู่ แต่คำเตือนจะปรากฏขึ้น ว่าฟังก์ชันหลักของเราไม่ส่งคืนอะไรเลย โดยทั่วไปแล้ว ทำตามที่คุณพอใจ :) ยาก? ชัดเจนว่าไม่. คลิกการดำเนินการทีละขั้นตอนในโหมดการแยกส่วนประกอบ และดูว่าโปรเซสเซอร์ดำเนินการตามคำสั่งแต่ละอย่างอย่างไร เกิดอะไรขึ้นกับรีจิสเตอร์ การเคลื่อนไหวผ่านคำสั่งและการวนรอบสุดท้ายเกิดขึ้นได้อย่างไร? ต่อเนื่องอีกสองสามวัน... ท็อปท็อป: Atmel Studio เป็นแพลตฟอร์มการพัฒนาแบบรวมที่ให้ความสามารถในการออกแบบและแก้ไขข้อบกพร่องแอปพลิเคชันที่พัฒนาขึ้นสำหรับไมโครคอนโทรลเลอร์ Atmel โดยใช้สถาปัตยกรรมโปรเซสเซอร์ ARM Cortex-M ซีรีส์ Atmel Studio เป็นสภาพแวดล้อมที่ราบรื่นและใช้งานง่าย ซึ่งให้ความสามารถในการแก้ไขข้อบกพร่องและสร้างแอปพลิเคชันที่สร้างด้วยภาษา C/C++ หรือภาษาแอสเซมบลี มีไลบรารี่มากมายในตัวของซอร์สโค้ด Atmel Software Framework ฟรี ซึ่งประกอบด้วยโปรเจ็กต์มากกว่า 1,600 โปรเจ็กต์สำหรับสถาปัตยกรรม ARM และ AVR การมีห้องสมุดเช่นนี้ถือเป็นโบนัสที่ยอดเยี่ยมสำหรับโปรแกรมเมอร์ทุกคน IDE นี้สามารถใช้เพื่อตั้งโปรแกรมไมโครคอนโทรลเลอร์ที่ใช้ AVR ได้หลากหลาย รวมถึงไมโครคอนโทรลเลอร์แฟลชที่ใช้ Atmel SAM3 ที่ใช้คอร์ Cortex-M3, Cortex-M4 Atmel Studio ยังมีเครื่องมือที่จะทำให้ชีวิตของโปรแกรมเมอร์ง่ายขึ้นมาก แพลตฟอร์มดังกล่าวประกอบด้วยโซลูชันต่างๆ เช่น Atmel Spaces และ Atmel Gallery Atmel Gallery คือร้านค้าออนไลน์ที่รวบรวมเครื่องมือสำหรับการพัฒนาและซอฟต์แวร์รวม Atmel Spaces คือพื้นที่บนระบบคลาวด์สำหรับการพัฒนาร่วมกันและการจัดเก็บไฟล์โครงการฮาร์ดแวร์และซอฟต์แวร์สำหรับไมโครคอนโทรลเลอร์ Atmel 7.0.790
(25.02.2016)
ดีและ แอล.โอ.และ สวัสดีไบต์ต่ำและสูงจะถูกพรากไปจากผลลัพธ์นี้เพราะว่า เห็นได้ชัดว่าอาจไม่พอดีกับหนึ่งไบต์ ใน สวัสดี X (พารามิเตอร์อินพุตมาโคร) ถูกเลื่อนไปทางขวาแปดครั้ง ส่งผลให้เหลือเพียงไบต์ที่สำคัญที่สุดเท่านั้น และใน แอล.โอ.เราทำระดับบิต AND ด้วยตัวเลข 00FF ด้วยเหตุนี้จึงเหลือเพียงไบต์ต่ำเท่านั้น
“ UBRRL และ Co” ทั้งหมดนี้เป็นรีจิสเตอร์การกำหนดค่าของเครื่องส่งสัญญาณ UART ด้วยความช่วยเหลือที่เราจะสื่อสารกับโลก และตอนนี้เราได้กำหนดค่าที่ต้องการให้กับพวกเขาแล้ว โดยตั้งค่าให้เป็นความเร็วและโหมดที่ต้องการ
แถบความคืบหน้าทุกประเภทวิ่งผ่านไป สตูดิโอเปลี่ยนไปและมีลูกศรสีเหลืองปรากฏขึ้นใกล้กับทางเข้าฟังก์ชั่นหลัก นี่คือจุดที่โปรเซสเซอร์กำลังทำงานอยู่และการจำลองถูกหยุดชั่วคราว
ตอนนี้รีเซ็ตการจำลองเป็นศูนย์ คลิกที่นี่ รีเซ็ต (Shift+F5). เปิดรายการแยกชิ้นส่วน ตอนนี้คุณจะเห็นสิ่งที่เกิดขึ้นจริงในคอนโทรลเลอร์ ดู -> ถอดประกอบ. แล้วก็ไม่ใช่ YYAAAAAAA!!! ผู้ประกอบ!!! สยองขวัญ!!! และมันเป็นสิ่งจำเป็น เพื่อว่าในภายหลังเมื่อมีบางอย่างผิดพลาด คุณอย่าโง่ในโค้ดและอย่าถามคำถามงี่เง่าในฟอรัม แต่จงทำความเข้าใจในทันทีและดูว่าคุณติดขัดตรงไหน ไม่มีอะไรน่ากลัวที่นั่น 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
+00000000: 940C002A JMP 0x0000002A กระโดด +00000002: 940C0034 JMP 0x00000034 กระโดด +00000004: 940C0034 JMP 0x00000034 กระโดด +00000006: 940C0034 JMP 0x0 0000034 กระโดด +00000008: 940C0034 JMP 0x00000034 กระโดด +0000000A: 940C0034 JMP 0x00000034 กระโดด +0000000C: 940C0034 JMP 0x00000034 กระโดด + 0000000E: 940C0034 JMP 0x00000034 กระโดด +00000010: 940C0034 JMP 0x00000034 กระโดด +00000012: 940C0034 JMP 0x00000034 กระโดด +00000014: 940C0034 JMP 0x0 0000034 กระโดด +00000016: 940C0034 JMP 0x00000034 กระโดด +00000018: 940C0034 JMP 0x00000034 กระโดด +0000001A: 940C0034 JMP 0x00000034 กระโดด +0000001C : 940C0034 JMP 0x00000034 กระโดด +0000001E: 940C0034 JMP 0x00000034 กระโดด +00000020: 940C0034 JMP 0x00000034 กระโดด +00000022: 940C0034 JMP 0x000000 34 กระโดด +00000024: 940C0034 JMP 0x00000034 กระโดด +00000026: 940C0034 JMP 0x00000034 กระโดด +00000028: 940C0034 JMP 0x00000034 กระโดด
ดังนั้น หากคุณมองดู มีการเปลี่ยนแปลงอย่างต่อเนื่อง และโค้ดคำสั่ง JMP คือสี่ไบต์ โดยประกอบด้วยที่อยู่การกระโดดที่เขียนไว้ข้างหลัง - ไบต์ต่ำที่ที่อยู่ต่ำ และโค้ดคำสั่งกระโดด 940C 1
2
3
4
+0000002C: E5CF LDI R28,0x5F โหลดทันที +0000002D: E0D4 LDI R29,0x04 โหลดทันที +0000002E: BFDE OUT 0x3E,R29 ออกไปที่ตำแหน่ง I/O +0000002F: BFCD OUT 0x3D,R28 ออกไปที่ตำแหน่ง I/O
1
2
+00000041: 94F8 CLI Global Interrupt ปิดการใช้งาน +00000042: CFFF RJMP PC-0x0000 การข้ามแบบสัมพัทธ์
1
+00000034: 940C0000 JMP 0x00000000 กระโดด
1
2
3
4
5
6
7
8
9
10
11
12
< 1
2
3
+0000003E: E080 LDI R24.0x00 โหลดทันที +0000003F: E090 LDI R25.0x00 โหลดทันที +00000040: 9508 RET Subroutine return
อเล็กซี่78ฉันสร้างปลั๊กอินสำหรับ Firefox ที่ช่วยให้ใช้งานไซต์และฟอรัมของฉันได้ง่ายขึ้น
การสนทนาและการดาวน์โหลดคุณสมบัติและฟังก์ชั่นที่สำคัญ
ความต้องการพิเศษ
มีอะไรใหม่ในเวอร์ชันนี้?
