สำรวจข้อมูลเบื้องต้นเกี่ยวกับไมโครคอนโทรลเลอร์

สิ่งหนึ่งที่ยอดเยี่ยมเกี่ยวกับ IC ของไมโครคอนโทรลเลอร์มีวางจำหน่ายเกือบทั่วโลกและร้านค้าปลีกอิเล็กทรอนิกส์

บทนำ

โดยพื้นฐานแล้วอุปกรณ์ไมโครคอนโทรลเลอร์มักนิยมใช้ในแอพพลิเคชั่นที่เกี่ยวข้องกับการประเมินสภาพแวดล้อมโดยรอบและในอุปกรณ์อิเล็กทรอนิกส์ที่คล้ายคลึงกัน

คุณสามารถค้นหาอุปกรณ์เหล่านี้ที่ใช้ในการแสดงพารามิเตอร์บางอย่างในแอพพลิเคชั่นควบคุมมอเตอร์ไฟ LED เซ็นเซอร์ประเภทต่างๆเช่นเซ็นเซอร์เอียงเครื่องวัดความเร่งมาตรวัดความเร็วเครื่องบันทึกข้อมูลตัวควบคุมอุณหภูมิแป้นพิมพ์ ฯลฯ

ความเข้าใจเบื้องต้นเกี่ยวกับไมโครคอนโทรลเลอร์สามารถหาได้จากการอ้างถึงไมโครคอนโทรลเลอร์ AVR Amega32 ซึ่งก้าวหน้ามากจนบางครั้งเรียกว่าคอมพิวเตอร์ภายในชิป

อุปกรณ์นี้ได้รับมอบหมายให้ดำเนินการชุดคำสั่งเพื่อสร้างโปรแกรม

ภาษาของโปรแกรมที่คุณจะเห็นที่นี่คือ C ++ คุณจะได้เรียนรู้ภาษานี้ในเชิงลึกมากขึ้นในหลักสูตรที่นี่

เมื่อพูดถึง MCU คุณจะได้รับสิ่งอำนวยความสะดวกในการมีตัวเลือกในการควบคุมและกำหนดค่าพินเอาต์ทั้งหมด

หากคุณเริ่มเหนื่อยกับเรื่องนี้เพียงแค่ทำใจให้สบายเพราะมันไม่มีอะไรซับซ้อนเลยคุณจะผ่อนคลายในทุกแง่มุมอย่างมั่นคง แต่มั่นคงเมื่อเราก้าวไปข้างหน้า

ในชิป MCU พินทั้งหมดยกเว้น Vdd และ Vss ซึ่งเป็นพินเพาเวอร์ของชิปสามารถกำหนดได้ด้วยการกำหนดเฉพาะ

รายละเอียด Pinout

หากคุณเหลือบมองชิปจากด้านบนคุณจะพบรอยบากรูปสามเหลี่ยมเล็ก ๆ ซึ่งระบุจุดเริ่มต้นจากจุดเริ่มต้นที่พินเอาต์ซึ่งนับว่าพิน # 1 ของชิปเริ่มต้นที่รอยบากนี้

เริ่มต้นจากพินนี้คุณจะพบหมุด 20 พินที่ด้านล่างของด้านนั้น (ซ้าย) และอีก 20 พินที่ด้านอื่น ๆ (ขวา) จากล่างขึ้นบนทางด้านขวามือ

8 พินแรกที่เริ่มต้นจากรอยบากคือ PBO-7 ซึ่งสร้างหมุดดัชนีของ IC เนื่องจากโปรแกรมทั้งหมดที่นี่เริ่มต้นด้วยศูนย์ดัชนี

ชุดพินเอาต์ข้างต้นเรียกว่า PORT B ​​ในขณะที่มีชุดพอร์ตอื่น ๆ ที่เหมือนกันที่กำหนดให้ A ถึง D

พอร์ตเหล่านี้สามารถกำหนดให้ยอมรับและรับรู้ข้อมูลที่ป้อนที่เรียกว่า INPUT และยังส่งข้อมูลในรูปแบบที่ระบุที่เรียกว่า OUTPUT

หมุดสองตัวที่อยู่ในหมวดหมู่ทั่วไปคือหมุด (+) / (-) ซึ่งเรียกอีกอย่างว่า Vdd และ GND

อาจเห็นหมุดหนึ่งตัวจาก PORT D (PDO-6) อยู่ที่ด้านซ้ายของชิปที่บริเวณด้านล่าง

PD7 ซึ่งเป็นพิน # 7 ของ PORT D สามารถตรวจสอบได้โดยยืนอยู่คนเดียวและเริ่มต้นชุดพินทางด้านขวามือ

ตอนนี้ย้ายจากด้านขวามือของชิปที่ PORT D สิ้นสุดลง PORT C จะเริ่มนับขึ้นตามลำดับ

สิ่งเหล่านี้ทำให้เกิดหมุดที่น่าสนใจมากมายของ MCU ตั้งแต่อนาล็อกไปจนถึงดิจิตอล

หมุดเหล่านี้มีจุดเด่นที่จะกลายเป็นอินพุตตรวจจับสำหรับตรวจจับพารามิเตอร์ต่างๆผ่านขั้นตอนวงจรอะนาล็อกที่กำหนดค่าจากภายนอก

หมุดด้านบนเป็นพอร์ต A

การแปลงอนาล็อกเป็นดิจิตอลผ่านพินข้างต้นสามารถเข้าใจได้ด้วยความช่วยเหลือของตัวอย่างที่ระดับอุณหภูมิอะนาล็อกที่ตรวจพบโดยใช้เซ็นเซอร์ธรรมดาเช่นเทอร์มิสเตอร์ถูกนำไปใช้กับพิน PORT A อันใดอันหนึ่งซึ่ง MCU ยอมรับและแปลงได้ทันที เพื่อสร้างการอ่านข้อมูลดิจิทัลจากศูนย์ถึง 255 องศา F (ตัวเลข 8 บิตซึ่งสามารถอัปเกรดเพื่อให้ได้เอาต์พุต 10 บิต)

คุณสมบัติอีกประการหนึ่งที่สามารถเห็นได้ใน MCU นอกจากนี้คือพื้นที่การเขียนโปรแกรมที่มีอยู่หรือหน่วยความจำซึ่งกำหนดพื้นที่สำหรับตัวแปรและโปรแกรมที่ระบุสำหรับไมโครคอนโทรลเลอร์

นอกจากนี้ MCU ยังมีนาฬิกาในตัวที่กำหนดไว้สำหรับการนับพารามิเตอร์ที่เกี่ยวข้อง

คุณสมบัตินาฬิกาช่วยให้ MCU สามารถประยุกต์ใช้ตัวเองสำหรับกระบวนการนับต่างๆซึ่งอาจรวดเร็วในช่วงไมโครวินาทีขึ้นอยู่กับคุณสมบัติของอุปกรณ์นั้น ๆ และอาจช้าลงเมื่อมีขอบเขตที่ต้องการ

ตอนนี้คุณอาจเข้าใจแนวคิดไมโครคอนโทรลเลอร์แล้วในระดับหนึ่งและเกี่ยวกับพอร์ตและพิน

วิธีสร้างตัวเชื่อมต่อ SPI จากโปรแกรมเมอร์ไปยังไมโครคอนโทรลเลอร์

ตอนนี้ถึงเวลาที่จะเจาะลึกลงไปในหัวข้อนี้และสำรวจโลกของการเขียนโปรแกรม

ต้องบอกว่าก่อนที่จะทำตามขั้นตอนการโหลดโปรแกรมลงในชิปเราต้องหาวิธีที่เหมาะสมในการรวมตัวเชื่อมต่อ SPI (Serial Peripheral Interface) เข้ากับ MCU

อย่างไรก็ตามแม้หลังจากนี้เราก็ไม่สามารถผลัก SPI เข้าไปในพิน MCU ได้แล้วใช่ไหม เราไม่สามารถอนุญาตให้สายไฟที่ขยายจาก SPI เสียบเข้ากับบอร์ดขนมปังได้โดยตรง นอกจากนี้ยังอาจทำให้การตั้งค่าสายไฟที่เชื่อมต่อกับพินไม่ถูกต้องทำให้การเชื่อมต่อไม่ดี

ดังนั้นเพื่อที่จะทำให้สิ่งต่างๆไร้ที่ติอย่างแท้จริงเราจึงทำตามขั้นตอนบน veroboard เล็ก ๆ ซึ่งเราได้รับหมุดโลหะเชื่อมต่อที่ต้องการซึ่งเรียกว่าบัดกรี 'ส่วนหัว' ขณะนี้สามารถใช้หมุดส่วนหัวเหล่านี้สำหรับเชื่อมต่อกับขั้วต่อ SPI การเชื่อมต่อจากส่วนหัวนี้อาจถูกยกเลิกไปยังพินส่วนหัวแบบขนานอื่นซึ่งอาจใช้สำหรับการเชื่อมต่อเขียงหั่นขนม

ดังนั้นการประกอบข้างต้นจึงกลายเป็นแพลตฟอร์มเชื่อมต่อระดับกลางที่สะดวกสบายและเชื่อถือได้สำหรับ SPI ไปยัง MCU

Uptil ตอนนี้ทุกอย่างดูดีโฆษณาสมบูรณ์แบบดังนั้นเรามาดูรายได้เกี่ยวกับโปรแกรมเมอร์ที่จำเป็นระหว่างพีซีและ MCU ของคุณ

อาจมี บริษัท หลายแห่งที่ทำและขายหน่วยโปรแกรมเมอร์เหล่านี้ดังนั้นการจัดหาหน่วยเหล่านี้จึงไม่น่าจะเป็นปัญหาสำหรับคุณเช่น Adafruit Industries, USBtinyISP หรือ Sparkfun เป็นต้น

สิ่งเหล่านี้อาจดูแตกต่างไปจากประเภททั่วไปอย่างสิ้นเชิง แต่โดยพื้นฐานแล้วมีทุกอย่างเหมือนกันและเป็นไปตามกฎการเขียนโปรแกรมมาตรฐานและอาจใช้เป็นอินเทอร์เฟซระหว่างพีซีของคุณกับไมโครคอนโทรลเลอร์ AVR

อย่างไรก็ตามอย่าลืมคิดอย่างหนึ่งหากคุณใช้ MCU อื่นไม่ใช่ AVR Atmega32 คุณอาจต้องตรวจสอบโปรแกรมเมอร์ที่เข้ากันได้สำหรับชิป MCU นั้น

อาจสังเกตได้ว่าโปรแกรมเมอร์เหล่านี้ไม่กี่คนที่ใช้ไดรเวอร์ที่เหมือนกันต้องดูแลบางอย่างและเราจะเรียนรู้เพิ่มเติมเกี่ยวกับเรื่องนี้ในบทต่อ ๆ ไป

การเชื่อมต่อพีซีของคุณกับชิปไมโครคอนโทรลเลอร์เป็นพื้นฐานอย่างแท้จริงและคุณจะยินดีที่ทราบว่าขั้นตอนนี้จำเป็นสำหรับการดำเนินการนี้ง่ายเพียงใด มากดปุ่มกันทันที J

การสร้างบอร์ดอินเทอร์เฟซ SPI ที่อธิบายไว้ข้างต้นไม่ใช่เรื่องยากทั้งหมดนี้คือการทำให้เหล็กบัดกรีของคุณทำงานผ่านการเชื่อมต่อทั้งหมดในแถวส่วนหัวสองแถวที่แสดงบนบอร์ดเอนกประสงค์ขนาดเล็ก

รูปด้านบนแสดงรายละเอียดการเชื่อมต่อที่คุณจะต้องปฏิบัติตามในขณะที่เชื่อมต่อสายไฟระหว่างส่วนหัว

เพื่อให้สิ่งต่าง ๆ ง่ายขึ้นเรามาดูรายละเอียดการเชื่อมต่อต่อไปนี้สำหรับสิ่งเดียวกันโดยอ้างอิงภาพด้านบน:

หมุด SPI เริ่มจากด้านซ้ายบนไปที่“ Master IN, Slave OUT” (MISO)

SPI pin จากตรงกลางด้านซ้ายเชื่อมต่อกับเข็มนาฬิกา (SCK)

SPI พินที่ด้านล่างซ้ายจะเชื่อมต่อกับรีเซ็ต (เราจะเรียนรู้อย่างละเอียดเกี่ยวกับพินนี้ในบทแนะนำต่อไปนี้)

SPI ที่เกี่ยวข้องกับด้านล่างขวาเกี่ยวกับพิน GND ของ MCU, GND หมายถึงพินที่สร้างเส้นจ่ายเป็นศูนย์หรือรางลบ (สัมพัทธ์) ของแหล่งจ่าย

SPI สิ้นสุดจากส่วนหัวตรงกลางด้านขวาเชื่อมโยงกับพิน“ Master Out, Slave IN” (MOSI) ของ MCU

SPI ที่ออกมาจากส่วนหัวด้านขวาบนจะต่อเข้ากับ (+) ของ MCU ซึ่งค่อนข้างเห็นได้ชัดว่าเป็น Vdd หรือขาจ่ายบวกของ MCU

แค่นั้นแหละ.

เชื่อมต่อตัวเชื่อมต่อสองตัวตามที่อธิบายและบอร์ดอินเทอร์เฟซ SPI ของคุณพร้อมสำหรับการดำเนินการที่จำเป็น

สำหรับความช่วยเหลือเพิ่มเติมคุณสามารถดูรูปที่แสดงด้านบนบอร์ดอินเทอร์เฟซสุดท้ายของคุณควรมีลักษณะเช่นนี้หลังจากการเชื่อมต่อสายทั้งหมดทำได้อย่างเหมาะสมด้วยความช่วยเหลือของการสนทนาข้างต้น

ฉันหวังว่าคุณอาจสร้างอินเทอร์เฟซ SPI ตามที่อธิบายไว้ในบทช่วยสอนก่อนหน้านี้แล้วและตอนนี้ก็ถึงเวลาตรวจสอบให้แน่ใจว่าคอมพิวเตอร์ของเรายอมรับโปรแกรมเมอร์ที่เราจำเป็นต้องรวมเข้าด้วยกันระหว่างพีซีและ MCU

การสร้างรหัสโปรแกรมอย่างง่ายสำหรับ MCU

เราใช้หน่วย USBTinyISP จาก Sparkfun เพื่อเชื่อมโยงคอมพิวเตอร์กับไมโครคอนโทรลเลอร์

เราทราบดีว่าระบบปฏิบัติการคอมพิวเตอร์ใด ๆ เช่น Windows จะต้องใช้ไดรเวอร์โดยที่มันจะไม่มีประโยชน์ในการโหลดอะไรลงในคอมพิวเตอร์ดังนั้นโปรแกรมเมอร์ของเราจึงจำเป็นต้องมีไดรเวอร์เพื่อโหลดลงในคอมพิวเตอร์ของคุณ

มาดูขั้นตอนที่จำเป็นสำหรับการติดตั้งไดรเวอร์ในระบบปฏิบัติการคอมพิวเตอร์ของคุณที่นี่เราจะนำตัวอย่างของระบบปฏิบัติการ Windows 7 ที่มีข้อมูลจำเพาะ 32 บิตหรือ 64 บิต

เปิด sparkfun.com และคลิกที่ 'หน้าโปรแกรมเมอร์ AVR กระเป๋า' ลิงก์สามารถมองเห็นได้ในหน้าเว็บ

จากนั้นค้นหา 'ไดรเวอร์ Windows' ใต้เอกสารและคลิกที่มัน

เพื่อให้มีไฟล์ pocketprog-driver.zip ในคอมพิวเตอร์ของคุณ

ไปที่คอมพิวเตอร์ของคุณค้นหาตำแหน่งดาวน์โหลดและคลายซิปไฟล์ที่ดาวน์โหลดลงในโฟลเดอร์

ในกรณีที่คอมพิวเตอร์ของคุณเป็นระบบปฏิบัติการ 64 บิตคุณจะต้องทำตามขั้นตอนเพิ่มเติมตามที่ระบุไว้ในระบบปฏิบัติการ 32 บิตคุณสามารถเริ่มการติดตั้งได้โดยตรงจากไฟล์ที่คลายซิป

สำหรับ 64 บิตให้ทำตามสิ่งเหล่านี้สำหรับ 32 บิตให้ละเว้น:

Google 'libusb sourceforge' และคลิกที่ลิงค์นี้เวอร์ชันล่าสุด

คุณจะพบไฟล์เพิ่มเติมบางไฟล์ แต่คุณสนใจที่จะค้นหาไฟล์ bib นั่นคือ libusb-win32-bin - #. #. #. #. zip

ตอนนี้ไปหาตำแหน่งดาวน์โหลดนี้ในคอมพิวเตอร์ของคุณเปิดเครื่องรูดและบันทึกไว้ในโฟลเดอร์ใดโฟลเดอร์หนึ่ง

ไปที่โฟลเดอร์นี้ไปที่โฟลเดอร์ bin แล้วไปที่โฟลเดอร์ amd64

คุณจะเห็นสองโฟลเดอร์ที่นี่: ghcalled libusb0.dll และ libusb0.sys

คุณต้องการเปลี่ยนชื่อเป็น libusb0_x64.dll และ libusb0_x64.sys

ตอนนี้คุณจะต้องคัดลอกไฟล์ด้านบนลงในโฟลเดอร์ pocketprog-driver เพียงเขียนทับไฟล์ในเวอร์ชันที่มีอยู่

ในการติดตั้งไดรเวอร์ข้างต้นวิธีการต่อไปนี้ซึ่งค่อนข้างไม่ธรรมดาในประเภทของมันจะทำให้คุณสนใจ:

เป็นโหมด 'เพิ่มฮาร์ดแวร์เดิม'

คลิกที่ 'เมนูเริ่ม'

จากนั้นดำเนินการต่อโดยคลิกขวาที่ 'คอมพิวเตอร์'

คลิกที่ 'จัดการ' และสุดท้ายคลิกที่ 'ตัวจัดการอุปกรณ์'

จากนั้นภายในเมนูให้เลือก“ เพิ่มฮาร์ดแวร์เดิม”

ไปที่กด“ ถัดไป” จนกระทั่งใส่ตัวช่วย

ทำตามคำแนะนำคลิกที่ 'ติดตั้งฮาร์ดแวร์ซึ่งคุณจะต้องเลือกจากรายการขั้นสูง' ซึ่งจะแจ้งไอคอนปุ่มตัวเลือกในการเลือกนั้น ๆ จริงๆแล้วมันเป็นปุ่มควบคุมของหน้าต่างที่ตอนนี้จะดูเหมือนวงกลมเล็ก ๆ ที่มีแฟ้มสีฟ้ากลมอยู่ข้างใน

ตอนนี้เพียงคลิก 'ถัดไป'

ซึ่งจะแสดงเมนู 'แสดงอุปกรณ์ทั้งหมด' ซึ่งคุณจะต้องคลิก

หลังจากนี้ให้คลิกที่ไอคอน 'Have Disk'

ด้วยความช่วยเหลือของไอคอน 'เรียกดู' ไปที่ตำแหน่งของโฟลเดอร์ pocketprog-driver หากคุณทำการเลือกอย่างถูกต้องคุณจะเห็นภาพไฟล์ pocketprog.inf ที่อยู่ในโฟลเดอร์นั้น ๆ

ดับเบิลคลิกที่ไฟล์นี้และคุณจะได้เห็นไดรเวอร์ที่ติดตั้งลงในพีซีของคุณอย่างแน่นอน

เกินห้ามใจ !! มาดูบทแนะนำต่อไปในหน้าถัดไป

ตอนนี้คุณอาจติดตั้งซอฟต์แวร์ที่จำเป็นและสร้างอินเทอร์เฟซ SPI

วิธีการโอนโปรแกรมไปยังชิปไมโครคอนโทรลเลอร์

ขั้นตอนต่อไปจะเรียกใช้ส่วนประกอบบางอย่างเช่นเขียงหั่นขนม LED และตัวต้านทานที่คำนวณได้สำหรับแอปพลิเคชันที่ต้องการ

ในส่วนนี้เราจะเรียนรู้วิธีการทดสอบของโปรแกรมเมอร์และยืนยันการติดตั้งไดรเวอร์และซอฟต์แวร์ที่เกี่ยวข้อง

เพื่อตรวจสอบว่าไดรเวอร์และซอฟต์แวร์ได้รับการติดตั้งอย่างถูกต้องหรือไม่เราจะใช้โปรแกรมง่ายๆที่เรียกว่า avrdude

AVRdude เป็นโปรแกรมที่เกี่ยวข้องกับการติดตั้ง WinAVR ล่าสุดโดยที่ไม่สามารถถ่ายโอนไฟล์ไปยัง MCU ได้จริง

โปรแกรมนี้เป็นรูปแบบไฟล์. hex ซึ่งโดยพื้นฐานแล้ว MCU จะเข้าใจได้สำหรับการดำเนินการที่จำเป็น

ในกรณีที่การตรวจสอบไม่สำเร็จโปรแกรมเมอร์จะไม่สามารถทำการโอนไฟล์ได้

มาดูกันอย่างรวดเร็วว่าเราจะใช้ขั้นตอนการทดสอบได้อย่างไรโดยใช้คำแนะนำต่อไปนี้:

เปิดพรอมต์ DOS (ระบบปฏิบัติการดิสก์) โดยคลิก 'เมนูเริ่ม' และพิมพ์ cmd.exe ในช่องค้นหาที่กำหนด

ตอนนี้การดำเนินการ AVRdude สามารถทำได้โดยเพียงพิมพ์ avrdude –c usbtiny –p m32 บนข้อความแจ้ง DOS ทันทีที่ดำเนินการนี้ DOS จะรับทราบทันทีว่าการเชื่อมต่อสำเร็จหรือไม่

ในคำสั่งด้านบน“ -c” คือแฟล็กการแจ้งเตือนซึ่งรวมถึงข้อกำหนดพารามิเตอร์โปรแกรมเมอร์“ usbtiny” ในขณะที่แท็ก“ -p” ระบุอุปกรณ์ไมโครคอนโทรลเลอร์ (“ m32 ระบุ Atmega32)

ในกรณีที่คุณใช้ MCU อื่นคุณจะต้องใส่คำนำหน้าที่เกี่ยวข้องสำหรับการใช้งาน

เมื่อขั้นตอนข้างต้นเสร็จสิ้นคุณสามารถพิมพ์ 'exit' บนพรอมต์ DOS และจะย้ายคุณออกจากหน้าต่าง

หากคุณสงสัยอย่างจริงจังเกี่ยวกับรายละเอียดการเขียนโปรแกรมจริงเราจำเป็นต้องทำการบัดกรีและสร้างวงจร LED อะนาล็อกภายนอกซึ่งโปรแกรมสามารถนำไปใช้งานได้ก่อนเพราะหากไม่มีระบบรับทราบการตอบสนองจาก MCU การเขียนโปรแกรม และการทำงานของไมโครคอนโทรลเลอร์จะค่อนข้างไร้ความหมาย

การทำบอร์ด LED นั้นง่ายมากเพียงแค่บัดกรีตะกั่วทั้งสองข้างของ LED เข้ากับชิ้นส่วนของ veroboard และเชื่อมต่อตัวต้านทานกับตะกั่วตัวใดตัวหนึ่งของ LED บทบาทของ LED นี้เป็นเพียงการ จำกัด กระแสให้กับ LED เพื่อไม่ให้เกิดการไหม้เนื่องจากกระแสโฆษณาแรงดันไฟฟ้าเกินจากเอาต์พุต MCU

ค่าของตัวต้านทานสามารถคำนวณได้โดยใช้สูตรง่ายๆต่อไปนี้:

R = (Ub - LEDfwd) / I

โดยที่ Ub คือแรงดันไฟฟ้า LEDfwd คือแรงดันไฟฟ้าที่เหมาะสมที่สุดของ LED ที่ใช้และฉันคือแอมป์ที่เหมาะสมที่สุด

สมมติว่าเราใช้ LED สีแดงซึ่งมีแรงดันไฟ LED ไปข้างหน้า = 2.5V และกระแส I = 20mA สมการข้างต้นสามารถแก้ไขได้ดังนี้:

เนื่องจากแรงดันไฟฟ้าจาก MCU จะเป็น 5V จึงอาจแสดงเป็น:

R = (5 - 2.5) / 02 = 125 โอห์ม¼วัตต์ค่าที่ใกล้ที่สุดคือ 120 โอห์มจะทำ

ตอนนี้เรามี LED ตัวต้านทาน 120 โอห์มและ veroboard เพียงแค่เชื่อมต่อส่วนประกอบด้านบนตามที่ระบุในแผนภาพกับไมโครคอนโทรลเลอร์

เมื่อเสร็จแล้ว MCU สามารถตั้งโปรแกรมสำหรับการตอบสนองที่ตั้งใจไว้ในการตั้งค่า LED ด้านบน

ถัดไปการเขียนโปรแกรมของ MCU

เพื่อให้ไมโครคอนโทรลเลอร์สามารถดำเนินการใช้งานที่มีความหมายได้จำเป็นต้องเขียนคำแนะนำที่เหมาะสมลงใน MCU

วิธีติดตั้งสภาพแวดล้อมการเขียนโปรแกรมและตรวจสอบ WinAVR

สำหรับสิ่งนี้เราอาจใช้ 'โปรแกรมแก้ไขข้อความ' ของเราเองในพีซีของเราแม้ว่าพวกเราอาจจะชอบการใช้ 'สภาพแวดล้อมการเขียนโปรแกรม' ที่เป็นมืออาชีพมากขึ้นแทนที่จะใช้โปรแกรมแก้ไขข้อความธรรมดา แต่วิธีนี้จะช่วยให้คุณเพลิดเพลินไปกับ คุณลักษณะที่น่าสนใจในตัวภายในแพ็คเกจ 'สภาพแวดล้อมการเขียนโปรแกรม' นี้

มันจะรองรับการสร้างและแก้ไขโปรแกรมผ่านภาษาต่างๆและยังรวบรวมไว้ในโหมดส่งมอบที่เข้าใจง่ายและยอมรับโดยชิปไมโครคอนโทรลเลอร์

ในที่สุดสิ่งนี้จะได้รับการสนับสนุนโดย WinAVR และโอนไปยังชิป MCU ที่เกี่ยวข้อง

นอกจากนี้ยังสามารถติดตั้ง WinAVR เพื่อดำเนินการอื่น ๆ อีกมากมายเช่นการแก้ไขปัญหาโปรแกรมและเตือนเราเกี่ยวกับไวยากรณ์ที่เป็นไปได้และการรวบรวมข้อผิดพลาดและข้อผิดพลาด เราจะพูดถึงบทแนะนำในภายหลังของเรา

คุณจะต้องดำเนินการติดตั้ง WinAVR ให้เร็วและเร็วมาก มาเจาะลึกรายละเอียดด้วยประเด็นต่อไปนี้:

คุณจะต้องดาวน์โหลดเวอร์ชันล่าสุดจากโฟลเดอร์ WinAVR source forge files คุณจะพบข้อมูลที่เป็นประโยชน์เกี่ยวกับการดาวน์โหลดนี้จากเว็บไซต์อย่างเป็นทางการ

คุณจะได้รับแจ้งจากแบบสอบถามความปลอดภัยเพื่อให้คุณสามารถตอบได้ว่าคุณต้องการให้ดาวน์โหลดหรือไม่สิ่งนี้ถูกสอบถามว่าไฟล์ที่จะดาวน์โหลดเป็นไฟล์ปฏิบัติการ

ดาวน์โหลดไฟล์และเริ่มกระบวนการดำเนินการโดยคลิกที่ไฟล์ เริ่มการติดตั้ง

กระบวนการนี้จะแนะนำคุณด้วยคำถามที่สามารถตอบได้เพื่อให้คุณสามารถปรับปรุงการติดตั้งได้ตามความสะดวกของคุณ คุณต้องการละเว้นสิ่งเหล่านี้เป็นรูปแบบเริ่มต้นทั้งหมดนี้ขึ้นอยู่กับคุณที่จะเลือกรูปแบบที่คุณรู้สึกว่าเหมาะสมที่สุดสำหรับการกระทำ

จนถึงตอนนี้คุณจะพบว่าทุกอย่างค่อนข้างปกติและง่ายไปและพบกับตัวเลือกสองสามอย่างที่เมนูเริ่มต้นถูกโยนมาที่คุณ ไม่ต้องกังวลมีเพียงบางส่วนเท่านั้นที่ใช้ tem ชื่อ 'โปรแกรมเมอร์ notepad' เพียงตัวเดียว

เมื่อคลิกที่ไอคอนนี้จะเริ่มต้นอินเทอร์เฟซผู้ใช้เพื่อให้คุณสามารถใช้การเขียนโปรแกรม (เช่นการสร้างและแก้ไข) นอกจากนี้คุณยังจะได้เห็นโปรแกรมที่ประกอบด้วยคำสั่งเมนูเพื่อช่วยให้คุณรวบรวมรหัสและฝังลงในไมโครคอนโทรลเลอร์

งานพื้นฐานของ notepad โปรแกรมเมอร์ข้างต้นคือการแปลงรหัสที่มนุษย์อ่านได้ซึ่งคุณจะเขียนเป็นชุดคำสั่งที่เข้าใจได้เฉพาะกับ MCU เท่านั้น

บทช่วยสอนถัดไปจะกล่าวถึงการทดสอบโปรแกรมเมอร์ข้างต้นเพื่อให้เรามั่นใจได้ว่ามันเข้ากันได้กับ Windows หรือไม่และ 'จับมือ' กับไมโครคอนโทรลเลอร์ IC ของคุณหรือไม่

วิธีการตั้งโปรแกรม MCU สำหรับการเปิดไฟ LED

เมื่อสิ่งนี้ได้รับการยืนยันแล้วเราจะดำเนินการต่อเพื่อสร้างโค้ด 'ไม่ต้องทำอะไร' เล็ก ๆ เพียงเพื่อให้แน่ใจว่าขั้นตอนการถ่ายโอนรหัสไม่พบข้อผิดพลาด

แน่นอนว่าตอนนี้เราพร้อมที่จะใช้โปรแกรมแรกของเราใน MCU แล้ว แต่ก่อนหน้านั้นการสรุปสิ่งที่เราทำในบทเรียนก่อนหน้านี้เป็นเรื่องน่าสนใจ:

เราจัดหาไมโครคอนโทรลเลอร์ AVR Atmel ตามข้อกำหนดที่จำเป็นของเราที่นี่เราได้ใช้ ATMega32 สำหรับภาพประกอบต่อไปเราได้เรียนรู้เกี่ยวกับพื้นฐานไมโครคอนโทรลเลอร์และหน่วยโปรแกรมเมอร์ซึ่งมีหน้าที่ในการถ่ายโอนโปรแกรมไปยังชิป MCU

นอกจากนี้เราได้สร้างตัวเชื่อมต่ออินเทอร์เฟซ SP ซึ่งเป็นสิ่งจำเป็นเพื่อให้คอมพิวเตอร์ของคุณสามารถเชื่อมโยงกับไมโครคอนโทรลเลอร์สำหรับการดำเนินการเขียนโปรแกรม

หลังจากนี้เรายืนยันว่ามีการติดตั้งไดรเวอร์อย่างถูกต้องในคอมพิวเตอร์สำหรับระบบปฏิบัติการ 32 บิตและ 64 แต่หรือไม่

ต่อไปเราได้ติดตั้งสภาพแวดล้อมการเขียนโปรแกรมที่เรียกว่า Win AVR เพื่ออำนวยความสะดวกในการเขียนโฆษณาโอนรหัสไปยังไมโครคอนโทรลเลอร์ตามด้วยการใช้ avrdude สำหรับการตรวจสอบโปรแกรมเมอร์กับพีซีของคุณและไมโครคอนโทรลเลอร์ที่เชื่อมต่อกัน

สุดท้ายในบทที่แล้วเราสร้างวงจร LED / ตัวต้านทานเสร็จแล้วและเชื่อมต่อกับเอาต์พุต MCU ที่เกี่ยวข้อง

นั่นเป็นงานที่ต้องทำมากมาย แต่ถึงเวลาแล้วที่จะมุ่งหน้าไปสู่การเขียนโปรแกรมที่แท้จริงได้ทันที!

ในการเริ่มต้นเราต้องการแบ่งไมโครคอนโทรลเลอร์ออกเป็นสามประเภทซึ่งจะทำให้ความเข้าใจของเราง่ายขึ้นมาก:

การควบคุมการตรวจจับและการสื่อสาร

เป็นเรื่องน่าสนใจที่ทราบว่าฟังก์ชันข้างต้นสามารถตั้งโปรแกรมได้หลายวิธี

ในโปรแกรมแรกของเราเราจะพยายามสั่งให้ไมโครคอนโทรลเลอร์ 'ควบคุม' พารามิเตอร์ภายนอกใช่คุณคิดถูกแล้วว่าจะเป็น LED ที่เราสร้างขึ้นเมื่อไม่นานมานี้

เพื่อความแม่นยำเราจะบอกให้ MCU เปิดไฟ LED ที่เชื่อมต่อ แต่ฉันรู้ว่านี่ดูค่อนข้างดั้งเดิม แต่ระยะเริ่มต้นจะต้องง่ายเสมอ

การก้าวไปข้างหน้ากับงานปัจจุบันการควบคุม MCU LED นั้นค่อนข้างง่าย:

สำหรับสิ่งนี้เราสั่งให้พิน # 0 บน PORT B ​​สร้าง 5V ที่ต้องการสำหรับ LED

จำจากบทช่วยสอนก่อนหน้านี้เราเชื่อมต่อขั้วบวกของ LED เข้ากับพินที่กล่าวถึงข้างต้นของ MCU

มีสิ่งสำคัญสองอย่างที่ต้องระบุกับพินนี้ของ MCU: 1) เอาต์พุตและ 2) 5 โวลต์

เราจะเรียนรู้วิธีที่เราสั่งให้พินนั้นกลายเป็นเอาต์พุตของ MCU

เมื่อตั้งค่าเป็นเอาต์พุตของชิปแล้วเราอาจสั่งให้เป็น 'สูง' (5V) หรือ 'ต่ำ' (0V) ตามที่ต้องการสำหรับแอปพลิเคชัน

เนื่องจากวงจรลอจิกใด ๆ เช่น MCU พินอาจเป็นเอาต์พุตหรืออินพุตและสามารถกำหนดค่าให้สร้างลอจิกสูงหรือลอจิกต่ำพินจะต้องได้รับการกำหนดให้เป็นตรรกะสูงหรือต่ำแบบลอจิกเท่านั้น ไม่มีสถานะระดับกลางหรือไม่ได้กำหนดไว้นอกเหนือจากสองสถานะเหล่านี้สำหรับไมโครคอนโทรลเลอร์หรือสำหรับ IC ดิจิทัลใด ๆ สำหรับเรื่องนั้น เช่นเดียวกันกับแต่ละพินของ MCU

สำหรับการกำหนดพินอินพุตและเอาต์พุตอินพุตจะอยู่ในตำแหน่งเพื่อรับสัญญาณจากสเตจอะนาล็อกภายนอกในขณะที่เอาต์พุตจะรับผิดชอบในการตีความสิ่งเหล่านี้ให้เป็นสถานะตรรกะที่ระบุหรือความถี่

แม้ว่าการมอบหมายข้างต้นสามารถทำได้หลายวิธี แต่เราจะพูดถึงหนึ่งในนั้นเพื่อความเรียบง่าย อย่างไรก็ตามต้องสังเกตว่าแม้ว่าสิ่งที่จะนำเสนอในตอนนี้จะดูง่ายและน่าสนใจ แต่ก็ไม่สามารถใช้งานได้และไม่ใช่ประเภทที่แนะนำสำหรับแอปพลิเคชัน MCU ทั้งหมดด้วยเหตุผลเดียวกับที่คุณจะได้รับการแนะนำให้รู้จักกับวิธีการเขียนโปรแกรมยอดนิยมในภายหลังในหลักสูตร . โปรแกรมเหล่านี้จะอนุญาตให้กำหนดเฉพาะพินที่ต้องการตามข้อกำหนดโดยไม่ส่งผลกระทบต่อการเชื่อมต่ออื่น ๆ ซึ่งอาจถูกกำหนดให้ทำหน้าที่อื่นอยู่แล้ว

อย่างไรก็ตามตอนนี้เราจะไม่กังวลเกี่ยวกับพินอื่น ๆ มากนักและจะใช้เฉพาะพินที่สนใจที่เกี่ยวข้องเพื่อหลีกเลี่ยงความยุ่งยากในขอบเขตบางส่วน

สำหรับการกำหนดพินเป็นเอาต์พุตเราจำเป็นต้องใช้ Data Direction Register (DDR) หากคุณสงสัยว่าการลงทะเบียนในที่นี้หมายถึงอะไรเป็นเพียงช่องว่างใน MCU ที่ช่วยให้ไมโครคอนโทรลเลอร์ตอบสนองในลักษณะที่กำหนด

การใช้ DDR เราสามารถตั้งค่าพินเพื่อส่งข้อมูลที่เป็นเหมือน 'เอาต์พุต' หรือยอมรับข้อมูลที่อยู่ในรูปแบบของ 'อินพุต'

อย่างไรก็ตามคุณอาจสับสนเกี่ยวกับคำนี้หมายความว่าอย่างไร? ข้อมูลจะเพิ่มมิติที่สามให้กับพินซึ่งอาจถูกกำหนดให้ต่อเนื่องที่ศูนย์ลอจิก (0V) หรือลอจิกสูง (5V) แต่สัญญาณที่อาจแตกต่างกันอย่างรวดเร็วเช่นความถี่ของพัลส์ ความถี่จะมาพร้อมกับลอจิกสูงและต่ำ (5V และ 0V) ที่สั่นโดยมีช่วงเวลาหรือช่วงเวลาที่กำหนดดังนั้นจึงมีการกำหนดเวลาและอาจมีการปรับเปลี่ยนตามเวลานั่นคือเหตุผลที่เราระบุว่าเป็น 'ข้อมูล' ซึ่งหมายถึงพารามิเตอร์ที่ระบุว่า ฟังก์ชันที่สัมพันธ์กับฟังก์ชันอื่น (สถานะตรรกะและเวลา)

วิธีการหนึ่งในการกำหนด pin0 เป็นเอาต์พุตคือการเขียนโค้ดต่อไปนี้:

DDRB = 0b00000001

ในโปรแกรมข้างต้น DDRB หมายถึง Data Direction Register สำหรับ PORT B ​​0b สั่งคอมไพเลอร์เกี่ยวกับนิพจน์ไบนารีต่อไปนี้ของตัวเลขในขณะที่ '1' ที่ส่วนท้ายของนิพจน์ระบุตำแหน่งของ pin0 นั่นคือตำแหน่งในรูปแบบ ของพินแรกของ PORT B

หากคุณจำได้เราได้เรียนรู้ว่า PORT B ​​เชื่อมโยง 8 พินกับมัน (จาก 0 ถึงพิน 7) และหากคุณสังเกตเห็นว่ารหัสด้านบนมีตัวเลข 8 หลักอยู่ด้วยหมายความว่าแต่ละหลักหมายถึง 8 พินของพอร์ต B

ตอนนี้ขั้นตอนต่อไปคือกำหนด 5V ให้กับพินนี้ (pin0) อีกครั้งหลักการของการทำงานเหมือนกับ DDR ดังที่แสดงไว้ข้างต้นผ่านรหัสไบนารีต่อไปนี้:

PORTB = 0b00000001

ดังที่เห็นได้ข้อแตกต่างเพียงอย่างเดียวระหว่างรหัสข้างต้นกับรหัสก่อนหน้าคือในรหัสนี้เราได้ใช้ประโยชน์จากการลงทะเบียน PORT รีจิสเตอร์นี้จัดการเฉพาะการกำหนดพินของพอร์ตนั้น ๆ โดยเฉพาะซึ่งถูกจัดตำแหน่งไว้ใน MCU ดังนั้นจึงช่วยให้เราสามารถกำหนดโลจิกข้อมูลจริง (0 หรือ 1) สำหรับพินเหล่านั้น

ตอนนี้เราอาจสนใจที่จะพูดคุยเกี่ยวกับรายละเอียดโดยประมาณของโปรแกรมของเรา ดังที่เราทราบดีว่าโปรแกรมทั้งหมดต้องการพื้นที่เฉพาะในการเริ่มต้นการดำเนินการสิ่งนี้สามารถเปรียบเทียบได้กับพ่อครัวที่รู้ส่วนผสมทั้งหมดเกี่ยวกับสูตรเฉพาะ แต่ไม่ได้รับคำแนะนำจากที่ใดให้เริ่มต้น

ฟังก์ชัน“ main” ในที่นี้คือตำแหน่งที่โปรแกรม C / C ++ แต่ละโปรแกรมเริ่มต้นการทำงาน ดังนั้นหลักอาจถูกสร้างขึ้นเป็น:

int หลัก (โมฆะ)
{
}

อย่างไรก็ตามในการเปิดใช้งานโปรแกรมเพื่อตีความรายละเอียดการลงทะเบียน DDR และ PORT และการทำงานภายในชิป MCU จำเป็นต้องมีคำสั่งเพิ่มเติมซึ่งอาจประกอบด้วยข้อมูลทั้งหมดเกี่ยวกับ AVR MCU บางทีเราอาจต้องการเพิ่มการรวมนี้ในโปรแกรมทั้งหมดของเรา

# รวม
int หลัก (โมฆะ)
{
}

ทันทีที่การคอมไพล์เริ่มต้นขึ้นส่วนพรีโปรเซสเซอร์ของคอมไพลเลอร์จะมุ่งเน้นไปที่ไดเร็กทอรี AVR เพื่อระบุไฟล์“ io.h” ส่วนขยาย“ .h” ในที่นี้ระบุว่าเป็นไฟล์ส่วนหัวและโค้ดนี้ภายในไฟล์จะถูกนำมาใช้ที่จุดเริ่มต้น (ส่วนหัว) ของไฟล์ต้นฉบับที่สร้างขึ้นดังนั้นชื่อ“ ส่วนหัว”

ที่นี่เราสามารถแนะนำคำสั่ง DDR และ PORT ในโค้ดของเราได้เนื่องจากการเพิ่มไฟล์ส่วนหัว io.h จะทำให้คอมไพเลอร์เกี่ยวข้องกับพวกเขา

# รวม

int หลัก (โมฆะ)

{

DDRB = 0b00000001 // ทิศทางข้อมูลลงทะเบียนการตั้งค่า pin0 เพื่อเอาท์พุทและพินที่เหลือเป็นอินพุต

PORTB = 0b00000001 // ตั้งค่า pin0 เป็น 5 โวลต์

}

ข้างต้นแก้ไขการวางแนวของ pin0 เป็นเอาต์พุตโดยมีขนาด 5V อย่างไรก็ตามยังมีปัญหาหนึ่งที่ไม่ได้ระบุไว้สำหรับพินนี้นั่นคือพินนี้ยังไม่ได้รับคำสั่งให้เปิดไปเรื่อย ๆ ตราบใดที่ MCU เปิดอยู่ ลูปข้อเสนอแนะที่ไม่มีที่สิ้นสุดนี้จะช่วยให้มั่นใจได้ว่าพินนี้จาก MCU จะไม่ปิด แต่จะดำเนินต่อไปด้วยเอาต์พุต 5V ไปเรื่อย ๆ

แม้ว่าจะมีหลายวิธีในการใช้คำสั่งลูปสำหรับพิน แต่เราจะลองใช้ลูป“ while” ที่นี่ ตามชื่อที่แนะนำลูป“ while” จะบอกไมโครคอนโทรลเลอร์ว่า“ ในขณะที่” มีพลังงานที่พร้อมใช้งานคุณต้องเปิดใช้งานต่อไปโดยใช้ 5V ที่กำหนดสำหรับพินเอาต์ที่กำหนด

# รวม

int หลัก (โมฆะ)

{

DDRB = 0b00000001 // ทิศทางข้อมูลลงทะเบียนการตั้งค่า pin0 เพื่อเอาท์พุทและพินที่เหลือเป็นอินพุต

PORTB = 0b00000001 // ตั้งค่า pin0 เป็น 5 โวลต์

ในขณะที่ (1)

{

// โค้ดจะอยู่ที่นี่หากจำเป็นต้องรันซ้ำแล้วซ้ำเล่า ... ไม่รู้จบ

}

}

คุณอาจต้องการทราบว่าที่นี่เราได้ใช้ '1' ในรูปแบบของอาร์กิวเมนต์สำหรับลูป 'while' เนื่องจากทุกอย่างยกเว้น '0' ถือได้ว่าเป็นตรรกะ 'จริง'

นั่นหมายความว่าการพิจารณาแบบวนซ้ำ“ while” จะไม่รับผิดชอบต่อสิ่งใด ๆ นอกจากตรรกะ“ จริง” ซึ่งหมายความว่าพินนั้นจะยึดกับสถานะที่ระบุไปเรื่อย ๆ

LED สามารถเห็นได้ว่าเปิดอยู่บนพินที่กำหนดอย่างถาวรตราบเท่าที่ MCU ได้รับพลังงานจาก Vdd และ Vss

ตอนนี้เรามีผลลัพธ์ที่ต้องการจะได้รับและในที่สุดก็สามารถเห็นมันเกิดขึ้นได้หลังจากทำงานหนักมามาก แต่อย่างไรก็ตามการได้เห็นผลลัพธ์อันหอมหวานจากการทำงานหนักของเรานั้นน่าพอใจมาก

ในบทช่วยสอนถัดไปเราจะเรียนรู้วิธีเพิ่มมิติข้อมูล“ เวลา” ให้กับ LED ด้านบนนั่นคือวิธีทำให้มันกะพริบตามอัตราที่กำหนด

อันที่จริงแล้วในการใช้งานข้างต้น LED จะกะพริบ แต่อัตราการวนซ้ำนั้นเร็วมากจนเกือบจะเหมือนกับการเปิดสวิตช์ถาวรบนไฟ LED

เราจะมาดูกันว่าจะเพิ่มลูปนี้ได้อย่างไรโดยมีการหน่วงเวลาตามต้องการเพื่อให้ LED กะพริบในอัตราล่าช้านั้น

วิธีสร้างไฟ LED กะพริบโดยใช้ไมโครคอนโทรลเลอร์ AVR

ในการสนทนาครั้งที่แล้วเราได้เรียนรู้วิธีการเปิดสวิตช์ LED ผ่านไมโครคอนโทรลเลอร์มันโดดเด่นไม่ใช่เหรอ? อาจจะไม่มาก!

ต่อไปนี้เราจะเรียนรู้วิธีเพิ่มสีสันให้กับการส่องสว่าง LED ด้านบนโดยการใช้ฟังก์ชันแบบสองทิศทางนั่นคือเราจะพยายามทำให้ไฟกะพริบหรือกะพริบตามความถี่หรืออัตราที่กำหนด เราจะดูว่าอัตรานี้สามารถเพิ่มหรือลดได้อย่างไรตามที่ผู้ใช้ต้องการ

มาดูเรื่องนี้กัน:

# รวม

# รวม

int หลัก (โมฆะ)

{

DDRB | = 1<< PINB0

ในขณะที่ (1)

{

PORTB ^ = 1<< PINB0

_delay_ms (100)

}

}

หากคุณรู้สึกงุนงงกับสัญลักษณ์แปลก ๆ เหล่านั้น (&, ^, | etc) ที่ใช้ในนิพจน์ข้างต้น (& ไม่มีอยู่ แต่สามารถใช้ในรหัสอื่น ๆ ที่คล้ายกันได้) นี่คือข้อมูลที่เกี่ยวข้องที่คุณสนใจที่จะรู้เกี่ยวกับสิ่งเหล่านี้ :

ประกอบด้วยอัลกอริทึมเชิงตรรกะมาตรฐานจำนวนมากเช่น AND, OR, NOT และ XOR ซึ่งโดยทั่วไปจะใช้กับโค้ดด้านบน

ฟังก์ชันเชิงตรรกะเหล่านี้โดยเฉพาะจะเปรียบเทียบสองบิต“ 1” และ“ 0” ตามตารางความจริงที่กำหนดไว้

เราจะได้แนวคิดจากการวิเคราะห์การจัดเรียงบิตต่อไปนี้:

01001011 &
10001101
เท่ากับ
00001001

ในโค้ดด้านบน & อ้างถึง AND ตามที่ใช้ในการเขียนโปรแกรม C

การอ่านแถวในแนวตั้งแสดงให้เห็นว่า 0 และ 1 เท่ากับ 0, 1 และ 0 ก็เท่ากับ 0, 0 และ 0 เท่ากับ 0, 1 และ 1 เท่ากับ 1 การอ่านก็ทำได้ง่ายเพียงแค่นั้น สิ่งเหล่านี้เป็นไปตามตารางความจริงของตัวดำเนินการ AND

หากเราประเมินตารางต่อไปนี้จะแสดงสัญลักษณ์“ |” แสดงถึงการใช้ฟังก์ชัน“ หรือ”“ |” สามารถพบได้ทางด้านซ้ายของ“ backspace” ในแป้นพิมพ์คอมพิวเตอร์ของคุณ:

01001011 |
10001101
เท่ากับ
11001111

ตารางความจริงนี้ของฟังก์ชันตรรกะ OR ระบุว่าบิต 0 หรือ 1 เท่ากับ 1, 1 หรือ 0 เท่ากับ 1, 0 หรือ 0 เท่ากับ 0 ในขณะที่ 1 หรือ 1 เท่ากับ 1

การรวมบิตต่อไปนี้ใช้สำหรับตัวดำเนินการลอจิก XOR ที่แสดงโดย ^ และอาจศึกษาได้เช่นเดียวกับที่เราทำกับตาราง AND, OR:

01001011 ^
10001101
เท่ากับ
11000110

ตอนนี้เรามาดูโปรแกรมแรกกันต่อและเรียนรู้ว่าบรรทัดต่อไปนี้หมายถึงอะไร:

# รวม

ผ่านบทช่วยสอนก่อนหน้านี้เรารู้ว่านิพจน์ทำงานอย่างไรดังนั้นเราจะไม่พูดย้ำอีกครั้ง แต่ดูเหมือนว่าจะเป็น 'รวม' ใหม่ที่แสดงโดย #include ซึ่งต้องได้รับการตรวจสอบ

ใน 'รวม' delay.h นี้ช่วยให้เรามีวิธีการใช้งานง่าย ๆ

ตามชื่อที่แสดงถึงความล่าช้า h ทำให้เราสามารถกระตุ้นให้เกิดความล่าช้าในโปรแกรมนั้น ๆ

นิพจน์ถัดไป int main (โมฆะ) สามารถละเว้นจากการสนทนาที่กำลังดำเนินอยู่ได้เนื่องจากเราได้กล่าวถึงเรื่องนี้ในโพสต์ก่อนหน้านี้แล้ว

ถัดมาคือ DDRB ที่เปลี่ยนแปลง

ต่อไปนี้แสดงรูปแบบก่อนหน้านี้ซึ่งไม่ใช่วิธีที่ดีกว่าในการกำหนดพินเนื่องจากพินทั้งหมดจาก 0 ถึง 7 ถูกเปลี่ยนเป็นรูปแบบอินพุต แต่ลองนึกดูว่าจะเป็นอย่างไรหากเราต้องการสร้างโปรแกรมที่ยาวขึ้นซึ่งต้องใช้พินเหล่านั้นสำหรับฟังก์ชันอื่น ๆ ตัวอย่างเช่น pin2 อาจจำเป็นสำหรับการใช้การสลับระยะไกลของอุปกรณ์ ในกรณีนี้เราจะไม่ยินดีที่จะมอบหมายสิ่งเดียวกับอินพุตผ่านการลองผิดลองถูก นั่นอาจหมายถึงการตอบสนองที่ไม่ถูกต้องจากเครื่องส่งสัญญาณระยะไกลไปยังเครื่องรับอุปกรณ์

DDRB = 0b00000001

เราต้องการสร้างอิทธิพลเพียงบิตเดียวคือ hat pin0 บิตโดยมองไปที่ฟังก์ชัน“ OR” ซึ่งสามารถดำเนินการได้ผ่านการกำบังแบบไบนารี

DDRB = DDRB | 0b00000001

ที่นี่มีมาสก์“ OR”: 0b00000001 แม้ว่าจะดูเหมือนว่าเป็นเลขฐานสองที่แท้จริง แต่ในกรณีที่ DDRB รุ่นก่อนหน้าเช่น: 0b01001010 จากนั้นใช้ OR กับสิ่งนี้ผ่านการกำบังอาจให้: 0b01001010 | 0b00000001 = 0b01001011

ความแตกต่างของผลลัพธ์ที่สามารถเห็นได้คือเฉพาะกับ pin0 ซึ่งบิตของมันเปลี่ยนไป!

การบีบอัดข้อความข้างต้นให้ดียิ่งขึ้นผ่าน C ++ ทำให้:

DDRB | = 0b00000001

อย่างไรก็ตามเราพบว่ามีมากกว่านี้ในโปรแกรมที่กำหนด แม้ว่ามันอาจจะดูถูกต้องและชัดเจน แต่เราก็ควรใช้ประโยชน์จากข้อความบางส่วนจากไฟล์ส่วนหัว io.h โดยเฉพาะอย่างยิ่งเมื่อมันถูกสร้างขึ้นโดยพื้นฐานเพื่อความสะดวกของเรา?

ดังนั้นถ้า“ DDRB | = 1<< PINBO, why it’s like that?

1<< PINBO is implemented for applying the masking effect. The “1” indicates what may be introduced inside the mask, while the < < is simply the left shift functionality. It executes exactly as it’s named, and PINBO is the number of locations that the “1” would sequence across the left hand side. To be precise PINBO may be equivalent of a 0.

ดังนั้นเราจึงเริ่มต้นด้วย 0b00000000 และใส่“ 1” เพื่อสร้าง 0b0000001 จากนั้นเราจึงโอนไปทางซ้าย 0 ตำแหน่งซึ่งจะให้ 0b00000001 ที่เหมือนกันทุกประการตามด้านบน

ตอนนี้ถ้าสมมติว่าเป็น PINB4 คำสั่งอาจแสดงเป็น 1<< PINB4. I this case the “1” would be pushed to the left 4 locations producing: 0b00010000.

ระวังเราใช้ดัชนีศูนย์หมายความว่ามีศูนย์สี่ตัวหลัง '1'

ตอนนี้ดำเนินการต่อไปยังลูป“ while” ที่เราสังเกตเห็นใน“ ลูปไม่มีที่สิ้นสุด” ก่อนหน้านี้ แต่บางทีตอนนี้เราต้องการให้ไมโครคอนโทรลเลอร์ดำเนินการตามที่ต้องการ สิ่งนี้อาจทำได้เฉพาะในลูปที่กำหนดเท่านั้น เป็นลูปที่ลำดับที่เฉพาะเจาะจงซ้ำแล้วซ้ำอีก

ในกรณีที่การดำเนินการจะถูกวางไว้ก่อนลูปจะดำเนินการเพียงครั้งเดียว

อย่างไรก็ตามในการทำให้ LED กะพริบไปเรื่อย ๆ จำเป็นต้องสลับ PINB0 สลับกันเป็นเปิด / ปิดภายในลูป นอกจากนี้เรายังพบความล่าช้าที่เกิดขึ้นโดยที่ LED ไม่กะพริบจะเป็นไปไม่ได้ แต่สิ่งนี้จะบังคับให้ LED กะพริบในอัตราที่รวดเร็วมากซึ่งยากที่จะรับรู้ด้วยตาเปล่ามันจะต้องช้าลงเล็กน้อยเพื่อให้สามารถระบุได้ด้วยตาของเรา

เราทราบขั้นตอนการตั้งค่าของบิตเฉพาะในเลขฐานสอง แต่ไม่แน่ใจว่าวิธีการใช้บิต“ 0” เฉพาะในกรณีที่เป็น“ 1”

คุณสามารถเห็นโปรแกรมต่อไปนี้ในการทำสิ่งนี้ แต่เราจะพบว่าอาจไม่ปรากฏในโปรแกรม

คำสั่งสองคำเริ่มต้นจะเปลี่ยนบิตเป็น“ 1” (5V, ไฟ LED) จากนั้นจึงมีการหยุดชั่วคราวเป็นเวลา 100 มิลลิวินาที

สองสามบรรทัดถัดไปจะเปลี่ยน PINB0 บิตเป็น“ 0” (แรงดันไฟฟ้าเป็นศูนย์ปิดไฟ LED) แต่ขออภัยการเปรียบเทียบ AND จะไม่สามารถเรียกใช้“ 0” จากบิตได้ แต่ถ้าเราใช้ NOT“ ~” สำหรับรูปแบบไบนารีสามารถเปลี่ยน 0 ทั้งหมดเป็น 1s และในทางกลับกัน

สิ่งนี้จะช่วยให้เราสามารถกำหนดเฉพาะ PINB0 บิตและพลิกเป็น“ 0” วงเล็บถูกรวมไว้เพื่อให้มีการดำเนินการกำบังเพื่อให้สามารถใช้การดำเนินการ NOT สำหรับทั้งมาสก์และไม่เพียงแค่ทับ '1' ก่อนเลื่อนไปทางซ้าย '<<”.

PORTB | = 1<< PINB0
_delay_ms (100)
PORTB & = ~ (1<< PINB0)
_delay_ms (100)

ในการสร้างความล่าช้าในการเปิดปิดหรือช่วงเวลาที่มีระยะเวลาเท่ากันเราอาจตัดสี่บรรทัดก่อนหน้าให้สั้นลงเหลือสองบรรทัดและใช้ฟังก์ชัน XOR เพื่อประโยชน์ของเรา ต้องสังเกตว่าการดำเนินการ XOR และพินที่กำหนดให้กับ 1 ในกรณีที่เป็น 0 และในทางกลับกัน การดำเนินการนี้จะมีผลกับ PINB0 เท่านั้น ในบางครั้งที่มีการใช้คำสั่งมันก็จะเปลี่ยนบิตให้ตรงข้ามกับตรรกะที่มีอยู่

PORTB ^ = 1<< PINB0
_delay_ms (100)

เสร็จ! ตอนนี้ LED ของคุณจะกะพริบตามอัตราที่ตั้งไว้…. ง่ายใช่ไหม?