Details

Written by Super User

Category: Microcontroller & Microprocessor

Published: 03 September 2023

Hits: 178

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

การขัดจังหวะสามารถแบ่งออกได้เป็น 2 ประเภทหลักๆ คือ

• การขัดจังหวะจากอุปกรณ์ภายนอก (External Interrupt) เป็นการขัดจังหวะที่เกิดจากอุปกรณ์ภายนอก เช่น การกดปุ่มบนแป้นพิมพ์ การมาถึงของข้อมูลจากอุปกรณ์ภายนอก เป็นต้น
• การขัดจังหวะจากซอฟต์แวร์ (Software Interrupt) เป็นการขัดจังหวะที่เกิดจากซอฟต์แวร์ เช่น การเรียกใช้ฟังก์ชัน interrupt ในโปรแกรม

หลักการทำงานของการขัดจังหวะ มีดังนี้

1. อุปกรณ์ภายนอกหรือซอฟต์แวร์จะส่งสัญญาณขัดจังหวะไปยังไมโครโปรเซสเซอร์
2. ไมโครโปรเซสเซอร์จะหยุดการทำงานที่ดำเนินอยู่ในปัจจุบันชั่วคราว
3. ไมโครโปรเซสเซอร์จะบันทึกค่าสถานะการทำงานปัจจุบันลงในหน่วยความจำ
4. ไมโครโปรเซสเซอร์จะเปลี่ยนเส้นทางการประมวลผลไปยังโปรแกรมย่อยการขัดจังหวะ
5. โปรแกรมย่อยการขัดจังหวะจะจัดการกับเหตุการณ์สำคัญที่เกิดขึ้น
6. โปรแกรมย่อยการขัดจังหวะจะส่งสัญญาณกลับไปยังไมโครโปรเซสเซอร์
7. ไมโครโปรเซสเซอร์จะกลับมาทำงานที่ดำเนินอยู่เดิม

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

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

ไมโครคอนโทรลเลอร์ ESP32 พัฒนาโดย Espressif Systems มีระบบขัดจังหวะที่ยืดหยุ่นมาก IRAM_ATTR เป็นคำหลักที่ใช้ระบุว่าควรวางฟังก์ชันเฉพาะไว้ใน RAM ภายในของ ESP32 เพื่อการดำเนินการที่รวดเร็วยิ่งขึ้น โดยเฉพาะอย่างยิ่งที่สำคัญอย่างยิ่งสำหรับ Interrupt Service Routines (ISR) เพื่อให้แน่ใจว่าฟังก์ชันดังกล่าวสามารถทำงานได้อย่างรวดเร็วและไม่ถูกขัดจังหวะโดยการทำงานของหน่วยความจำแฟลช .

จำนวน "ชุดการขัดจังหวะ" ที่สามารถรองรับได้:

• จำนวนการขัดจังหวะของฮาร์ดแวร์: ESP32 มีพิน GPIO จำนวนหนึ่ง ซึ่งส่วนใหญ่สามารถกำหนดค่าให้เป็นแหล่งสัญญาณขัดจังหวะภายนอกได้ ตามทฤษฎีแล้ว หมายความว่า GPIO เกือบทุกพินสามารถมีรูทีนขัดจังหวะของตัวเองได้ อย่างไรก็ตาม จำนวนที่แน่นอนอาจน้อยกว่าเล็กน้อย เนื่องจากพินบางตัวอาจมีฟังก์ชันพิเศษหรืออาจไม่ปรากฏบนทุกโมดูล
• การขัดจังหวะที่ใช้ร่วมกัน: เป็นไปได้ที่พิน GPIO หลายอันจะแชร์รูทีนขัดจังหวะเดียว ซึ่งทำได้โดยการตรวจสอบว่าพินใดที่ทำให้เกิดการขัดจังหวะภายใน ISR
• การขัดจังหวะของซอฟต์แวร์และการแจ้งเตือนงาน: นอกเหนือจากการขัดจังหวะด้วยฮาร์ดแวร์แล้ว ESP32 ยังรองรับการขัดจังหวะที่เรียกใช้ซอฟต์แวร์และการแจ้งเตือนงานอีกด้วย สิ่งเหล่านี้ใช้ภายในสภาพแวดล้อม FreeRTOS ที่กรอบงาน ESP-IDF ใช้ โดยทั่วไปแล้วจะไม่ถูกระบุว่าเป็น "การขัดจังหวะ" ในความหมายของไมโครคอนโทรลเลอร์แบบดั้งเดิม แต่มีจุดประสงค์ที่คล้ายกัน
• ข้อจำกัดของ RAM ภายใน (IRAM): แม้ว่าคุณจะสามารถกำหนด ISR ได้จำนวนมาก แต่โปรดจำไว้ว่า IRAM ของ ESP32 นั้นมีจำกัด หากคุณวางฟังก์ชันมากเกินไปหรือฟังก์ชันขนาดใหญ่ใน IRAM โดยใช้ IRAM_ATTR พื้นที่ว่างของคุณอาจหมด คุณต้องจัดการพื้นที่นี้อย่างรอบคอบเพื่อให้แน่ใจว่า ISR ที่สำคัญและฟังก์ชันที่สำคัญอื่นๆ สามารถเหมาะสมได้

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

อ้างอิงถึงการใช้IRAM_ATTR คำหลักสำหรับรูทีนการบริการขัดจังหวะ (ISR) บน ESP32 โดยทั่วไปจะทำเพื่อให้แน่ใจว่า ISR ถูกจัดเก็บไว้ใน RAM ภายใน (IRAM) ของ ESP32 เพื่อให้สามารถดำเนินการได้อย่างรวดเร็วและไม่ได้รับผลกระทบจากการทำงานของแฟลชที่อาจเกิดขึ้น

อธิบายให้ชัดเจนกว่านี้:

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

เพื่อป้องกันสิ่งนี้ ควรวางโค้ดสำคัญเช่น ISR ไว้ใน IRAM เพื่อให้แน่ใจว่าการตอบสนองของการขัดจังหวะจะเกิดขึ้นทันที และไม่ต้องรอการทำงานของแฟลชใดๆ

นี่เป็นตัวอย่างง่ายๆ ของวิธีที่คุณอาจใช้IRAM_ATTR ด้วย ISR:

void IRAM_ATTR handleInterrupt() {

    // Your ISR code here

}

   โดยการวางIRAM_ATTR ก่อนคำจำกัดความฟังก์ชัน ISR คุณกำลังสั่งให้ ESP-IDF (กรอบการพัฒนาอย่างเป็นทางการสำหรับ ESP32) เพื่อวางจัดการขัดจังหวะ ทำงานใน RAM ภายใน ช่วยให้มั่นใจถึงการดำเนินการที่รวดเร็วเมื่อเกิดการขัดจังหวะ

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

ตัวอย่าง 5 buttons

// Define 5 buttons
struct Button {
const uint8_t PIN;
uint32_t numberKeyPresses;
bool pressed;
};

Button buttons[] = {
{18, 0, false},
{19, 0, false},
{20, 0, false},
{21, 0, false},
{22, 0, false}
};

// ISR for all buttons
void IRAM_ATTR handleInterrupt() {
for (int i = 0; i < 5; i++) {
if (digitalRead(buttons[i].PIN) == LOW) { // If button is pressed
buttons[i].numberKeyPresses++;
buttons[i].pressed = true;
}
}
}

void setup() {
Serial.begin(115200);

// Attach interrupt for all buttons
for (int i = 0; i < 5; i++) {
pinMode(buttons[i].PIN, INPUT_PULLUP);
attachInterrupt(buttons[i].PIN, handleInterrupt, FALLING);
}
}

void loop() {
for (int i = 0; i < 5; i++) {
if (buttons[i].pressed) {
Serial.printf("Button %d has been pressed %u times\n", i + 1, buttons[i].numberKeyPresses);
buttons[i].pressed = false;
}
}
}

อธิบาย Code นี้:

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

ตรวจสอบให้แน่ใจว่า Pin ที่คุณใช้ (18, 19, 20, 21, 22 ในตัวอย่างนี้) พร้อมใช้งานสำหรับจุดประสงค์นี้บนบอร์ด/โมดูล ESP32 เฉพาะของคุณ ถ้าไม่คุณสามารถเปลี่ยนเป็นหมุดอื่นที่เหมาะสมได้

 REF .

https://lastminuteengineers.com/handling-esp32-gpio-interrupts-tutorial/

Details

Written by Super User

Category: Microcontroller & Microprocessor

Published: 16 October 2022

Hits: 1274

• arduino
• battery charger

https://github.com/curiores/ArduinoTutorials/tree/main/SolarCharger 

Details

Written by Super User

Category: Microcontroller & Microprocessor

Published: 03 September 2023

Hits: 761

• pid
• esp32
• pidc servo

การควบคุม RC servo ด้วย PID Control เป็นเรื่องที่น่าสนใจและเป็นประโยชน์สำหรับผู้ที่สนใจในการพัฒนาโปรเจ็คทางด้าน อิเล็กทรอนิกส์ และ โรบอทิกส์ สำหรับผู้เริ่มต้น มีข้อแนะนำดังนี้:

1. เริ่มจากพื้นฐาน:

   • ความหมายของ RC servo และ ทำไมต้องใช้ PID Control
   • ศึกษาการทำงานของ RC servo รวมถึงการเชื่อมต่อไฟฟ้า

2. ทฤษฎี PID Control:

   • ความหมายของ P, I, D และ วิธีการทำงานของแต่ละส่วน
   • การปรับ PID constants และวิธีการดูแล้วว่า constants ใดทำให้การควบคุมดีขึ้น

3. การเขียนโค้ด:

   • ตัวอย่างโค้ดที่ง่ายสำหรับควบคุม RC servo ด้วย PID
   • อธิบายการทำงานของโค้ดในแต่ละส่วน

4. ปฏิบัติการ:

   • การเชื่อมต่อ RC servo กับ ESP32 และอุปกรณ์อื่น ๆ
   • วิธีการปรับปรุงและประสิทธิภาพในการควบคุม

5. การทดสอบและการปรับแต่ง:

   • วิธีการทดสอบระบบ เช่น การใช้ฟังก์ชันแตกต่าง ๆ และการปรับค่าต่าง ๆ
   • สาเหตุที่ PID ไม่ทำงานดีในบางเวลา และวิธีการแก้ไข

6. เคสตัวอย่างและโปรเจคที่เกี่ยวข้อง:

   • ตัวอย่างโปรเจคที่สามารถประยุกต์ใช้ PID Control กับ RC servo
   • การพัฒนาและประยุกต์ใช้ในความเป็นจริง

      

Single RC Servo Control with PID 

//ESP32 CPU with Arduino IDE

#include <ESP32_Servo.h>
#include <PID_v1.h>

Servo throttleServo;
const int throttlePin = 14; // The digital pin where the servo is connected
const int sensorPin = 4; // The digital pin where the sensor is connected

const double setPointRPM = 6800.0; // Store setpoint RPM as double

double measuredRPM = 0;
volatile int pulseCount = 0;
unsigned long lastPulseTime = 0;

// PID parameters
double kp = 1.0; // Proportional constant
double ki = 0.1; // Integral constant
double kd = 0.1; // Derivative constant

double throttleOutput; // Declare throttleOutput here

double actualSetPointRPM = setPointRPM; // Create a double variable for setpoint RPM

PID pid(&measuredRPM, &throttleOutput, &actualSetPointRPM, kp, ki, kd, DIRECT);

const int minServoValue = 0; // Minimum servo value
const int maxServoValue = 180; // Maximum servo value

void setup() {
Serial.begin(115200);
throttleServo.attach(throttlePin);
pinMode(sensorPin, INPUT_PULLUP);
attachInterrupt(digitalPinToInterrupt(sensorPin), handleInterrupt, FALLING);

// Set the output limits for the PID controller
pid.SetOutputLimits(minServoValue, maxServoValue);

// Set the mode of the PID controller to AUTOMATIC
pid.SetMode(AUTOMATIC);
}

void loop() {
unsigned long currentTime = millis();
if (currentTime - lastPulseTime >= 1000) {
measuredRPM = pulseCount * (60000.0 / (currentTime - lastPulseTime));
lastPulseTime = currentTime;
pulseCount = 0;

pid.Compute(); // Compute the PID output

throttleServo.write(throttleOutput);

Serial.print("Measured RPM: ");
Serial.print(measuredRPM);
Serial.print("\tThrottle Output: ");
Serial.println(throttleOutput);
printPIDValues(kp, ki, kd); // Print PID gains for debugging
}
}

void handleInterrupt() {
pulseCount++;
}

void printPIDValues(double Kp, double Ki, double Kd) {
Serial.print("P: "); Serial.print(Kp);
Serial.print("\tI: "); Serial.print(Ki);
Serial.print("\tD: "); Serial.println(Kd);
}

Multi RC Servo Control with PID 

//ESP32 CPU with Arduino IDE

#include <ESP32_Servo.h>
#include <PID_v1.h>

struct ServoControl {
Servo servo;
int servoPin;
int sensorPin;
double setPointRPM;
double kp;
double ki;
double kd;

// Runtime variables
PID* pid;
double measuredRPM = 0;
volatile int pulseCount = 0;
unsigned long lastPulseTime = 0;
double throttleOutput;

double input;
double output;
double setpoint;

ServoControl(int sPin, int sensor, double sp, double p, double i, double d)
: servoPin(sPin), sensorPin(sensor), setPointRPM(sp), kp(p), ki(i), kd(d) {}
};

ServoControl controls[] = {
ServoControl(14, 4, 6800.0, 1.0, 0.1, 0.1),
ServoControl(15, 5, 6800.0, 1.2, 0.05, 0.2),
ServoControl(16, 17, 6800.0, 1.2, 0.05, 0.2)
};

void IRAM_ATTR handleInterrupt0() { controls[0].pulseCount++; }
void IRAM_ATTR handleInterrupt1() { controls[1].pulseCount++; }
void IRAM_ATTR handleInterrupt2() { controls[2].pulseCount++; }

typedef void (*ISR)(void);
ISR interruptHandlers[] = {
handleInterrupt0,
handleInterrupt1,
handleInterrupt2 // Fixed to correct interrupt handler
};

void initServo(ServoControl &control, int index) {
control.servo.attach(control.servoPin);
pinMode(control.sensorPin, INPUT_PULLUP);
attachInterrupt(digitalPinToInterrupt(control.sensorPin), interruptHandlers[index], FALLING);

control.input = control.measuredRPM;
control.output = control.throttleOutput;
control.setpoint = control.setPointRPM;

control.pid = new PID(&control.input, &control.output, &control.setpoint, control.kp, control.ki, control.kd, DIRECT);
control.pid->SetOutputLimits(0, 180);
control.pid->SetMode(AUTOMATIC);
}

void setup() {
Serial.begin(115200);
for (int i = 0; i < sizeof(controls)/sizeof(controls[0]); i++) {
initServo(controls[i], i);
}
}

void adjustPIDViaSerial() {
if (Serial.available()) {
String input = Serial.readStringUntil('\n');
int servoID;
char parameter;
double value;
sscanf(input.c_str(), "%d,%c,%lf", &servoID, &parameter, &value);

if(servoID >= 0 && servoID < sizeof(controls)/sizeof(controls[0])) {
switch (parameter) {
case 'P': controls[servoID].kp = value; break;
case 'I': controls[servoID].ki = value; break;
case 'D': controls[servoID].kd = value; break;
}

controls[servoID].pid->SetTunings(controls[servoID].kp, controls[servoID].ki, controls[servoID].kd);
Serial.println("PID values updated!");
} else {
Serial.println("Invalid servo ID!");
}
}
}

void loop() {
adjustPIDViaSerial();

for (int i = 0; i < sizeof(controls)/sizeof(controls[0]); i++) {
ServoControl& control = controls[i];
unsigned long currentTime = millis();
if (currentTime - control.lastPulseTime >= 1000) {
control.measuredRPM = control.pulseCount * (60000.0 / (currentTime - control.lastPulseTime));
control.lastPulseTime = currentTime;
control.pulseCount = 0;

control.input = control.measuredRPM;
control.pid->Compute();

control.servo.write(control.output);

Serial.print("Servo #");
Serial.print(i);
Serial.print(" - Measured RPM: ");
Serial.print(control.measuredRPM);
Serial.print("\tThrottle Output: ");
Serial.println(control.output);
}
}
}

Details

Written by Super User

Category: Microcontroller & Microprocessor

Published: 16 October 2022

Hits: 1180

• pid control
• pid
• motor

ตัวควบคุม PID คืออะไร?

คำว่า PID ย่อมาจากอนุพันธ์อินทิกรัลตามสัดส่วน และ เป็นอุปกรณ์ประเภทหนึ่งที่ใช้ในการควบคุมตัวแปร กระบวนการต่างๆ เช่น ความดัน การไหล อุณหภูมิ และ ความเร็วในงานอุตสาหกรรม ในคอนโทรลเลอร์นี้ อุปกรณ์ป้อนกลับแบบลูปควบคุมใช้ เพื่อควบคุมตัวแปรกระบวนการทั้งหมด การควบคุมประเภทนี้ใช้เพื่อขับเคลื่อนระบบไปในทิศทางของตำแหน่งเป้าหมาย หรือ ระดับอื่น มีเกือบทุกที่สำหรับการควบคุมอุณหภูมิ และ ใช้ในกระบวนการทางวิทยาศาสตร์ ระบบอัตโนมัติ และ สารเคมี ในคอนโทรลเลอร์นี้ ฟีดแบ็คเป็นแบบลูปปิด (Close Loop) จะใช้เพื่อรักษาเอาท์พุตจริง

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

กระบวนการ ออกแบบการควบคุม เริ่มต้นด้วยการกำหนดข้อกำหนดด้านประสิทธิภาพ ประสิทธิภาพของระบบควบคุมมักจะวัดโดยการใช้ฟังก์ชันขั้นตอนเป็นตัวแปรคำสั่ง set point จากนั้นจึงวัดการตอบสนองของตัวแปรกระบวนการ โดยทั่วไป การตอบสนองจะถูกหาปริมาณโดยการวัดคุณลักษณะของรูปคลื่นที่กำหนดไว้ เวลาที่เพิ่มขึ้นคือระยะเวลาที่ระบบใช้ในการเปลี่ยนจาก 10% เป็น 90% ของค่าสถานะคงตัวหรือค่าสุดท้าย เปอร์เซ็นต์โอเวอร์ชูตคือจำนวนที่ตัวแปรกระบวนการโอเวอร์ชูตค่าสุดท้าย ซึ่งแสดงเป็นเปอร์เซ็นต์ของค่าสุดท้าย เวลาในการชำระเป็นเวลาที่ตัวแปรกระบวนการต้องชำระภายในเปอร์เซ็นต์ที่กำหนด (โดยทั่วไปคือ 5%) ของค่าสุดท้าย ข้อผิดพลาด Steady-State คือความแตกต่างสุดท้ายระหว่างตัวแปรกระบวนการและจุดตั้งค่า

แหล่งความรู้ PID

https://www.teachmemicro.com/arduino-pid-control-tutorial/