ESP32 Code Examples
ตัวอย่างโค้ดไมโครไพธอนเพื่อนำไปทดลองใช้งานกับบอร์ด ESP32
คำแนะนำ
ผู้อ่านควรมีความรู้ภาษา Python เบื้องต้น พื้นฐานอิเล็กทรอนิกส์ และการเขียนโค้ดไมโครคอนโทรลเลอร์ในระดับพื้นฐานมาบ้าง เช่น Arduino
บอร์ด ESP32 ที่เราสามารถเลือกมาใช้งานนั้น มีหลายรูปแบบ ความเหมาะสมของบอร์ดแต่ละชนิด ก็อาจแตกต่างกันไปขึ้นอยู่กับวัตถุประสงค์สำหรับการใช้งาน ดังนั้นขอแนะนำให้ใช้บอร์ดที่เสียบขา Pin Headers ลงบนเบรดบอร์ดได้ สำหรับการต่อวงจรใช้งานร่วมกับอุปกรณ์หรือวงจรอิเล็กทรอนิกส์พื้นฐานแบบต่าง ๆ
ในกรณีที่ต้องการใช้ไมโครไพธอนสำหรับ ESP32 แนะนำให้ใช้บอร์ด ESP32 ที่มีชิป PSRAM หรือเรียกว่า SPIRAM (เช่น 4MB) เพื่อเพิ่มความจุของหน่วยความจำ นอกเหนือจาก RAM ที่มีอยู่ภายในชิป ESP32 SoC
ประเด็นหนึ่งที่สำคัญเมื่อได้เลือกใช้บอร์ดไมโครคอนโทรลเลอร์ คือ การทราบตำแหน่งของขาต่าง ๆ ของบอร์ด หรือ Pin Layout (PinOut Map) แตกต่างกันไปขึ้นอยู่กับบอร์ดที่ใช้ ดังนั้นควรตรวจสอบให้ถูกต้องเมื่อนำไปต่อวงจร จะไม่ได้เกิดความผิดพลาดในการใช้งานขา GPIO หรือขาแรงดันไฟเลี้ยง (ขา 3.3V และ GND) จากบอร์ด ESP32
แหล่งข้อมูลเกี่ยวกับบอร์ด LilyGO TTGO T8 (V1.1 / V1.3 / V1.7) ที่ได้นำมาใช้งาน
TTGO-T8-ESP32 (Repository): https://github.com/LilyGO/TTGO-T8-ESP32
Schematic (PDF): https://github.com/LilyGO/TTGO-T8-ESP32/blob/master/t8_v1.7.1.pdf
โค้ดตัวอย่างที่ 1: LED Blink + Push Button (Polling)
ตัวอย่างแรกเป็นการทดลองใช้ขา GPIO ของ ESP32 เป็นเอาต์พุตหรืออินพุตแบบดิจิทัล ถ้าเป็นเอาต์พุต มีการกำหนดและเปลี่ยนสถานะค่า 0 หรือ 1 สำหรับเอาต์พุต และสลับค่าโดยเว้นระยะเวลาตามที่กำหนดไว้ ถ้านำไปขาเอาต์พุตนี้ไปต่อกับวงจร LED ก็จะทำให้มองเห็นการเปลี่ยนแปลงของสถานะลอจิกได้
อีกกรณีหนึ่งคือ การใช้ขา GPIO เป็นอินพุต ใช้ในการอ่านค่าจากวงจรปุ่มกด (Push Button) เช่น วงจรปุ่มกดที่ทำงานแบบ Active-Low คือ ถ้าไม่กดปุ่ม จะได้ค่าเป็น High (1) แต่ถ้ากดปุ่มจะได้ค่าเป็น Low (0)
คลาส Pin
จากไลบรารี machine
เกี่ยวข้องกับการใช้งาน GPIO (Digital I/O pins) ของฮาร์ดแวร์ เช่น ใช้งานเป็นขาดิจิทัล-อินพุต หรือเอาต์พุต การเปิดใช้งานขาอินพุตร่วมกับอินเทอร์รัพท์ (Interrupt) และการเปิดใช้งาน Internal Pull-Up หรือ Pull-Down สำหรับขาที่จะถูกใช้เป็นอินพุต เป็นต้น
ในตัวอย่างนี้ได้เลือกใช้ขา GPIO-21 สำหรับ LED และ GPIO-22 สำหรับปุ่มกด (ทำงานแบบ Active-Low และเปิดใช้งาน Pull-Up ภายในวงจรที่ขาดังกล่าว)
การทำงานของโปรแกรมจะทำให้ LED กระพริบ และมีการตรวจสอบสถานะอินพุตของปุ่มกด ถ้าพบว่า มีการกดปุ่ม (ได้ค่าเป็น 0) จะหยุดการทำงานของลูป while
และจบการทำงานของโปรแกรม
โค้ดตัวอย่างที่ 2: LED Blink + Push Button (Interrupt-Driven)
จากตัวอย่างที่แล้ว เราได้ใช้วิธีวนซ้ำ (Polling) เพื่อคอยอ่านค่าอินพุตจากวงจรปุ่มกด และนำค่าอินพุตที่อ่านได้ในแต่ละครั้ง มากำหนดเงื่อนไขในการหยุดหรือออกจากลูป while
ในตัวอย่างนี้ เราจะใช้วิธีที่เรียกว่า "อินเทอร์รัพท์" (Interrupt) สำหรับอินพุต-ปุ่มกด
เมื่อมีการกดปุ่ม จะเกิดการเปลี่ยนระดับลอจิก จาก High เป็น Low หรือที่เรียกว่า “ขอบขาลง” (Falling Edge) และเมื่อปล่อย จะเกิด “ขอบขาขึ้น” (Rising Edge) และอาจเกิดได้มากกว่าหนึ่งครั้ง ถ้ามีการกระเด้งของสวิตซ์ปุ่มกด (Switch Bouncing)
เราสามารถกำหนดให้ไมโครไพธอนเรียกฟังก์ชันที่เราสร้างขึ้นมา (Callback Function หรือ Interrupt Handler) เช่น ฟังก์ชัน btn_handler()
ในโค้ดตัวอย่าง ให้ทำงานโดยอัตโนมัติเมื่อเกิดเหตุการณ์ดังกล่าว เช่น ขอบขาลง ในตัวอย่างนี้จะทำให้ตัวแปรภายนอก stop
เปลี่ยนจาก False
เป็น True
ซึ่งใช้ในการตรวจสอบเงื่อนไขการออกจากลูป while
โค้ดตัวอย่างที่ 3: LED Toggle on Button Press
โค้ดตัวอย่างถัดไปสาธิตการทำให้ LED เปลี่ยนสถานะเอาต์พุตหนึ่งครั้งเมื่อมีการกดปุ่มการทำงานของโค้ดจะอาศัยการเปิดใช้งานอินเทอร์รัพท์ที่ขาอินพุต (ตรวจสอบเหตุการณ์ขอบขาลง) และมีการสร้างฟังก์ชัน btn_handler()
ให้ทำหน้าที่เป็น Callback Function
เมื่อเกิดเหตุการณ์ดังกล่าว ฟังก์ชัน btn_handler()
จะสลับสถานะของ LED หนึ่งครั้ง นอกจากนั้น ถ้ามีการกดปุ่มค้างไว้ (Long Press) ให้จบการทำงานของโปรแกรม
โค้ดตัวอย่างที่ 4: Timer-based LED Blink
ตัวอย่างถัดไปเป็นการใช้ Timer จากคลาส Timer
ในไลบรารี machine
เพื่อทำคำสั่งของฟังก์ชัน led_toggle()
ที่ทำหน้าที่เป็น Callback ตามระยะเวลาที่กำหนด (Periodic Mode) เช่น ทุก ๆ 500 มิลลิวินาที โดยอัตโนมัติ และทำให้เกิดการสลับสถานะลอจิกสำหรับ LED
ในตัวอย่างนี้มีการระบุหมายเลขของ Timer เป็น -1 ซึ่งหมายถึง การใช้งานไทม์เมอร์แบบซอฟต์แวร์ (FreeRTOS-based) และไม่ได้ใช้ Hardware Timer (หมายเลข 0,1,2,3) ของ ESP32
โค้ดตัวอย่างที่ 5: Thread-based LED Blink
ตัวอย่างถัดไป สาธิตการกระพริบของ LED ซึ่งเกิดจากการทำงานของ ‘เธรด’ (Thread) โดยใช้ไลบรารี _thread
และกำหนดใช้ฟังก์ชัน led_toggle()
สำหรับการทำงานที่เกี่ยวข้อง การกระพริบจะเกิดซ้ำไปเรื่อย ๆ จนกว่า ตัวแปรภายนอก stop
จะมีค่าเป็น True
เช่น เกิดขึ้นเมื่อมีการกดปุ่ม
นอกจากนั้น ยังมีการใช้วงจร Timer ของ ESP32 จากคลาส machine.Timer
ในโค้ดตัวอย่างนี้ timer
จะถูกตั้งเวลาให้ทำงานแบบ One-Shot เมื่อเวลาผ่านไปตามที่กำหนด เช่น มีคาบเท่ากับ 5000 มิลลิวินาที เมื่อถึงเวลา จะเรียกฟังก์ชัน stop_led_blink()
ที่ทำหน้าที่เป็น Callback Function และทำคำสั่งเพียงหนึ่งครั้ง คือ การเปลี่ยนค่าของตัวแปรภายนอก stop
จาก False
ให้เป็น True
ซึ่งจะถูกใช้ในการตรวจสอบเพื่อการจบการทำงานของโปรแกรม
โค้ดตัวอย่างที่ 6: PWM LED Dimming
ถัดไปเป็นตัวอย่างการสร้างสัญญาณประเภท PWM (Pulse Width Modulation) แล้วนำไปใช้เป็นสัญญาณเอาต์พุตสำหรับวงจร LED ถ้าปรับค่า Duty Cycle ของสัญญาณ PWM จาก 0 ไปจนถึงค่าสูงสุด 1023 สำหรับ ESP32 ซึ่งมีความละเอียดเท่ากับ 10 บิต (ช่วงความกว้างที่เป็น High ในแต่ละคาบ จะอยู่ระหว่าง 0% ถึง 100% ตามลำดับ) เราจะเห็น LED สว่างขึ้นตามลำดับ ความถี่ของ PWM เมื่อใช้ ESP32 สามารถเลือกได้ในช่วง 1 Hz ถึง 40 MHz แต่สำหรับตัวอย่างนี้ เลือกความถี่เท่ากับ 500 Hz
การสร้างสัญญาณ PWM สำหรับขา Pin จะใช้คลาส PWM
ของไลบรารี machine
ให้ลองสังเกตการใช้คำสั่ง เช่น duty()
และ freq()
ในการเขียนหรืออ่านค่าสำหรับค่า Duty Cycle และความถี่ของสัญญาณ
ในตัวอย่างนี้ มีการคำนวณค่าคงตัวโดยใช้ฟังก์ชัน math.sin()
และเก็บไว้ในอาร์เรย์ที่มีขนาดเท่ากับ N (N=32) แล้วนำไปใช้เพื่อกำหนดค่า Duty Cycle ทีละค่าตามลำดับในอาร์เรย์
เมื่อทดสอบการทำงานของโค้ดตัวอย่างกับอุปกรณ์จริง จะเห็นการปรับความสว่างของ LED ด้วยสัญญาณแบบ PWM
โค้ดตัวอย่างที่ 7: Neopixel RGB LED
เฟิร์มแวร์ของไมโครไพธอน มีไลบรารี neopixel
เพื่อใช้ในการกำหนดสีให้แก่โมดูล RGB LED (WS2812B) หรือที่มักเรียกว่า Neopixel ซึ่งใช้สายสัญญาณดิจิทัลเป็นเอาต์พุต เพียงเส้นเดียว (ในตัวอย่างนี้ ได้เลือกใช้ขา GPIO-23)
ตัวอย่างโค้ดนี้ สาธิตการกำหนดสีให้ RGB LED จำนวน 1 ดวง โดยเปลี่ยนสี (ระบุค่าสีแบบ 24 บิต ประกอบด้วย 3 ไบต์แบบ 3-Tuple) จากแดง (Red), เขียว (Green) และน้ำเงิน (Blue) ไปตามลำดับ
ข้อสังเกต: เนื่องจากใช้โมดูลที่มี RGB LED เพียงดวงเดียว ดังนั้นเลือกจึงใช้ 3.3V จากบอร์ด ESP32 เป็นแหล่งจ่ายแรงดันคงที่ได้ แต่ถ้าใช้ RGB LED จำนวนหลายดวงและอาจใช้กระแสไฟมาก ควรใช้แหล่งจ่ายแรงดันคงที่จากภายนอก
โค้ดตัวอย่างที่ 8: DHT22 Sensor Reading
เฟิร์มแวร์ของไมโครไพธอน มีไลบรารี dht
สำหรับการอ่านค่าจากโมดูลเซ็นเซอร์ DHT22 มาให้แล้ว ดังนั้นเราสามารถลองใช้คำสั่ง เพื่ออ่านค่าอุณหภูมิ (Temperature) และความชื้นสัมพัทธ์ (Relative Humidity) ได้ไม่ยาก
การต่อวงจรเพื่อใช้งานโมดูล DHT22 ก็ใช้แรงดันไฟเลี้ยง 3.3V และ GND จากบอร์ด ESP32 และสายสัญญาณ Digital I/O เพียงเส้นเดียว ในตัวอย่างนี้ได้เลือกใช้ขา GPIO-19 (และจะต้องมีตัวต้านทานแบบ Pull-Up เช่น 4.7k หรือ 10k ต่ออยู่ด้วย)
การอ่านค่าจากโมดูล DHT22 จะทำทุก ๆ 2000 มิลลิวินาที โดยใช้ Software Timer ช่วยจัดการเพื่อให้ทำงานในลักษณะที่มีคาบ (Periodic Task)
โค้ดตัวอย่างที่ 9: ESP32 ADC Reading
การใช้คำสั่งของไมโครไพธอน เพื่ออ่านค่าจากวงจร ADC (Analog-to-Digital Converter) ของ ESP32 จะใช้ได้กับขาหมายเลข GPIO 32 ถึง 39 สำหรับ ADC1 ค่าที่ได้จะอยู่ในช่วง 0 ถึง 4095 (ความละเอียดสูงสุด 12 บิต) และแรงดันจะต้องอยู่ในช่วง 0V ถึง 1.1V และถ้าสูงกว่านั้น จะอ่านได้ค่า 4095
แต่ถ้าจะให้รับแรงดันอินพุตได้สูงกว่านั้น (แต่ต้องไม่เกิน 3.6V !!!) ต้องกำหนดค่าสำหรับ Attenuation (การลดทอนขนาดสัญญาณ) ให้เหมาะสม มีค่าให้เลือกได้ดังนี้
ADC.ATTN_0DB
(ไม่มีการลดทอนสัญญาณ หรือ 0dB และอ่านแรงดันในช่วง 0V ถึง 1.1V โดยประมาณ)ADC.ATTN_2_5DB
(การลดทอนสัญญาณ -2.5dB)ADC.ATTN_6DB
(การลดทอนสัญญาณ -6dB)ADC.ATTN_11DB
(การลดทอนสัญญาณสูงที่สุด -11dB และอ่านแรงดันในช่วง 0V ถึง 3.3V โดยประมาณ)
นอกจากนั้นยังสามารถเลือกได้ว่า ต้องการจะอ่านข้อมูลที่มีความละเอียดกี่บิต ตั้งแต่ 9 บิต จนถึง 12 บิต
ข้อสังเกต: จากการทดลองอ่านค่าจากวงจรแบ่งแรงดัน และตั้งค่าแรงดันให้อยู่ในช่วง 0V ถึง 3.3 V ค่าที่อ่านได้จาก ADC ของ ESP32 อาจมีความแม่นยำไม่สูงนัก (ค่าไม่ค่อยนิ่ง)
โค้ดตัวอย่างที่ 10: ESP32 DAC Output
ESP32 มีวงจร DAC (Digital-to-Analog Converter) อยู่ภายใน แบ่งเป็น 2 ช่อง ซึ่งตรงกับขา GPIO-26 (DAC Channel 1) และ GPIO-25 (DAC Channel 2) ตามลำดับ สามารถกำหนดค่าตัวเลขขนาด 8 บิต สำหรับเอาต์พุตได้ ในช่วง 0 ถึง 255 ซึ่งหมายถึง 0V ถึง 3.3V
เราสามารถใช้คลาส machine.DAC
เพื่อสร้างสัญญาณเอาต์พุตแบบแอนะล็อกโดยใช้ DAC ของ ESP32 ตามตัวอย่างดังนี้ ซึ่งได้เลือกใช้ DAC ช่อง 1 ที่ขา GPIO-26 เป็นเอาต์พุต แล้วใช้สายไฟต่อจากขานี้ไปยังขา GPIO-34 ซึ่งจะถูกใช้เป็นขาสำหรับ ADC เพื่ออ่านค่าอินพุตจากสัญญาณแอนะล็อก (เลือกขนาดข้อมูลที่อ่านได้เป็นแบบ 10 บิต)
โค้ดตัวอย่างที่ 11: Pulse Width Measurement
ตัวอย่างถัดไปสาธิตการวัดความกว้างของพัลส์ช่วงที่เป็น High โดยใช้คำสั่ง machine.time_pulse_us()
และสร้างสัญญาณ PWM เพื่อใช้ในการทดสอบ
ในการทดสอบการทำงานของโค้ด ได้เลือกใช้ขา GPIO-19 เป็นขาเอาต์พุตสำหรับสัญญาณ PWM โดยเลือกความถี่เท่ากับ 1kHz และปรับค่า Duty Cycle ได้ในช่วง 10% ถึง 90% และสัญญาณเอาต์พุตจะถูกนำไปป้อนกลับให้ขา GPIO-23 ที่ใช้เป็นขาอินพุต-ดิจิทัล
ตัวอย่างข้อความเอาต์พุตเปรียบเทียบค่าที่ต้องการกับค่าที่วัดได้ สำหรับการตั้งค่า Duty Cycle ในแต่ละกรณี ตั้งแต่ 10% ถึง 90% หรือความกว้างของพัลส์ตั้งแต่ 100 usec ถึง 900 usec สำหรับสัญญาณ PWM ที่มีคาบเท่ากับ 1000 usec
โค้ดตัวอย่างที่ 12: Getting System Info
โค้ดตัวอย่างถัดไป สาธิตการอ่านข้อมูลเกี่ยวกับระบบ เช่น ข้อมูลเกี่ยวกับ Machine ID ซึ่งในกรณีของ ESP32 ก็คือ MAC Address ที่มี 6 ไบต์ โดยการใช้คำสั่ง machine.unique_id()
หรือคำสั่ง network.WLAN().config('mac')
ซึ่งจะได้ข้อมูลเป็น bytes
และใช้คำสั่ง ubinascii.hexlify()
แปลงข้อมูลดังกล่าวให้เป็นข้อความเลขฐานสิบหก
ถ้าต้องการตรวจสอบดู ขนาดของหน่วยความจำ Flash และขนาดของหน่วยความจำ RAM ที่ยังว่างอยู่ หรือถูกใช้ไปในขณะนั้น ก็สามารถทำคำสั่งตามโค้ดตัวอย่างนี้ได้
ถ้าต้องการทราบข้อมูลเกี่ยวกับระบบ เช่น ชื่อของระบบ เวอร์ชันของเฟิร์มแวร์ของไมโครไพธอนที่กำลังใช้งานอยู่นั้น ก็สามารถทำคำสั่ง uos.uname()
ตามโค้ดตัวอย่างต่อไปนี้ได้
โค้ดตัวอย่างที่ 13: SPI Loopback Test
บัส SPI เป็นวิธีการสื่อสารข้อมูลที่มักพบเห็นได้บ่อย โดยทั่วไปจะใช้สัญญาณ 3 เส้น คือ SCK (Serial Clock), MOSI (Master-Out-Slave-In) และ MISO (Master-In-Slave-Out)
โดยทั่วไปแล้ว เราจะใช้ไมโครคอนโทรลเลอร์ทำหน้าที่เป็น ‘มาสเตอร์’ (Master) สำหรับบัส SPI เพื่อเชื่อมต่อกับอุปกรณ์อื่นในระบบบัส ซึ่งทำหน้าที่เป็น ‘สเลฟ’ (Slave)
แต่ถ้ามีอุปกรณ์ ‘สเลฟ’ มากกว่าหนึ่งตัว จะต้องมีสัญญาณควบคุมสำหรับอุปกรณ์แต่ละตัว เรียกว่า Slave Select (SS) หรือ Chip Select (CS) ซึ่งทำงานแบบ Active-Low
ในการทำงานของบัส SPI การรับส่งข้อมูลจะเกิดขึ้นพร้อมกัน เมื่อส่งข้อมูลทีละบิตออกไปทาง MOSI ก็จะได้ข้อมูลทีละบิตจาก MISO เข้ามา
ตัวอย่างโค้ดต่อไปนี้ สาธิตการเขียนข้อมูลไบต์ในอาร์เรย์และอ่านข้อมูลโดยใช้บัส SPI โดยเชื่อมต่อขา MOSI เข้ากับ MISO เข้าด้วยกัน ดังนั้นจึงเป็นการรับส่งข้อมูลแบบ Loopback
การเลือกใช้ขาสำหรับ Hardware SPI ของ ESP32 จะใช้ขา GPIO-14, GPIO-13 และ GPIO-12 สำหรับ SCK, MOSI และ MISO ตามลำดับ ซึ่งตรงกับขาสำหรับบัส HSPI ของ ESP32
โหมดการทำงานของ SPI มี 4 โหมด ในกรณีนี้ได้เลือกใช้โหมด (polarity=0, phase=0) ความถี่ของสัญญาณ SCK กำหนดให้เป็น 10 MHz (baudrate) ขนาดเฟรมข้อมูลเป็น 8 บิต ส่งข้อมูลบิตแบบ MSB First
โค้ดตัวอย่าง สาธิตการส่งข้อมูลคราวละ 5 ไบต์ โดยที่ 4 ไบต์แรกคือ 0xaa
, 0xbb
, 0xcc
, 0xdd
และไบต์สุดท้ายจะเป็นค่าของตัวนับขนาด 8 บิต
แต่ถ้าไม่มีการเชื่อมต่อระหว่างขา MISO และ MOSI เมื่อโค้ดทำงาน จะอ่านได้ค่า 0xff
, 0xff
, 0xff
, 0xff
, 0xff
, …
โค้ดตัวอย่างที่ 14: UART Data Transmission
ESP32 มีวงจร UART (Universal Asynchronous Receiver/Transmitter) สำหรับสื่อสารข้อมูลบิตแบบอนุกรม หรือที่เรียกว่า Hardware UART มีจำนวน 3 ชุด คือ UART0, UART1 และ UART2
แต่ UART0 จะถูกใช้สำหรับ MicroPython REPL และเชื่อมต่อกับไอซี USB-to-Serial ไว้แล้ว (เช่น CP2102 / CP2104 เป็นต้น) ดังนั้นถ้าเราต้องการจะส่งข้อมูลด้วย UART ก็สามารถเลือกใช้ UART1 หรือ UART2 แทนได้ เช่น เลือกใช้ขา GPIO สำหรับ UARTx ดังนี้ เหมือนในกรณีที่เขียนโค้ดด้วย Arduino-ESP32 แต่จะเลือกขา GPIO อื่นได้เช่นกัน
UARTx | RX GPIO | TX GPIO | CTS | RTS |
UART0 | GPIO3 | GPIO1 | N/A | N/A |
UART1 | GPIO9 | GPIO10 | GPIO6 | GPIO11 |
UART2 | GPIO16 | GPIO17 | GPIO8 | GPIO7 |
ในกรณีที่เราจะใช้ UART ส่งข้อมูลไปยังคอมพิวเตอร์ อุปกรณ์ที่จำเป็นต้องใช้ร่วมกันคือ โมดูล USB-to-Serial และให้เลือกใช้แรงดันลอจิกที่ 3.3V เท่านั้น (ไม่ใช่ 5V)
ตัวอย่างต่อไปนี้ สาธิตการใช้งาน UART โดยเลือกขา TX / GPIO-2 (ทิศทางเอาต์พุตสำหรับ ESP32) และ RX / GPIO-15 (ทิศทางอินพุตสำหรับ ESP32) ตามลำดับ และให้นำไปเชื่อมต่อกับขา RXD และ TXD ของโมดูล USB-to-Serial ตามลำดับ อีกทั้งให้ต่อขา GND ร่วมกันด้วย
เมื่อเปิดใช้งาน UART ให้ id = 1 เลือกใช้ Baudrate เท่ากับ 115200 จากนั้นจะมีการส่งข้อความทีละบรรทัด ซึ่งได้จากการแปลงตัวเลขที่คำนวณได้จากฟังก์ชัน math.sin()
โดยให้มีค่าอยู่ในช่วง -100 .. +100
การส่งข้อความ จะใช้คำสั่ง write()
ของไลบรารี machine.UART
ถ้าใช้โปรแกรมอย่างเช่น Arduino IDE และเปิดใช้งาน Serial Plotter จะเห็นการแสดงข้อมูลในรูปของกราฟ
ถ้าจะลองเขียนโค้ดที่คอยรับข้อความทีละบรรทัดจาก UART แล้วส่งกลับไปยังคอมพิวเตอร์ เพื่อทดสอบการทำงานในลักษณะ UART Loopback ก็มีตัวอย่างดังนี้
ลองเปรียบเทียบกับอีกโค้ดตัวอย่างหนึ่ง ซึ่งให้ผลการทำงานเหมือนกัน แต่ใช้คำสั่งของไลบรารี machine.UART
ที่แตกต่างกันในการรับข้อมูล
โค้ดตัวอย่างที่ 15: BH1750 I2C Light Sensor
ESP32 มีวงจรภายในที่สำหรับการสื่อสารข้อมูลด้วยบัส I2C จำนวน 2 ชุด (Hardware I2C) และจะต้องเลือกใช้ขา SCL (Clock) และ SDA (Data) ให้ถูกต้อง และการเขียนโค้ดด้วยไมโครไพธอน เราจะใช้คลาส machine.I2C
เริ่มต้นด้วยการต่ออุปกรณ์ที่ทำงานเป็น I2C Slave และให้ ESP32 ทำหน้าที่เป็น I2C Master ในตัวอย่างนี้ เราจะใช้โมดูลเซ็นเซอร์แสง BH1750 ซึ่งสามารถใช้แรงดันไฟเลี้ยง 3.3V และ GND จากบอร์ด ESP32 ได้ และเลือกใช้ขา SCL / GPIO-22 และ SDA / GPIO-21 ตามลำดับ
โค้ดต่อไปนี้ สาธิตการตรวจหาอุปกรณ์ที่เชื่อมต่อกับ I2C Bus โดยใช้ขา SCL และ SDA ตามที่กำหนดไว้ ถ้าตรวจพบอุปกรณ์ BH1750 จะแสดงข้อความที่ระบุหมายเลขแอดเดรส 0x23
โมดูล GY302 เป็น Breakout Board สำหรับ BH1750 ที่ได้เลือกมาใช้งาน มีขา VCC, GND , SCL, SDA, ADDR ตามลำดับ ถ้าไม่ต่อขา ADDR จะได้หมายเลขแอดเดรสเป็น 0x23
แต่ถ้าต่อขาดังกล่าวกับ VCC จะได้ 0x5c
ตัวอย่างถัดไปสาธิตการอ่านค่าความเข้มแสงจากโมดูล BH1750 ซึ่งจะได้ค่าตัวเลขจำนวนเต็มในช่วง 0 .. 65535 (16 บิต)
โค้ดตัวอย่างที่ 16: TouchPad
ตัวอย่างถัดไปสาธิตการใช้งาน TouchPad สำหรับขา GPIO บางขาของ ESP32 โดยได้เลือกใช้ขา GPIO-4 (TOUCH0) และ GPIO-0 (TOUCH1) จำนวน 2 ขา
ในการตรวจสอบดูว่า มีการใช้นิ้วมือสัมผัสที่ลวดหรือแผ่นโลหะที่เชื่อมต่อกับขา TouchPad หรือไม่ ก็ใช้วิธีการอ่านค่าเหมือนกรณีแอนะล็อก-อินพุต และจะได้ค่าเป็นเลขจำนวนเต็มบวก ถ้ามีการสัมผัส จะได้ค่าตัวเลขค่อนข้างต่ำ ในโค้ดตัวอย่างได้กำหนดไว้ว่า ถ้าได้ค่าต่ำกว่า 200 แสดงว่า มีการสัมผัสด้วยปลายนิ้ว
โดยทั่วไป ขา GPIO ที่ใช้เป็น TouchPad Input ควรมีตัวต้านทาน Pull-Up เช่น 1 เมกกะโอห์ม ต่อเอาไว้ด้วย
โค้ดตัวอย่างที่ 17: การใช้ OLED I2C Display
ตัวอย่างถัดไปสาธิตการใช้งานโมดูแสดงผลแบบ OLED โดยเชื่อมต่อกับบัส I2C ของ ESP32 โมดูล OLED ที่คนทั่วไปนิยมนำมาใช้งานจะใช้ไอซีควบคุมคือ SSD1306 และ SH1106 ดังนั้นจึงต้องเลือกไลบรารีที่นำมาใช้งานสำหรับไมโครไพธอนให้ถูกต้อง
เราสามารถดาวน์โหลดไฟล์ .py ซึ่งเป็นไลบรารีสำหรับไมโครไพธอนได้จาก
โมดูล OLED อาจจะมีขนาดที่แตกต่างกันคือ ความกว้าง (Width) และความสูง (Height) เช่น 128 x 64 หรือ 128 x 32 เป็นต้น
ในบางกรณีจะพบว่า โมดูล OLED นั้นใช้งานแบบบัส SPI ซึ่งจะมีจำนวนขามากกว่า และสิ่งที่ควรระวังคือ โมดูล OLED ที่ใช้วิธีการเชื่อมต่อแบบ I2C มีขา 4 ขา ได้แก่ GND, VCC, SCL, SDA ตามลำดับ แต่ก็อาจพบกรณีที่มีการเรียงขาแตกต่างไป ดังนั้นตรวจสอบให้แน่ใจก่อนต่อใช้งานวงจร
โค้ดสำหรับสาธิตการใช้งานโมดูล SH1106-based OLED I2C 128x64 pixels (default address: 0x3C)
เผยแพร่ภายใต้ลิขสิทธิ์ Attribution-ShareAlike 4.0 International (CC BY-SA 4.0)
Last updated