- การสื่อสารแบบอนุกรมบน STM8S103F3P6
- พินการสื่อสารแบบอนุกรมบน STM8S103F3P6
- แผนภาพวงจรสำหรับการสื่อสารแบบอนุกรม STM8S
- การตั้งค่า STVD สำหรับการสื่อสารแบบอนุกรม
- การเขียนโปรแกรม STM8S สำหรับการสื่อสารแบบอนุกรม
- การควบคุม LED จากจอภาพอนุกรม
- STM8S Serial Library ดูลึกขึ้น
การเขียนโปรแกรมไมโครคอนโทรลเลอร์ใหม่มักใช้เวลานานกว่าเนื่องจากวิธีการจัดการรีจิสเตอร์ใหม่และไม่รู้ว่าบิตทำอะไรกันแน่ เช่นเดียวกับการดีบักเช่นกันโดยไม่ต้องพูด นี่คือเหตุผลที่โปรแกรมเมอร์มักใช้เบรกพอยต์ในโค้ดและทำตามขั้นตอนโดยใช้ดีบักเกอร์ แต่การใช้ดีบักเกอร์อาจต้องใช้ฮาร์ดแวร์เพิ่มเติม (ราคาแพงที่สุด) และต้องใช้เวลาเพิ่มเติมด้วย การเป็นแฟนบอย Arduino สิ่งหนึ่งที่เราทุกคนเห็นพ้องต้องกันคือการใช้คำสั่งการพิมพ์แบบอนุกรมสำหรับการดีบักและการทำความเข้าใจโค้ดของเราทำให้ชีวิตง่ายขึ้นมาก เราสามารถจำลองสิ่งเดียวกันบน STM8 ด้วยคอมไพเลอร์ C และไลบรารี SPL ได้อย่างไร มันเป็นไปได้อย่างมากและนั่นคือสิ่งที่เราจะทำในบทช่วยสอนที่สามของชุดการสอนของเรานอกจากนี้คุณยังตรวจสอบการเริ่มต้นใช้งาน STM8S (บทช่วยสอน 1) และ STM8S GPIO control (บทช่วยสอน 2) หากคุณยังใหม่อยู่ที่นี่ นอกจากนี้เรายังได้สำรวจความเป็นไปได้ของการเขียนโปรแกรม STM8S กับ Arduino สำหรับการเริ่มต้นอย่างรวดเร็ว ทั้งหมดที่กล่าวมาเข้าสู่บทช่วยสอน
การสื่อสารแบบอนุกรมบน STM8S103F3P6
จากเอกสารข้อมูลของ STM8S103F3P6 เราจะเห็นว่าคอนโทรลเลอร์ 8 บิตของเรารองรับการสื่อสาร UART ในโหมดต่างๆมากมาย คอนโทรลเลอร์ยังมีพินเอาต์พุตนาฬิกาสำหรับการสื่อสาร UART แบบซิงโครนัสและยังสามารถรองรับ SmarCard, IrDA และ LIN แต่เราจะไม่สำรวจสิ่งนั้นในบทช่วยสอนนี้เพียงเพื่อหลีกเลี่ยงความซับซ้อน เราจะเรียนรู้วิธีการอ่านและเขียน UART แบบง่ายๆ
บทช่วยสอนยังมีไฟล์ส่วนหัวที่เรียกว่า stm8s103 serial.h ซึ่งคุณสามารถใช้คำสั่ง UART ง่ายๆเช่น Serial begin, Serial read, Serial print เป็นต้นโดยทั่วไปคุณจะสามารถพิมพ์ char, int และ string ไปยังมอนิเตอร์แบบอนุกรมได้ และอ่านถ่านจากมอนิเตอร์แบบอนุกรม ในตอนท้ายของบทช่วยสอนนี้คุณจะสามารถควบคุม LED จากจอภาพอนุกรมและรับคำติชมเกี่ยวกับสถานะของ LED ได้ ไฟล์ส่วนหัวที่กล่าวถึงข้างต้นขึ้นอยู่กับไลบรารี SPL ดังนั้นอย่าลืมทำตามบทช่วยสอนการเริ่มต้นใช้งาน
พินการสื่อสารแบบอนุกรมบน STM8S103F3P6
เริ่มจากด้านฮาร์ดแวร์กันก่อน เมื่อดูพินในไมโครคอนโทรลเลอร์STM8S103F3P6อย่างรวดเร็วเราจะเห็นว่าพิน 1, 2 และ 3 จะใช้สำหรับการสื่อสาร UART
ในสามพิน 1 คือพินนาฬิกา UART ซึ่งจะใช้เฉพาะในระหว่างการสื่อสาร UART แบบซิงโครนัสดังนั้นเราจึงไม่จำเป็นต้องใช้ที่นี่ พิน 2 คือพินตัวส่งสัญญาณ UART และพิน 3 คือพินตัวรับ UART โปรดทราบว่าพินเหล่านี้สามารถเพิ่มเป็นสองเท่าเป็นพินอนาล็อกหรือพิน GPIO ปกติ
แผนภาพวงจรสำหรับการสื่อสารแบบอนุกรม STM8S
แผนภาพวงจรนั้นง่ายมากที่นี่เราต้องเชื่อมต่อ ST-LINK 2 ของเราสำหรับการเขียนโปรแกรมและตัวแปลง USB เป็น TTL เพื่ออ่านข้อมูลอนุกรม โปรดทราบว่าคอนโทรลเลอร์ STM8S ของเราทำงานในระดับลอจิก 3.3V ดังนั้นตรวจสอบให้แน่ใจว่าตัวแปลง USB เป็น TTL ของคุณรองรับลอจิก 3.3V ด้วย แผนภาพวงจรทั้งหมดแสดงด้านล่าง
คุณต้องเชื่อมต่อ ST-link ของคุณในพอร์ต USB หนึ่งพอร์ตและตัวแปลง USB เป็น TTL ในพอร์ต USB อื่นของแล็ปท็อปของคุณเพื่อให้คุณสามารถตั้งโปรแกรมและตรวจสอบข้อมูลได้ในเวลาเดียวกัน การเชื่อมต่อ UART นั้นง่ายมากเพียงแค่ต่อกราวด์และขา Rx / Tx ของไมโครคอนโทรลเลอร์ STM8S ของคุณเข้ากับพิน Tx / Rx ของตัวแปลง USB เป็น TTL ที่นี่ฉันได้ขับเคลื่อนคอนโทรลเลอร์ด้วยพิน Vcc ของ ST-Link และเปิดพิน vss ของตัวแปลง TTL ไว้คุณสามารถทำสิ่งนี้ได้ในทางกลับกัน มีตัวแปลง USB เป็น TTL หลายประเภทในตลาดเพียงตรวจสอบให้แน่ใจว่าสามารถทำงานบนสัญญาณลอจิก 3.3V และมองหาพิน Tx, Rx และ GND อย่างง่ายและทำการเชื่อมต่อตามที่แสดงด้านบน การตั้งค่าฮาร์ดแวร์ของฉันแสดงอยู่ด้านล่าง
ในการสร้างวิธีการสื่อสารแบบอนุกรมเราได้จัดเตรียมไฟล์ส่วนหัว STM8S_Serial.h เมื่อใช้ไฟล์ส่วนหัวนี้คุณสามารถใช้งาน Arduino ง่ายๆเช่นฟังก์ชันสำหรับการสื่อสารแบบอนุกรม
คุณสามารถค้นหาไฟล์ที่จำเป็นทั้งหมดสำหรับโปรเจ็กต์นี้ได้ในหน้า STM8S103F3_SPL Github ของเรา หากคุณต้องการเฉพาะไฟล์ส่วนหัวนี้คุณสามารถดาวน์โหลดได้จากลิงค์ด้านล่าง
ดาวน์โหลด STM8S_Serial.h
การตั้งค่า STVD สำหรับการสื่อสารแบบอนุกรม
ในการทำงานกับการสื่อสารแบบอนุกรมเราจะใช้หลาย ๆไฟล์โดยใช้ฟังก์ชันไฟล์ส่วนหัว STM8S_Serial.h ที่เราพูดถึงก่อนหน้านี้ แต่ไลบรารีมีการอ้างอิงอื่น ๆ ส่วนหัวที่เกี่ยวข้องกับ SPL UART และ Clock และไฟล์ C จำนวนมาก ดังนั้นจากจุดนี้จึงเป็นการดีกว่าที่จะรวมส่วนหัวและไฟล์ C ทั้งหมดไว้ในโครงการของเราเพื่อหลีกเลี่ยงข้อผิดพลาดในการคอมไพล์ สภาพแวดล้อมการทำงาน STVD ของฉันมีลักษณะเช่นนี้
ตรวจสอบให้แน่ใจว่าคุณได้รวมไฟล์ที่มา SPL ทั้งหมดและรวมไฟล์เหมือนที่เราทำในบทช่วยสอนแรกของเรา และตรวจสอบให้แน่ใจว่าคุณได้เพิ่มไฟล์ส่วนหัว stm8s103_serial.h แล้ว ไม่มีไฟล์ C สำหรับส่วนหัวนี้
การเขียนโปรแกรม STM8S สำหรับการสื่อสารแบบอนุกรม
เมื่อการตั้งค่าโครงการ STVD พร้อมแล้วเราสามารถเริ่มเขียนโค้ดของเราในไฟล์ main.c คุณสามารถดูโค้ดทั้งหมดของบทช่วยสอนนี้ได้ที่ด้านล่างของหน้านี้ คำอธิบายดังนี้.
ขั้นตอนแรกคือการรวมไฟล์ส่วนหัวที่จำเป็นที่นี่ฉันได้เพิ่มไฟล์ส่วนหัวหลัก (stm8s) และไฟล์ส่วนหัว stm8s_103_serial ที่เราเพิ่งดาวน์โหลด
// ส่วนหัวที่จำเป็น #include "STM8S.h" #include "stm8s103_serial.h" //https://github.com/CircuitDigest/STM8S103F3_SPL/blob/master/stm8s103%20Libraries/stm8s103_Serial.h
ต่อไปเราจะใช้มาโครการออกแบบเพื่อระบุพินอินพุตและเอาต์พุต ที่นี่ที่เดียวจะได้รับการควบคุมไฟ LED บนกระดานที่เชื่อมต่อกับพอร์ต pin5 B ดังนั้นเราจึงให้ชื่อเป็นtest_LED
#define test_LED GPIOB, GPIO_PIN_5 // ไฟ LED ทดสอบเชื่อมต่อกับ PB5
เราจะกำหนดพินเป็นเอาต์พุต หากคุณไม่คุ้นเคยกับฟังก์ชั่น GPIO พื้นฐานให้กลับไปที่บทช่วยสอน STM8S GPIO
// Pin defanitions // ประกาศ PB5 เป็นพินพุชดึงขาออก GPIO_Init (test_LED, GPIO_MODE_OUT_PP_LOW_SLOW);
จากนั้นเราเริ่มต้นพอร์ตการสื่อสารแบบอนุกรมของเราที่ 9600 อัตราการส่ง สำหรับผู้ที่เป็นมือใหม่ 9600 คืออัตราความเร็วที่บิตข้อมูลจะถูกถ่ายโอนระหว่างการสื่อสาร หากคุณตั้งค่า 9600 ที่นี่คุณจะต้องตั้งค่าเดียวกันบนซอฟต์แวร์การตรวจสอบ จากนั้นเรายังพิมพ์สตริง“ Enter command” และไปยังบรรทัดถัดไป
Serial_begin (9600); // เริ่มต้นการสื่อสารแบบอนุกรมที่อัตรารับส่งข้อมูล 9600 Serial_print_string ("Enter command"); // พิมพ์สตริง Serial_newline (); // เลื่อนไปที่บรรทัดถัดไป
เมื่อย้ายไปที่ infinite while loop เราใช้ฟังก์ชัน Serial_available เพื่อตรวจสอบว่ามีข้อมูลอนุกรมที่เข้ามาหรือไม่ ถ้าใช่เราอ่านและบันทึกไว้ในตัวแปรที่เรียกว่า CH และยังพิมพ์เดียวกันโดยใช้Serial_print จากนั้นถ้าค่าที่ได้รับเป็น 0 เราจะปิด LED และถ้าเป็น 1 เราจะเปิด LED
ถ้า (Serial_available ()) {Serial_print_string ("คุณได้กด:"); ch = Serial_read_char (); Serial_print_char (ch); Serial_newline (); ถ้า (ch == '0') GPIO_WriteHigh (test_LED); // LED OFF ถ้า (ch == '1') GPIO_WriteLow (test_LED); // LED ON}
ด้วยเหตุนี้การเขียนโปรแกรมสำหรับบทช่วยสอนนี้จึงเสร็จสมบูรณ์เพียงแค่อัปโหลดรหัสที่ให้ไว้ที่ด้านล่างของหน้านี้และคุณจะสามารถควบคุม LED จากจอภาพแบบอนุกรมได้
การควบคุม LED จากจอภาพอนุกรม
เมื่อคุณอัปโหลดรหัสแล้วคุณสามารถเปิดจอภาพแบบอนุกรมใดก็ได้ที่อัตรารับส่งข้อมูล 9600 ฉันใช้ Arduino serial monitor เพื่อความสะดวกในการใช้งาน กดปุ่มรีเซ็ตและคุณจะเห็นข้อความ "ป้อนคำสั่ง" จากนั้นถ้าคุณป้อน 1 และกด Enter ไฟ LED ออนบอร์ดควรเปิดขึ้นในทำนองเดียวกันสำหรับ 0 ก็ควรปิด
การทำงานทั้งหมดสามารถพบได้ในวิดีโอที่เชื่อมโยงที่ด้านล่างของหน้านี้ หากคุณมีคำถามใด ๆ โปรดทิ้งไว้ในส่วนความคิดเห็น คุณยังสามารถใช้ฟอรัมของเราเพื่อโพสต์คำถามทางเทคนิคอื่น ๆ
STM8S Serial Library ดูลึกขึ้น
สำหรับคนที่อยากรู้อยากเห็นที่อยากรู้ว่าเกิดอะไรขึ้นในไฟล์ส่วนหัว STM8S103F3_Serial อ่านต่อ….
ไฟล์ส่วนหัวนี้ใช้งานได้ดีสำหรับการเขียนโปรแกรมระดับเริ่มต้น แต่ถ้าคุณใช้คอนโทรลเลอร์ STM8S เวอร์ชันอื่นหรือกำลังมองหาตัวเลือกขั้นสูงคุณอาจต้องการปรับแต่งส่วนหัวนี้เล็กน้อยหรือทำงานโดยตรงกับไลบรารี SPL ฉันเขียนไฟล์ส่วนหัวนี้เช่นเดียวกับที่สุกจากไฟล์ส่วนหัว UART1 คำอธิบายของไฟล์ส่วนหัวของฉันมีดังนี้
การอ่านอักขระจาก Serial Monitor
ฟังก์ชันนี้ช่วยในการอ่านอักขระเดี่ยวที่ถูกส่งไปยังไมโครคอนโทรลเลอร์จากจอภาพอนุกรม
ถ่าน Serial_read_char (โมฆะ) {while (UART1_GetFlagStatus (UART1_FLAG_RXE) == RESET); UART1_ClearFlag (UART1_FLAG_RXNE); กลับ (UART1_ReceiveData8 ()); }
เรารอจนกว่าค่าสถานะ RXE จะถูก SET เพื่อทำการรับสัญญาณให้เสร็จสิ้นจากนั้นจึงล้างแฟล็กเพื่อรับทราบการรับ สุดท้ายเราส่งข้อมูล 8 บิตที่ได้รับอันเป็นผลมาจากฟังก์ชันนี้
การพิมพ์อักขระไปยัง Serial Monitor
ฟังก์ชั่นนี้จะส่งอักขระเดียวจากไมโครคอนโทรลเลอร์ไปยังจอภาพอนุกรม
โมฆะ Serial_print_char (ค่าถ่าน) {UART1_SendData8 (ค่า); ในขณะที่ (UART1_GetFlagStatus (UART1_FLAG_TXE) == RESET); // รอส่ง}
ฟังก์ชั่นเพียงแค่เขียนค่า 8 บิตและรอจนกว่าการส่งจะเสร็จสมบูรณ์โดยตรวจสอบ UART1_FLAG_TXE ไปยัง SET
การเริ่มต้นการสื่อสารแบบอนุกรม
ฟังก์ชันนี้เริ่มต้นการสื่อสารแบบอนุกรมตามอัตราการส่งข้อมูลที่ต้องการ
เป็นโมฆะ Serial_begin (uint32_t baud_rate) {GPIO_Init (GPIOD, GPIO_PIN_5, GPIO_MODE_OUT_PP_HIGH_FAST); GPIO_Init (GPIOD, GPIO_PIN_6, GPIO_MODE_IN_PU_NO_IT); UART1_DeInit (); // Deinitialize อุปกรณ์ต่อพ่วง UART UART1_Init (baud_rate, UART1_WORDLENGTH_8D, UART1_STOPBITS_1, UART1_PARITY_NO, UART1_SYNCMODE_CLOCK_DISABLE, UART1_MODE_TXRX_ENABLE); // (BaudRate, Wordlegth, StopBits, Parity, SyncMode, Mode) UART1_Cmd (ENABLE); }
นอกเหนือจากอัตราการส่งข้อมูลแล้วยังมีพารามิเตอร์อื่น ๆ ที่ต้องตั้งค่าสำหรับการสื่อสารแบบอนุกรมเช่นจำนวนบิตข้อมูลจำนวนบิตหยุดความเท่าเทียมกัน ฯลฯ ที่พบมากที่สุด (คล้ายกับ Arduino) คือข้อมูล 8 บิต ด้วยบิตหยุดเดียวและไม่มีความเท่าเทียมกันและด้วยเหตุนี้จะเป็นการตั้งค่าเริ่มต้น คุณสามารถเปลี่ยนแปลงได้หากจำเป็น
การพิมพ์จำนวนเต็มไปยัง Serial Monitor
โดยส่วนใหญ่ถ้าเราใช้ซีเรียลมอนิเตอร์สำหรับการดีบักหรือมอนิเตอร์เราอาจต้องการพิมพ์ตัวแปรประเภท int ไปยังมอนิเตอร์อนุกรม ฟังก์ชันนี้ทำอย่างนั้น
เป็นโมฆะ Serial_print_int (หมายเลข int) // Funtion เพื่อพิมพ์ค่า int ไปยังมอนิเตอร์แบบอนุกรม {char count = 0; ถ่านหลัก = ""; ในขณะที่ (number! = 0) // แบ่ง int ไปยังอาร์เรย์ถ่าน {digit = number% 10; นับ ++; number = จำนวน / 10; } while (count! = 0) // พิมพ์อาร์เรย์ถ่านในทิศทางที่ถูกต้อง {UART1_SendData8 (หลัก + 0x30); ในขณะที่ (UART1_GetFlagStatus (UART1_FLAG_TXE) == RESET); // รอส่งนับ -; }}
ใช้ค่าจำนวนเต็มและแปลงเป็นอาร์เรย์อักขระใน while loop แรกจากนั้นในขณะที่วนซ้ำเราจะส่งอักขระแต่ละตัวที่คล้ายกับฟังก์ชัน print char ของเรา
กำลังพิมพ์บรรทัดใหม่
นี่เป็นฟังก์ชันง่ายๆในการพิมพ์บรรทัดใหม่ ค่าฐานสิบหกที่ต้องทำคือ“ 0x0a” เราแค่ส่งข้ามไปโดยใช้คำสั่งการส่ง 8 บิต
เป็นโมฆะ Serial_newline (โมฆะ) {UART1_SendData8 (0x0a); ในขณะที่ (UART1_GetFlagStatus (UART1_FLAG_TXE) == RESET); // รอส่ง}
การพิมพ์สตริงไปยังจอภาพอนุกรม
ฟังก์ชั่นที่มีประโยชน์อีกอย่างคือการพิมพ์สตริงบนมอนิเตอร์แบบอนุกรม
โมฆะ Serial_print_string (สายอักขระ) {. ถ่านฉัน = 0; ในขณะที่ (สตริง! = 0x00) {UART1_SendData8 (สตริง); ในขณะที่ (UART1_GetFlagStatus (UART1_FLAG_TXE) == RESET); ผม ++; }}
อีกครั้งฟังก์ชันนี้ยังแปลงสตริงเป็นอาร์เรย์ char และส่งอักขระแต่ละตัว ดังที่เราทราบดีว่าสตริงทั้งหมดจะสิ้นสุดลง ดังนั้นเราต้องข้ามและส่งอักขระไปเรื่อย ๆ จนกว่าจะถึง null 0x00
ตรวจสอบว่ามีข้อมูลอนุกรมให้อ่านหรือไม่
ฟังก์ชันนี้จะตรวจสอบว่ามีข้อมูลอนุกรมในบัฟเฟอร์พร้อมอ่านหรือไม่
bool Serial_available () {if (UART1_GetFlagStatus (UART1_FLAG_RXNE) == TRUE) ส่งคืน TRUE; อื่นส่งคืน FALSE; }
ตรวจสอบแฟ ล็ก UART1_FLAG_RXNE หากเป็นจริงจะส่งคืนค่าจริงและหากไม่เป็นเช่นนั้นจะส่งคืนค่าเท็จ