การทดลองในการบันทึกข้อมูลขั้นสูง (โดยใช้ Python): 11 ขั้นตอน

2024 ผู้เขียน: John Day | [email protected]. แก้ไขล่าสุด: 2024-01-30 13:03

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

(คุณสามารถดูรหัสทั้งหมดและดาวน์โหลดได้ที่: รหัสที่ GitHub คุณสามารถเข้าสู่การดูบางทีในหน้าต่างอื่นด้วยการคลิกเพียง 2 ครั้ง)

โดยทั่วไปการบันทึกข้อมูลเกี่ยวข้องกับสิ่งต่อไปนี้:

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

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

ขั้นตอนที่ 1: เครื่องมือและวัสดุ

ตัวอย่างนี้เป็นไฟล์ Python ทั้งหมด ดังนั้นมันจึงทำงาน และส่วนประกอบต่างๆ สามารถใช้ได้กับทุก OS รวมถึง Mac, PC, Linux และ Raspberry Pi

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

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

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

หมายเหตุรหัส: (รหัสที่ GitHub คุณสามารถเข้าสู่การดูบางทีในหน้าต่างอื่นด้วยการคลิกเพียง 2 ครั้ง) ตอนนี้อยู่ใน Python 3.6 ดังนั้นการมี 3.6 จะดีที่สุด โค้ดเวอร์ชันเก่าอยู่ที่นี่ในลิงก์ด้านล่าง

ขั้นตอนที่ 2: สร้างการทดลอง

มีสามขั้นตอนการเขียนโปรแกรม (และเส้น) ในการสร้างการทดสอบ การทดสอบแต่ละครั้งเป็นฟังก์ชันในออบเจ็กต์ LoggingSim ในไฟล์ simulate_logging.py มาดูการทดลองที่ 1 (แค่กราฟแรก) ซึ่งเราจะทำในขั้นตอนต่อไป:

def การทดสอบ_with_sample_rates(ตัวเอง):

พิมพ์ """ ทดลองกับอัตราตัวอย่าง การดูอัตราตัวอย่างต่างๆ โดยเปลี่ยน delta T """ self.start_plot(plot_title = "Sample Rates - ตอนที่ 1/3: Delta T = 1.0") self.add_sensor_data(name = "dt = 1.", แอมพลิจูด = 1., noise_amp =.0, delta_t = 1., max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot()

การทดสอบแต่ละครั้งเขียนเป็นฟังก์ชันของตัวเอง ดังนั้นเราจึงมีบรรทัดที่กำหนดฟังก์ชัน (การทดสอบโดยปกติ…..)

บรรทัดถัดไปที่ไม่ใช่ความคิดเห็น (start_plot(….) จะสร้างวัตถุสำหรับการทดสอบและตั้งชื่อให้กับมัน

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

• ชื่อ: ชื่อที่ใส่ในกราฟสุดท้ายเพื่อระบุข้อมูล
• แอมพลิจูด: สัญญาณมีขนาดใหญ่เพียงใด เราจะใช้แอมพลิจูด 1 เสมอในคำแนะนำนี้
• noise_amp: เสียงดังแค่ไหน 0 ไม่มีเสียงรบกวน เราจะเริ่มที่นี่
• delta_t: เวลาระหว่างการวัด ควบคุมอัตราตัวอย่าง
• max_t: เวลาสูงสุดที่เรารวบรวมข้อมูล เราจะใช้ 10 ในคำแนะนำนี้เสมอ
• run_ave: การประมวลผลโดยใช้ค่าเฉลี่ยการวิ่ง 0 หมายถึงไม่มีการประมวลผล
• trigger_value: การประมวลผลโดยใช้การทริกเกอร์ 0 หมายถึงไม่มีการประมวลผล

บรรทัดสุดท้ายที่ไม่ใช่ความคิดเห็น (self.show_plot……) แสดงกราฟ

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

ขั้นตอนที่ 3: เรียกใช้การทดสอบ

นี่คือรหัสสำหรับเรียกใช้การทดสอบ เหมือนกับใน Python มันถูกวางไว้ที่ท้ายไฟล์

sim_logging = LoggingSim()

sim_logging.experiment_with_sample_rates()

นี่เป็นเพียง 2 บรรทัด:

• สร้างโปรแกรมจำลองการบันทึก (LoggingSim())
• เรียกใช้ (sim_logging.experiment_with_sample_rates())

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

ขั้นตอนที่ 4: การทดลอง: อัตราตัวอย่าง

เครื่องจำลองตามที่ตั้งค่าไว้นี้จะส่งคลื่นไซน์ที่ราบรื่นของแอมพลิจูด 1 ออกมาเสมอ สำหรับการทดลองนี้ เราจะยุ่งกับอัตราการสุ่มตัวอย่าง ซึ่งปรับโดย delta_t ความแตกต่างของเวลาระหว่างตัวอย่าง เราจะไม่มีเสียงรบกวนหรือการประมวลผลอื่นๆ โค้ดใช้อัตราตัวอย่าง 3 อัตรา (delta_t = 1.0, 0.1 และ 0.01) เนื่องจากกราฟอยู่ทับกัน การทดสอบจึงถูกตั้งค่าเพื่อสร้างกราฟที่แตกต่างกัน 3 แบบ กราฟที่ได้คือภาพสำหรับขั้นตอนนี้

def การทดสอบ_with_sample_rates(ตัวเอง):

พิมพ์ """ ทดลองกับอัตราตัวอย่าง ดูที่อัตราตัวอย่างต่างๆ โดยเปลี่ยน delta T """ self.start_plot(plot_title = "Experiment Sample Rates 1/3: Delta T = 1.0") self.add_sensor_data(name = "dt = 1.", แอมพลิจูด = 1., noise_amp =.0, delta_t = 1., max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot() # ------------- ----------------------------------- self.start_plot(plot_title = "อัตราตัวอย่างการทดลอง 2/3: เดลต้า T = 0.1") self.add_sensor_data(ชื่อ = "dt = 1", แอมพลิจูด = 1., noise_amp =.0, delta_t = 0.1, max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot() # ------------------------------------------------ ตัวเอง.start_plot(plot_title = "อัตราตัวอย่างการทดลอง 3/3: Delta T = 0.01") self.add_sensor_data (ชื่อ = "dt = 1", แอมพลิจูด = 1, noise_amp =.0, delta_t = 0.01, max_t = 10, run_ave = 0, trigger_value = 0) self.show_plot()

หากต้องการเรียกใช้ให้ใช้บรรทัด: sim_logging.experiment_with_sample_rates()

ข้อสรุปที่เป็นไปได้:

• อัตราการสุ่มตัวอย่างต่ำเกินไปนั้นแย่มาก
• อัตราที่สูงมักจะดีกว่า

(รหัส Python 3.6 ที่ลิงค์ GitHub ด้านล่างที่คำแนะนำ 2.7)

ขั้นตอนที่ 5: ทดลอง: แสดงเสียงรบกวน

ในการทดลองนี้ เราคงสัญญาณเท่าเดิม ใช้อัตราการสุ่มตัวอย่างปานกลาง และมีปริมาณสัญญาณรบกวนต่างกัน (noise_amp =.0,.1, 1.0) เรียกใช้ด้วย: sim_logging.experiment_showing_noise() ผลลัพธ์คือหนึ่งกราฟที่มี 3 เส้น

ข้อสรุปที่เป็นไปได้:

สัญญาณรบกวนทำให้มองเห็นสัญญาณได้ยาก ให้ลดเสียงลงหากทำได้

รหัส:

# ------------------------------------------------

def Experiment_showing_noise(ตัวเอง): พิมพ์ """ การทดลองแสดงเสียงรบกวน การดูปริมาณเสียงรบกวนต่างๆ โดยการเปลี่ยนแอมพลิจูดของสัญญาณรบกวน """ self.start_plot(plot_title = "Experiment Showing Noise") self.add_sensor_data(name = "noise = 0.0" ", แอมพลิจูด = 1., noise_amp =.0, delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.add_sensor_data (ชื่อ = "noise = 0.1", แอมพลิจูด = 1, noise_amp = 1, delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.add_sensor_data (ชื่อ = "noise = 1.0", แอมพลิจูด = 1., noise_amp = 1., delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot()

ขั้นตอนที่ 6: การทดลอง: ลดเสียงรบกวนด้วยเส้นค่าเฉลี่ยเคลื่อนที่

ค่าเฉลี่ยเคลื่อนที่ (เช่น ที่มีความยาว 8) ใช้การวัด 8 ครั้งล่าสุดและหาค่าเฉลี่ย หากสัญญาณรบกวนเป็นแบบสุ่ม เราหวังว่าจะมีค่าเฉลี่ยที่ใกล้ 0 เรียกใช้การทดสอบด้วย: sim_logging.experiment_showing_noise() แสดงผลหนึ่งกราฟ

ข้อสรุปที่เป็นไปได้:

• ค่าเฉลี่ยเคลื่อนที่ช่วยขจัดเสียงรบกวนได้มาก
• ยิ่งค่าเฉลี่ยเคลื่อนที่นานเท่าใดก็ยิ่งลดสัญญาณรบกวนได้มากขึ้นเท่านั้น
• ค่าเฉลี่ยเคลื่อนที่ที่ยาวขึ้นอาจลดและบิดเบือนสัญญาณ

รหัส:

# ------------------------------------------------

def Experiment_with_moving_average(self): print """ Experiment with MovingAverage ดูที่ MovingAverage ต่างๆ โดยเปลี่ยนความยาว ทุกตัวมีนอยซ์เหมือนกัน """ # ------------------ ------------------------------ self.start_plot(plot_title = "MovingAverage-Part 1/2: No Moving Average") ตนเอง.add_sensor_data(name = "ave len=0", amplitude = 1., noise_amp =.1, delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot() self.start_plot(plot_title) = "MovingAverage-Part 2/2: Len 8 และ 32") self.add_sensor_data(ชื่อ = "ave len=8", แอมพลิจูด = 1, noise_amp =.1, delta_t =.1, max_t = 10., run_ave = 8, trigger_value = 0) self.add_sensor_data (ชื่อ = "ave len = 32", แอมพลิจูด = 1., noise_amp =.1, delta_t =.1, max_t = 10., run_ave = 32, trigger_value = 0) self.show_plot ()

ขั้นตอนที่ 7: การทดลอง: ค่าเฉลี่ยเคลื่อนที่และอัตราตัวอย่าง

ในการทดลองนี้ เราเปรียบเทียบสัญญาณดิบกับสัญญาณรบกวนและ 2 รูปแบบที่แตกต่างกันในการลดสัญญาณรบกวน

1. อัตราสุ่มตัวอย่างปานกลางและค่าเฉลี่ยการวิ่งปานกลาง
2. อัตราสุ่มตัวอย่างสูงและค่าเฉลี่ยการวิ่งที่มีความยาวสูง

เรียกใช้ด้วย: sim_logging…… เอาต์พุตเป็นกราฟเดียว ฉันคิดว่ามันชัดเจนว่า #2 ทำงานได้ดีกว่าในการลดเสียงรบกวน ดังนั้นเราจึงสรุปได้ว่า:

อัตราการสุ่มตัวอย่างสูงและค่าเฉลี่ยการวิ่งที่มีความยาวสูงนั้นดี

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

รหัส:

def การทดสอบ_with_moving_average_and_sample_rate(ตัวเอง):

พิมพ์ """ ทดลองกับค่าเฉลี่ยเคลื่อนที่และอัตราตัวอย่าง dt ค่าเฉลี่ยการรันจะแปรผัน """ # ---------------------------- -------------------- self.start_plot(plot_title = "ค่าเฉลี่ยเคลื่อนที่และอัตราการสุ่มตัวอย่าง") self.add_sensor_data(ชื่อ = "dt=.1 ra=0 trig= 0", แอมพลิจูด = 1., noise_amp =.1, delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.add_sensor_data(name = "dt=.1 ra=10 trig=0", แอมพลิจูด = 1., noise_amp =.1, delta_t =.1, max_t = 10., run_ave = 10, trigger_value = 0) self.add_sensor_data (ชื่อ = "dt=.01 ra=100 trig=0", แอมพลิจูด = 1., noise_amp =.1, delta_t =.01, max_t = 10., run_ave = 100, trigger_value = 0) self.show_plot()

ขั้นตอนที่ 8: การทดลอง: การบันทึกด้วย Trigger

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

ฉันได้บรรทัด # 2 จากการทดสอบครั้งล่าสุดซึ่ง "ดี" และเพิ่มทริกเกอร์ เรียกใช้ด้วย: sim_logging…… เอาต์พุตเป็นหนึ่งกราฟ x เส้น

เกิดอะไรขึ้น? เราได้รับพล็อตที่ "ดี" ด้วยจำนวนข้อมูลที่เหมาะสม (เหมือนกับ #1) มีค่าใช้จ่ายบางอย่างในการประมวลผลที่สูงขึ้น อย่างไรก็ตาม โดยรวมแล้ว ผลลัพธ์นั้นใกล้เคียงกับ #1 กับอัตราการสุ่มตัวอย่างที่ต่ำกว่าที่มีการกรองน้อยกว่า คุณอาจสรุป:

• ค่าเฉลี่ยระยะยาวพร้อมทริกเกอร์สามารถลดสัญญาณรบกวนได้ดีพร้อมข้อมูลในปริมาณที่เหมาะสม
• การประมวลผลพิเศษอาจไม่ให้ผลลัพธ์ที่ดีขึ้นมากนักและมีค่าใช้จ่าย

รหัส:

# ------------------------------------------------

def Experiment_with_trigger(self): print """ Experiment with Triggering, dt, run average และ trigger all be variety """ # ------------------------ ------------------------- self.start_plot(plot_title = "Trigger 1/1 - Triggering On") self.add_sensor_data(ชื่อ = "dt=.1 ra=10, trig =0", แอมพลิจูด = 1., noise_amp =.1, delta_t =.1, max_t = 10., run_ave = 10, trigger_value = 0) self.add_sensor_data(ชื่อ = "dt=.01 ra=100, trig =.1", แอมพลิจูด = 1., noise_amp =.1, delta_t =.01, max_t = 10., run_ave = 100, trigger_value =.1) self.show_plot()

=

ขั้นตอนที่ 9: การทดลอง: การบันทึกด้วยทริกเกอร์ - เสียงดังขึ้น

ลองทำการทดลองเดียวกันกับขั้นตอนสุดท้ายและเพิ่มเสียง เรียกใช้ด้วย: sim_logging…… เอาต์พุตเป็นหนึ่งกราฟ 2 เส้น

ตอนนี้การประมวลผลพิเศษดูคุ้มค่ามากขึ้นในขณะที่ ข้อสรุปที่สมเหตุสมผลที่นี่อาจเป็น:

การเลือกจำนวนและประเภทของการประมวลผลเพื่อลดสัญญาณรบกวนนั้นขึ้นอยู่กับสัญญาณและสัญญาณรบกวนของคุณ

รหัส:

def Experiment_with_trigger_louder_noise(ตัวเอง):

พิมพ์ """ เสียงดังกว่าการทดลองก่อนหน้า """ self.start_plot(plot_title = "การทดลองที่มีสัญญาณรบกวนทริกเกอร์") self.add_sensor_data (ชื่อ = "…dt=.1 ra=10", แอมพลิจูด = 1, noise_amp =.5, delta_t =.1, max_t = 10., run_ave = 10, trigger_value = 0) self.add_sensor_data (ชื่อ = "..dt=.01 ra=100 ทีวี =.1", แอมพลิจูด = 1, noise_amp =.5, delta_t =.01, max_t = 10., run_ave = 100, trigger_value =.1) self.show_plot()

ขั้นตอนที่ 10: ทำการทดลองของคุณเอง

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

ข้อสังเกตบางประการเกี่ยวกับการทดลองและสิ่งที่คุณอาจพิจารณา:

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

หมายเหตุ: การบันทึกรูปภาพจาก Wikipedia

ขั้นตอนที่ 11: การใช้เทคนิคในซอฟต์แวร์บันทึกของคุณ

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

• DataTrigger ใน data_trigger.py
• MovingAverage ใน moving_average.py

LoggingSim วัตถุหลักของฉันใน simulate_logging.py ควรให้ตัวอย่างที่ดีเกี่ยวกับวิธีการใช้งาน หากคุณใช้ภาษาอื่น คุณสามารถอ่านโค้ดของฉันและนำไปใช้ในภาษาของคุณได้

รหัสนี้สามารถช่วยให้โครงการของคุณบันทึกข้อมูลได้ดีขึ้น ลองใช้ดู

กราฟด้านบนมาจาก Graph Your Solar Power โดย russ_hensel ซึ่งใช้วัตถุเฉลี่ยที่วิ่งเหมือนกัน