低延迟Double-Edge PWM的设计

最新推荐文章于 2024-12-18 09:15:26 发布

原创

最新推荐文章于 2024-12-18 09:15:26 发布 · 1k 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#PWM设计 #Double-Edge #多相低延迟PWM

本文探讨了传统PWM的Trailing-Edge和Leading-Edge实现及其缺点，并详细介绍了Double-Edge PWM如何通过降低延迟来改进。此外，还讨论了基于环形振荡器的PWM设计和低延迟Double-Edge PWM的实现方法。

传统PWM

Trailing-Edge PWM实现框图：

Trailing-Edge PWM原理：

CLK置位锁存器Latch

比较器输出复位锁存器Latch

开关周期开始，PWM输出1

Vramp > Vc时，PWM输出0，直到下一个开关周期开始

Trailing-Edge PWM缺点：

Leading-Edge PWM实现框图：

Leading-Edge PWM原理：

比较器输出置位锁存器Latch

CLK复位锁存器Latch

开关周期开始，PWM输出0

最低0.47元/天解锁文章

确定要放弃本次机会？

福利倒计时

: :

立减 ¥

普通VIP年卡可用

立即使用

eLongming

关注关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
分享

复制链接

分享到 QQ

分享到新浪微博

扫一扫
举报

举报

专栏目录

电子测量中的国半推出业界最低功率而传播延迟不超过1ns的高速比较器系列

11-27

高性能模拟信号路径产品供应商美国国家半导体公司(National Semiconductor Corporation)宣布推出一款业界最低功率(典型值为21mA)而传播延迟时间不超过1纳秒(700ps)的双通道比较器。新推出的这款LMH7322双通道比较器与LMH7220单通道比较器是美国国家半导体单、双及4通道高速比较器系列的两个不同型号。这两款比较器与其他型号的产品都设有低电压差分信号传输(LVDS)及更低电压摆幅正射极耦合逻辑(RSPECL)输出。美国国家半导体计划于2007年第3季为客户提供4通道比较器的样品。这款新产品的技术规格大致上与LMH7322相同。　　无论是功耗还是性能，

电源技术中的通嘉科技PWM控制器可用于多种电源设计

11-28

通嘉科技推出全功能型Current Mode PWM控制器LD7520/LD7522，激活电流仅需35mA，具Green Mode节能操作功能，该产品整合了Leading-Edge Blanking，内部斜率补偿及数种保护功能，如，循环电流限制、OVP、OTP及OLP功能，提供设计者更高效率，更少外部零件的AC/DC解决方案，其中LD7522兼具有Brown-Out的功能。　　该二款IC不仅耗电低，即使轻载或无负载时，仍保持无噪音运作，并且可依需要设定为Latch-Mode或自动回复保护。　　LD7520/LD7522可应用在AC/DC变压器、充电器，Open frame电源供应器

参与评论您还未登录，请先登录后发表或查看评论

UC3842电源管理芯片详细解读

热门推荐

ice_cream23333的博客

05-02

9万+

UC3842是AC-DC反激式变压器中常用的电源管理芯片，其具有较低的启动电流（<1mA），并且可以在高达500KHz频率下工作，在输出端输出可脉宽调制的PWM波来驱动NMOSFET，并且在MOS管关断时具有较低的功耗。对UC3842进行详细而具体的理解不仅对开发开关电源，而且对测试调整开关电源都有很大的帮助。

开关电源——15种控制模式（1）

weixin_50578108的博客

07-11

4720

关于开关电源的控制模式，TI官网的有相对全面的归纳和描述，提供了15种不同的控制架构，这些架构涵盖了从基础到高级的多种控制模式，以适应不同的应用需求，如下表所示：以下是对控制模式相关内容的具体阐述与相关知识点的归纳整理，以便于更好的理解、交流讨论，欢迎在评论区留言、探讨，共同学习进步。开关电源的电压模式控制是开关稳压器中最基本的一种控制策略，它通过检测输出电压并与参考电压进行比较，调节功率开关管的导通时间（占空比）来维持输出电压稳定。

Leading edge 和Trailing edge

qwaszx523的博客

04-18

1万+

一个时钟周期有两个edge，分别称为： (1)Leading edge=前一个边沿=第一个边沿，对于开始电压是1，那么就是1变成0的时候；对于开始电压是0，那么就是0变成1的时候。 (2)Trailing edge=后一个边沿=第二个边沿，对于开始电压是1，那么就是0变成1的时候；对于开始电压是0，那么就是1变成0的时候。

电机响应延迟揭秘：从PWM指令到扭矩输出的3ms时间窗口测量与补偿技术

其本质是时间敏感环节在微秒级时序上的非理想行为叠加，包括PWM生成滞后、驱动传播延迟、开关器件响应不及时及电流环处理开销等。这类延迟直接影响扭矩动态响应精度，在高动态伺服系统中可导致相位滞后、振荡甚至失...

#include <pigpio.h> #include <iostream> #include <unistd.h> #include <opencv2/opencv.hpp> #include <vector> using namespace cv; using namespace std; // ---------- 配置参数 ---------- const int BACKGROUND_COLOR = 1; // 1: 红色背景, 2: 蓝色背景 // ---------- 函数声明 ---------- void GetLineROI(Mat src, Mat &ROI); void GetSignROI(Mat src, Mat &ROI); void GetROI(Mat src, Mat &ROI); bool detectBackgroundPresence(Mat &img); int detectABLetter(Mat &img); double PID(double error1); int atc(int angle); int dong(); int xunji(Mat frame); void preprocessImg(Mat img, Mat &gray, Mat &canny); void saveDebugImage(Mat img, string name, int frame_count); bool detect_A_shape(Mat &roi); bool detect_B_shape(Mat &roi); void performAction(int letter); Mat preprocessForLetter(Mat &roi); void improveLineDetection(Mat &canny); // ---------- 全局变量 ---------- const int pwm_pin = 13; const int servo_pin = 12; const int pwm_freq1 = 200; const int pwm_freq2 = 50; const int pwm_range1 = 40000; const int pwm_range2 = 100; const int init_duty = 10000; double last_error = 0; const double kp = 0.25, kd = 0.06; // 进一步降低PID参数 const double min_ang = 75, max_ang = 89; // 缩小角度范围 bool debug_save = true; bool ab_detected = false; int detected_letter = 0; int action_cooldown = 0; // ---------- 保存调试图像 ---------- void saveDebugImage(Mat img, string name, int frame_count) { if (debug_save && frame_count % 100 == 0) { // 进一步减少保存频率 string filename = "/tmp/" + name + "_" + to_string(frame_count) + ".jpg"; imwrite(filename, img); cout << "Saved debug image: " << filename << endl; } } // ---------- 循迹ROI ---------- void GetROI(Mat src, Mat &ROI) { int width = src.cols; int height = src.rows; // 调整ROI，使用更靠近车辆的区域 Rect rect(Point(width/4, height*3/4), Point(3*width/4, height-20)); ROI = src(rect).clone(); } // ---------- 标志检测ROI ---------- void GetSignROI(Mat src, Mat &ROI) { int width = src.cols; int height = src.rows; // 扩大检测区域 Rect rect(Point(width/4, height/3), Point(3*width/4, 2*height/3)); ROI = src(rect).clone(); } // ---------- 图像预处理（优化版） ---------- void preprocessImg(Mat img, Mat &gray, Mat &canny) { cvtColor(img, gray, COLOR_BGR2GRAY); GaussianBlur(gray, gray, Size(7, 7), 1.0, 1.0); // 增加模糊程度 // 使用自适应Canny阈值 double median_val = cv::median(gray); int lower_thresh = max(0, (int)(0.5 * median_val)); int upper_thresh = min(255, (int)(1.5 * median_val)); Canny(gray, canny, lower_thresh, upper_thresh, 3); // 改善线条检测 improveLineDetection(canny); } // ---------- 改善线条检测 ---------- void improveLineDetection(Mat &canny) { // 使用形态学操作连接断开的边缘 Mat kernel = getStructuringElement(MORPH_RECT, Size(3, 3)); morphologyEx(canny, canny, MORPH_CLOSE, kernel); // 去除小噪点 vector<vector<Point>> contours; findContours(canny, contours, RETR_EXTERNAL, CHAIN_APPROX_SIMPLE); for (size_t i = 0; i < contours.size(); i++) { if (contourArea(contours[i]) < 10) { drawContours(canny, contours, (int)i, Scalar(0), -1); } } } // ---------- 字母预处理 ---------- Mat preprocessForLetter(Mat &roi) { Mat gray, binary; if (roi.channels() == 3) { cvtColor(roi, gray, COLOR_BGR2GRAY); } else { gray = roi.clone(); } GaussianBlur(gray, gray, Size(5, 5), 1.0); // 尝试多种二值化方法 Mat binary1, binary2; adaptiveThreshold(gray, binary1, 255, ADAPTIVE_THRESH_GAUSSIAN_C, THRESH_BINARY, 11, 2); threshold(gray, binary2, 0, 255, THRESH_BINARY | THRESH_OTSU); // 选择效果更好的二值化结果 int nonZero1 = countNonZero(binary1); int nonZero2 = countNonZero(binary2); binary = (nonZero1 > nonZero2) ? binary1 : binary2; // 对于深色背景浅色字母的情况，可能需要反转 if (nonZero1 < roi.total() * 0.3 || nonZero2 < roi.total() * 0.3) { bitwise_not(binary, binary); } Mat kernel_open = getStructuringElement(MORPH_RECT, Size(2, 2)); Mat kernel_close = getStructuringElement(MORPH_RECT, Size(6, 6)); morphologyEx(binary, binary, MORPH_OPEN, kernel_open); morphologyEx(binary, binary, MORPH_CLOSE, kernel_close); return binary; } // ---------- 背景存在检测（优化版） ---------- bool detectBackgroundPresence(Mat &img) { Mat roi; GetSignROI(img, roi); if (roi.empty()) { return false; } Mat hsv; cvtColor(roi, hsv, COLOR_BGR2HSV); Mat color_mask; if (BACKGROUND_COLOR == 1) { // 扩大红色检测范围 Mat red_mask1, red_mask2, red_mask3; inRange(hsv, Scalar(0, 30, 30), Scalar(20, 255, 255), red_mask1); inRange(hsv, Scalar(150, 30, 30), Scalar(180, 255, 255), red_mask2); // 增加亮度较低的红色检测 inRange(hsv, Scalar(0, 50, 20), Scalar(10, 255, 100), red_mask3); color_mask = red_mask1 | red_mask2 | red_mask3; } else { // 扩大蓝色检测范围 Mat blue_mask1, blue_mask2; inRange(hsv, Scalar(85, 30, 30), Scalar(145, 255, 255), blue_mask1); inRange(hsv, Scalar(100, 40, 20), Scalar(140, 255, 100), blue_mask2); color_mask = blue_mask1 | blue_mask2; } // 使用形态学操作填充区域 Mat kernel_dilate = getStructuringElement(MORPH_ELLIPSE, Size(7, 7)); dilate(color_mask, color_mask, kernel_dilate); Mat kernel_close = getStructuringElement(MORPH_ELLIPSE, Size(15, 15)); morphologyEx(color_mask, color_mask, MORPH_CLOSE, kernel_close); int color_pixels = countNonZero(color_mask); int total_pixels = roi.rows * roi.cols; double color_ratio = (double)color_pixels / total_pixels; cout << "Background presence - Color pixels: " << color_pixels << " / " << total_pixels << " (" << color_ratio*100 << "%)" << endl; saveDebugImage(color_mask, "bg_color_mask", 0); // 大幅降低阈值 return color_ratio > 0.005; // 从0.02降到0.005 } // ---------- A/B字母检测 ---------- int detectABLetter(Mat &img) { Mat roi; GetSignROI(img, roi); if (roi.empty()) { cout << "Sign ROI is empty!" << endl; return 0; } saveDebugImage(roi, "sign_roi", 0); // 直接使用颜色分割尝试找到字母 Mat hsv; cvtColor(roi, hsv, COLOR_BGR2HSV); Mat letter_mask; if (BACKGROUND_COLOR == 1) { // 红色背景上的字母可能是黑色或白色 // 寻找非红色区域 Mat red_mask; inRange(hsv, Scalar(0, 30, 30), Scalar(20, 255, 255), red_mask); inRange(hsv, Scalar(150, 30, 30), Scalar(180, 255, 255), letter_mask); letter_mask = ~red_mask; // 反转，得到非红色区域 } else { // 蓝色背景上的字母 Mat blue_mask; inRange(hsv, Scalar(85, 30, 30), Scalar(145, 255, 255), blue_mask); letter_mask = ~blue_mask; } // 形态学操作 Mat kernel = getStructuringElement(MORPH_RECT, Size(3, 3)); morphologyEx(letter_mask, letter_mask, MORPH_OPEN, kernel); saveDebugImage(letter_mask, "letter_mask", 0); vector<vector<Point>> contours; findContours(letter_mask, contours, RETR_EXTERNAL, CHAIN_APPROX_SIMPLE); cout << "Found " << contours.size() << " contours for letter detection" << endl; sort(contours.begin(), contours.end(), [](const vector<Point>& a, const vector<Point>& b) { return contourArea(a) > contourArea(b); }); if (!contours.empty()) { double area = contourArea(contours[0]); Rect rect = boundingRect(contours[0]); double aspect_ratio = (double)rect.width / rect.height; cout << "Main contour - Area: " << area << ", Bounding rect: " << rect.width << "x" << rect.height << ", Aspect ratio: " << aspect_ratio << endl; // 放宽条件 if (area > 200 && area < 50000 && aspect_ratio > 0.3 && aspect_ratio < 3.0) { Mat letter_roi = letter_mask(rect); saveDebugImage(letter_roi, "letter_candidate", 0); cout << " -> Testing for A/B shape" << endl; if (detect_A_shape(letter_roi)) { cout << "*** Detected A ***" << endl; Rect global_rect( rect.x + img.cols/4, rect.y + img.rows/3, rect.width, rect.height ); rectangle(img, global_rect, Scalar(0, 255, 0), 3); putText(img, "A", Point(global_rect.x, global_rect.y-10), FONT_HERSHEY_SIMPLEX, 1.5, Scalar(0, 255, 0), 3); return 1; } else if (detect_B_shape(letter_roi)) { cout << "*** Detected B ***" << endl; Rect global_rect( rect.x + img.cols/4, rect.y + img.rows/3, rect.width, rect.height ); rectangle(img, global_rect, Scalar(0, 255, 0), 3); putText(img, "B", Point(global_rect.x, global_rect.y-10), FONT_HERSHEY_SIMPLEX, 1.5, Scalar(0, 255, 0), 3); return 2; } else { cout << " -> Not A or B" << endl; } } else { cout << " -> Skipped due to area/aspect ratio" << endl; } } return 0; } // ---------- A形状检测 ---------- bool detect_A_shape(Mat &roi) { vector<vector<Point>> contours; vector<Vec4i> hierarchy; findContours(roi.clone(), contours, hierarchy, RETR_TREE, CHAIN_APPROX_SIMPLE); if (hierarchy.empty() || contours.empty()) return false; int valid_hole_count = 0; // 找到最大的轮廓 int main_contour_idx = -1; double max_area = 0; for (int i = 0; i < contours.size(); i++) { double area = contourArea(contours[i]); if (area > max_area) { max_area = area; main_contour_idx = i; } } if (main_contour_idx == -1) return false; // 统计孔洞 for (int i = 0; i < hierarchy.size(); i++) { if (hierarchy[i][3] == main_contour_idx) { double hole_area = contourArea(contours[i]); if (hole_area > 10) { // 最小孔洞面积 valid_hole_count++; } } } cout << " A shape - Valid holes: " << valid_hole_count << endl; return (valid_hole_count >= 1); // A至少有一个孔洞 } // ---------- B形状检测 ---------- bool detect_B_shape(Mat &roi) { vector<vector<Point>> contours; vector<Vec4i> hierarchy; findContours(roi.clone(), contours, hierarchy, RETR_TREE, CHAIN_APPROX_SIMPLE); if (hierarchy.empty() || contours.empty()) return false; int valid_hole_count = 0; // 找到最大的轮廓 int main_contour_idx = -1; double max_area = 0; for (int i = 0; i < contours.size(); i++) { double area = contourArea(contours[i]); if (area > max_area) { max_area = area; main_contour_idx = i; } } if (main_contour_idx == -1) return false; // 统计孔洞 for (int i = 0; i < hierarchy.size(); i++) { if (hierarchy[i][3] == main_contour_idx) { double hole_area = contourArea(contours[i]); if (hole_area > 10) { // 最小孔洞面积 valid_hole_count++; } } } cout << " B shape - Valid holes: " << valid_hole_count << endl; return (valid_hole_count >= 2); // B至少有两个孔洞 } // ---------- PID控制（稳定版） ---------- double PID(double error) { // 限制误差范围 double limited_error = max(min(error, 50.0), -50.0); double angle = kp * limited_error + kd * (limited_error - last_error); last_error = limited_error; return angle; } // ---------- 舵机角度转占空比 ---------- int atc(int angle) { int pulse_width = 500 + (angle / 180.0) * 2000; int duty = pulse_width / 20000.0 * 100; return duty; } // ---------- 硬件初始化 ---------- int dong() { if (gpioInitialise() < 0) { cout << "pigpio init error" << endl; return -1; } gpioSetMode(pwm_pin, PI_OUTPUT); gpioSetPWMfrequency(pwm_pin, pwm_freq1); gpioSetPWMrange(pwm_pin, pwm_range1); gpioSetMode(servo_pin, PI_OUTPUT); gpioSetPWMfrequency(servo_pin, pwm_freq2); gpioSetPWMrange(servo_pin, pwm_range2); gpioPWM(pwm_pin, init_duty); gpioPWM(servo_pin, atc(82)); cout << "pigpio ok!" << endl; sleep(2); return 0; } // ---------- 巡线控制（稳定版） ---------- int xunji(Mat frame) { Mat img, gray, canny; GetROI(frame, img); if (img.empty()) { cout << "Line ROI is empty!" << endl; return 0; } preprocessImg(img, gray, canny); int cols = canny.cols; int rows = canny.rows; saveDebugImage(canny, "line_canny", 0); // 改进的巡线算法 - 使用加权平均 vector<double> weights; vector<int> centers; double total_weight = 0; double weighted_sum = 0; // 从底部向上扫描，越靠近底部权重越高 for (int i = rows-1; i >= max(0, rows-80); i--) { int left_edge = -1; int right_edge = -1; // 寻找左边缘 for (int j = cols/3; j >= 5; j--) { if (canny.at<uchar>(i, j) == 255) { left_edge = j; break; } } // 寻找右边缘 for (int j = 2*cols/3; j < cols-5; j++) { if (canny.at<uchar>(i, j) == 255) { right_edge = j; break; } } // 如果找到左右边缘，计算中心点 if (left_edge != -1 && right_edge != -1) { int center = (left_edge + right_edge) / 2; double weight = (double)(i + 1) / rows; // 底部权重更高 centers.push_back(center); weights.push_back(weight); weighted_sum += center * weight; total_weight += weight; } } if (total_weight > 0 && !centers.empty()) { double center_avg = weighted_sum / total_weight; double error = center_avg - cols / 2.0; cout << "Line following - Valid rows: " << centers.size() << ", Center avg: " << center_avg << ", Target: " << cols/2 << ", Error: " << error << endl; double angle = PID(error); angle = 82 - angle; angle = max(min_ang, min(max_ang, angle)); cout << "Calculated angle: " << angle << endl; gpioPWM(servo_pin, atc((int)angle)); return 1; } else { cout << "Line lost! Only " << centers.size() << " valid rows found." << endl; // 丢失线路时保持直行，但稍微减速 gpioPWM(servo_pin, atc(82)); gpioPWM(pwm_pin, 8500); // 减速 return 0; } } // ---------- 执行动作函数 ---------- void performAction(int letter) { if (letter == 1) { cout << "=== Performing A Action: Turn Left ===" << endl; // 减速 gpioPWM(pwm_pin, 8000); usleep(300000); // 左转 gpioPWM(servo_pin, atc(75)); usleep(800000); // 转回直行并恢复正常速度 gpioPWM(servo_pin, atc(82)); gpioPWM(pwm_pin, 9300); usleep(400000); } else if (letter == 2) { cout << "=== Performing B Action: Turn Right ===" << endl; // 减速 gpioPWM(pwm_pin, 8000); usleep(300000); // 右转 gpioPWM(servo_pin, atc(89)); usleep(800000); // 转回直行并恢复正常速度 gpioPWM(servo_pin, atc(82)); gpioPWM(pwm_pin, 9300); usleep(400000); } } // ---------- 主函数 ---------- int main() { cout << "=== STABLE LINE FOLLOWING WITH A/B DETECTION ===" << endl; cout << "Background Color: " << (BACKGROUND_COLOR == 1 ? "RED" : "BLUE") << endl; cout << "A: Turn Left, B: Turn Right" << endl; cout << "=====================================" << endl; if (dong() < 0) { cout << "pigpio error !" << endl; return -1; } VideoCapture cap(0); if (!cap.isOpened()) { cout << "cap error" << endl; gpioPWM(pwm_pin, 0); gpioTerminate(); return -1; } // 设置摄像头参数 cap.set(CAP_PROP_FRAME_WIDTH, 640); cap.set(CAP_PROP_FRAME_HEIGHT, 480); cap.set(CAP_PROP_FPS, 30); cap.set(CAP_PROP_BRIGHTNESS, 50); cap.set(CAP_PROP_CONTRAST, 50); cap.set(CAP_PROP_SATURATION, 60); // 提高饱和度有助于颜色检测 Mat frame; int frame_count = 0; int detection_interval = 15; // 降低检测频率 int line_lost_count = 0; const int max_line_lost = 30; // 降低丢失阈值 int sign_detection_count = 0; const int sign_confirm_threshold = 2; cout << "Starting stable line following..." << endl; // 初始前进 gpioPWM(pwm_pin, 9300); try { while (cap.read(frame)) { frame_count++; // 正常巡线 int line_status = xunji(frame); if (line_status == 0) { line_lost_count++; if (line_lost_count > max_line_lost) { cout << "Line lost for too long, stopping!" << endl; gpioPWM(pwm_pin, 6000); break; } } else { line_lost_count = 0; // 恢复速度 gpioPWM(pwm_pin, 9300); } // 检测标志和字母（降低频率） if (frame_count % detection_interval == 0 && action_cooldown <= 0) { bool background_present = detectBackgroundPresence(frame); if (background_present) { sign_detection_count++; cout << "Background detected: " << sign_detection_count << "/" << sign_confirm_threshold << endl; if (sign_detection_count >= sign_confirm_threshold && !ab_detected) { int detected = detectABLetter(frame); if (detected != 0) { ab_detected = true; detected_letter = detected; cout << "=== LETTER DETECTED: " << (detected == 1 ? "A" : "B") << " ===" << endl; performAction(detected); action_cooldown = 120; // 冷却时间 sign_detection_count = 0; } } } else { sign_detection_count = 0; } } // 更新冷却时间 if (action_cooldown > 0) { action_cooldown--; } // 重置检测状态 if (action_cooldown == 0 && ab_detected) { ab_detected = false; detected_letter = 0; cout << "Reset detection state, ready for next sign" << endl; } usleep(20000); // 增加延迟，提高稳定性 } } catch (const exception& e) { cout << "Exception occurred: " << e.what() << endl; } // 清理 gpioPWM(pwm_pin, 0); gpioPWM(servo_pin, atc(82)); gpioTerminate(); cap.release(); cout << "Program exited!" << endl; return 0; }

最新发布

10-06

1. **背景检测阈值过低**： - 当前阈值设置为0.005（0.5%），可能会导致误检。建议适当提高阈值，例如0.01（1%），并在不同光照条件下测试。 2. **字母检测的鲁棒性**： - 字母检测依赖颜色分割（非背景区域）和...

#include <pigpio.h> #include <iostream> #include <unistd.h> #include <opencv2/opencv.hpp> #include <vector> using namespace cv; using namespace std; // ---------- 函数声明 ---------- void GetROI(Mat src, Mat &ROI); int detectAB(Mat &img); // 优化后的字母检测函数 double PID(double error1); int atc(int angle); int dong(); int xunji(Mat frame); void preprocessImg(Mat img, Mat &gray, Mat &canny); // ---------- 全局变量 ---------- const int pwm_pin = 13; const int servo_pin = 12; const int pwm_freq1 = 200; const int pwm_freq2 = 50; const int pwm_range1 = 40000; const int pwm_range2 = 100; const int init_duty = 10000; double last_error = 0; double kp = 0.3, kd = 0.08; double min_ang = 70, max_ang = 94; // ---------- ROI裁剪 ---------- void GetROI(Mat src, Mat &ROI) { int width = src.cols; int height = src.rows; Rect rect(Point(width/4, height/2), Point(3*width/4, height)); ROI = src(rect).clone(); } // ---------- 图像预处理 ---------- void preprocessImg(Mat img, Mat &gray, Mat &canny) { cvtColor(img, gray, COLOR_BGR2GRAY); GaussianBlur(gray, gray, Size(5, 5), 0.5, 0.5); Canny(gray, canny, 60, 120, 3); } // ---------- PID控制 ---------- double PID(double error) { double angle = kp * error + kd * (error - last_error); last_error = error; return angle; } // ---------- 舵机角度转占空比 ---------- int atc(int angle) { int pulse_width = 500 + (angle / 180.0) * 2000; int duty = pulse_width / 20000.0 * 100; return duty; } // ---------- 硬件初始化 ---------- int dong() { if (gpioInitialise() < 0) { cout << "pigpio初始化失败！" << endl; return -1; } gpioSetMode(pwm_pin, PI_OUTPUT); gpioSetPWMfrequency(pwm_pin, pwm_freq1); gpioSetPWMrange(pwm_pin, pwm_range1); gpioSetMode(servo_pin, PI_OUTPUT); gpioSetPWMfrequency(servo_pin, pwm_freq2); gpioSetPWMrange(servo_pin, pwm_range2); gpioPWM(pwm_pin, init_duty); sleep(2); gpioPWM(servo_pin, atc(82)); cout << "硬件初始化完成（舵机居中82°，电机就绪）" << endl; sleep(2); return 0; } int detectAB(Mat &img) { Mat roi, hsv; GetROI(img, roi); // 保留ROI处理 // 颜色空间转换与掩码处理 cvtColor(roi, hsv, COLOR_BGR2HSV); Mat blueMask, whiteMask, letters; //inRange(hsv, Scalar(90, 70, 70), Scalar(130, 255, 255), blueMask); // 蓝底 inRange(hsv, Scalar(0, 0, 200), Scalar(180, 30, 255), whiteMask); // 白字 Mat redMaskLow, redMaskHigh; inRange(hsv, cv::Scalar(0, 100, 100), cv::Scalar(10, 255, 255), redMaskLow); inRange(hsv, cv::Scalar(160, 100, 100), cv::Scalar(180, 255, 255), redMaskHigh); Mat redMask = redMaskLow | redMaskHigh; // 形态学优化（保留必要操作） Mat kernel = getStructuringElement(MORPH_RECT, Size(3, 3)); morphologyEx(whiteMask, whiteMask, MORPH_OPEN, kernel); // 联合掩码：只保留蓝底上的白字 //letters = whiteMask & blueMask; letters= whiteMask & redMask; // 轮廓检测与分析 vector<vector<Point>> contours; findContours(letters, contours, RETR_EXTERNAL, CHAIN_APPROX_SIMPLE); for (auto &contour : contours) { double area = contourArea(contour); // 面积过滤噪声 if (area < 500 || area > 5000) continue; Rect rect = boundingRect(contour); double aspect_ratio = (double)rect.width / rect.height; // 字母分类逻辑简化 if (aspect_ratio < 0.82) { // A通常细高 // 坐标转换到原图并绘制结果 Rect global_rect( rect.x + img.cols/4, rect.y + img.rows/2, rect.width, rect.height ); rectangle(img, global_rect, Scalar(0, 255, 255), 2); putText(img, "A", Point(global_rect.x, global_rect.y-10), FONT_HERSHEY_SIMPLEX, 1.2, Scalar(0, 215, 255), 2); return 1; } else if (aspect_ratio > 0.85 && aspect_ratio < 1.2) { // B接近正方 Rect global_rect( rect.x + img.cols/4, rect.y + img.rows/2, rect.width, rect.height ); rectangle(img, global_rect, Scalar(0, 255, 255), 2); putText(img, "B", Point(global_rect.x, global_rect.y-10), FONT_HERSHEY_SIMPLEX, 1.2, Scalar(0, 215, 255), 2); return 2; } } return 0; // 未检测到 } // ---------- 巡线控制 ---------- int xunji(Mat frame) { Mat img, gray, canny; GetROI(frame, img); preprocessImg(img, gray, canny); int cols = canny.cols, rows = canny.rows; vector<int> left(rows, -1), right(rows, -1); // 改为rows，因为我们要存储每一行的值 vector<int> mid(rows, -1); int mid_sum = 0, valid_cnt = 0; int start_row = min(300, rows - 1); int end_row = max(250, 0); // 从下往上扫描，从start_row到end_row for (int i = start_row; i >= end_row; i--) { bool left_lost = true, right_lost = true; int left_edge = -1, right_edge = -1; // 寻找左边缘：从中间向左搜索 for (int j = cols / 2; j >= 100; j--) { if (canny.at<uchar>(i, j) == 255) { left_edge = j; left_lost = false; break; } } if (left_lost) { left_edge = 0; // 如果没找到，设为0 } // 寻找右边缘：从中间向右搜索 for (int j = cols / 2; j < cols - 100; j++) { if (canny.at<uchar>(i, j) == 255) { right_edge = j; right_lost = false; break; } } if (right_lost) { right_edge = cols - 1; } // 如果左右边缘都找到，则计算中心 if (!left_lost && !right_lost) { int center = (left_edge + right_edge) / 2; mid[valid_cnt] = center; mid_sum += center; valid_cnt++; } } if (valid_cnt > 0) { double center_avg = mid_sum / valid_cnt; double error = center_avg - cols / 2; double angle = PID(error); angle = 82 - angle; // 82度是居中，根据误差调整 angle = max(min_ang, min(max_ang, angle)); gpioPWM(servo_pin, atc((int)angle)); } return 0; } // ---------- 主函数 ---------- int main() { if (dong() < 0) { cout << "硬件初始化失败，程序退出" << endl; return -1; } VideoCapture cap(0); if (!cap.isOpened()) { cout << "摄像头打开失败！" << endl; gpioPWM(pwm_pin, 0); gpioTerminate(); return -1; } Mat frame; bool isStopped = false; while (cap.read(frame) && !isStopped) { char key = waitKey(10); if (key == 27) break; if (!isStopped) { xunji(frame); } // 调用优化后的检测函数 int abType = detectAB(frame); if (abType == 1 && !isStopped) { cout << "检测到字母A → 左转并停车" << endl; gpioPWM(servo_pin, atc(75)); usleep(500000); gpioPWM(pwm_pin, 0); sleep(3); gpioPWM(servo_pin, atc(82)); isStopped = true; } else if (abType == 2 && !isStopped) { cout << "检测到字母B → 右转并停车" << endl; gpioPWM(servo_pin, atc(89)); usleep(500000); gpioPWM(pwm_pin, 0); sleep(3); gpioPWM(servo_pin, atc(82)); isStopped = true; } } gpioPWM(pwm_pin, 0); gpioPWM(servo_pin, atc(82)); gpioTerminate(); cap.release(); cout << "程序正常退出" << endl; return 0; }

09-26

double aspect_ratio = (double)rect.width / rect.height; // 形状特征分类 if (aspect_ratio ) { /* A字母处理 */ } else if (aspect_ratio > 0.85 && aspect_ratio ) { /* B字母处理 */ } } return 0; } ...

一种电流模DC-DC芯片中低延时电流比较器的设计.pdf

07-26

一种电流模DC-DC芯片中低延时电流比较器的设计.pdf

UC3842电源管理芯片详细解读。RS触发器在其中的应用控制PWM，很详细

二进制模----细微行动改变影响世界

12-18

2299

当MOS管关断时，INSENSE引脚无电流，为高阻态，则PWM比较器输出为低，PWM波占空比由振荡器决定，当MOS管导通时，INSENSE引脚电流逐渐增大，通过RS电阻INSENSE引脚电压逐渐拉高，当Vsense>1V时，PWM比较器输出为高，则RS触发器Reset引脚触发复位，RS触发器输出为高，则或门输出为高，UC3842输出端OUTPUT为低，MOS管关断，RS上电阻电流瞬间减小，INSENSE电压也快速地减小（<1V），PWM比较器输出为低，PWM波占空比由振荡器决定，如此往复。

锁存器原理脉冲电平作用

01-03

锁存器(Latch)是一种对脉冲电平敏感的存储单元电路，它们可以在特定输入脉冲电平作用下改变状态。

比较器的工作原理及性能指标介绍

u011878611的博客

08-29

9609

采用并联的NPN管和PNP管的结构作为比较器的输入级，以便比较器的输入电压可以扩展，使其下限可以低至最低水平，上限比电源电压高250mV，从而达到Beyond-theRail标准。该比较器的输入允许较大的共模电压。4.漏源电压：因为比较器只有两个不同的输出状态（零电平或电源电压），并且具有全功率摆幅特性的比较器的输出级是发射极跟随器，因此使其输入和输出信号压差很小。2.偏置电流：理想比较器的输入阻抗是无限的，因此从理论上讲，它对输入信号没有影响，但是实际比较器的输入阻抗不可能是无限的。

20200721 Sawtooth PWM和Symmetrical PWM

电力电子&电能质量求交流，加Q164429350

07-21

909

上面是锯齿

STM32G474_PWM输出的抖动模式

xl22126的博客

09-25

6095

看到哪记到哪抖动模式（Dithering mode）在查看手册的时候发现了这个模式，第一次看没看懂（可能是太困了），今天又看了一遍手册，大致理解了这个模式的作用。抖动模式的功能就是增加PWM的分辨率。手册的介绍是这样的：抖动模式 PWM的有效分辨率可以通过启动抖动模式来提高，使能TIMx_CR1寄存器中的DITHEN位来启动抖动模式。这适用于CCR（占空比分辨率增加）和ARR（PWM频率分辨率增加）。其工作原理是在16个连续的脉宽调制周期内稍微改变实际的CCR（或ARR）值（增加或不增加一个

B站记录——PWM捕获

EthanYhunt的博客

09-24

650

用定时器的输入捕获来计算输入信号的周期，因为这个例程只用到了一个输入捕获频道，依据的原理是中文参考手册上的图在捕获到上升沿的时候，会进入中断，两次上升沿之间的时间就是输入信号的周期。解决2个问题，一是输入时间太长，超过定时器的周期，溢出；二是怎么获得2次捕获，进而计算出输入时间。用一个全局的结构体变量，处理相关数据 typedef struct { FlagStatus Egde;//Egde = SET表示当前处于高电平;Egde = RESET表示当前处于低电平; uint8 uc.

pwm最后的解释

weixin_30463341的博客

03-04

1179

之前学东西总是模模糊糊，前几天看了pwm，虽然知道怎么配置，但是如果让我自己去写一个pwm的程序，我却不知如何下手。不知道如何配置他的频率和占空比。今天痛定思痛，决定彻底搞懂pwm。百度给的答案是： pwm的频率是指每秒钟信号从高电平到低电平再回到高电平的次数，占空比是高电平持续时间和低电平持续时间之间的比例。pwm的频率越高，其对输出的响应就会越快，频率越低输出响应越慢。 ...

PWM设计

fancysora的博客

09-04

537

PWM这个功能在PIC单片机上就有，但是如果你就要用51单片机的话，也是可以的，但是比较的麻烦你可以用定时器T0来控制频率，定时器T1来控制占空比：大致的的编程思路是这样的：T0定时器中断是让一个I0口输出高电平，在这个定时器T0的中断当中起动定时器T1，而这个T1是让IO口输出低电平，这样改变定时器T0的初值就可以改变频率，改变定时器T1的初值就可以改变占空比。希望对你有帮助。

IRQ和FIQ中断的区别

michaelcao1980的专栏

02-20

4万+

FIQ和IRQ是两种不同类型的中断，ARM为了支持这两种不同的中断，提供了对应的叫做FIQ和IRQ处理器模式（ARM有7种处理模式）。一般的中断控制器里我们可以配置与控制器相连的某个中断输入是FIQ还是IRQ,所以一个中断是可以指定为FIQ或者IRQ的，为了合理，要求系统更快响应，自身处理所耗时间也很短的中断设置为FIQ，否则就设置了IRQ。如果该中断设置为了IRQ，那么当该中

FIQ和IRQ区别

ll148305879的博客

06-06

1万+

FIQ和IRQ区别 FIQ和IRQ是两种不同类型的中断，ARM为了支持这两种不同的中断，提供了对应的叫做FIQ和IRQ处理器模式（ARM有7种处理模式）。一般的中断控制器里我们可以配置与控制器相连的某个中断输入是FIQ还是IRQ,所以一个中断是可以指定为FIQ或者IRQ的，为了合理，要求系统更快响应，自身处理所耗时间也很短的中断设置为FIQ，否则就设置了IRQ。如果该中断设置为了IRQ，...