STM32 摄像头颜色识别实战：OV7725/OV2640 驱动与算法解析

局限性：

• 性能限制：频率较低，传输速率受限，不适合高分辨率或高帧率应用。
• 资源消耗：占用大量 MCU 引脚，影响其他功能。

2. DCMI 驱动

DCMI（Digital Camera Memory Interface）是 STM32 等微控制器中专门用于连接图像传感器的硬件接口。

优势：

• 高效传输：专为高速图像数据传输设计，支持 DMA 直接内存访问，不占用 CPU 资源。
• 自动化：自动管理时序和数据流，稳定性高。
• 多格式支持：支持 RGB、YCbCr 等多种格式。

四、颜色识别的步骤和原理

接下来详细讲解颜色识别的算法逻辑和实现步骤。

1. RGB 阈值法

RGB 阈值法通过设定每个颜色通道（R、G、B）的数值范围来识别颜色。每个像素用 (R, G, B) 表示，分量值通常在 0 到 255 之间。

原理： 预设阈值范围来判断颜色。例如识别红色：R 大于某阈值，G 和 B 小于某阈值。

实现步骤：

1. 硬件连接：确保 STM32 与 OV7725 正确连接，配置 DCMI 接口。
2. 捕获数据：使用 DCMI 驱动捕获图像，通过 DMA 传输到内存。
3. 遍历处理：读取像素值，提取 RGB 分量。
4. 阈值匹配：比较像素值与预设范围。

// 假设已捕获并存储了图像数据到内存（例如：frame_buffer）
void process_image(uint16_t *frame_buffer, uint32_t width, uint32_t height) {
    for (uint32_t y = 0; y < height; y++) {
        for (uint32_t x = 0; x < width; x++) {
            uint16_t pixel = frame_buffer[y * width + x];
            // 提取 RGB 分量（假设图像格式为 RGB565）
            uint8_t R = (pixel >> 11) & 0x1F;
            uint8_t G = (pixel >> 5) & 0x3F;
            uint8_t B = pixel & 0x1F;
            
            // 将 RGB 分量转换为 8 位
            R = (R * 255) / 31;
            G = (G * 255) / 63;
            B = (B * 255) / 31;
            
            // 判断是否属于某个颜色范围（例如识别红色）
            if (R > 200 && G < 100 && B < 100) {
                // 如果符合红色范围，执行某些操作
            }
        }
    }
}

示例配置：

• 红色：R: [200, 255], G: [0, 100], B: [0, 100]
• 绿色：R: [0, 100], G: [200, 255], B: [0, 100]
• 蓝色：R: [0, 100], G: [0, 100], B: [200, 255]

2. HSV 空间转换

HSV（色相、饱和度、明度）空间更接近人类感知，对光照变化更鲁棒。

• 色相（H）：0°~360°，代表颜色种类。
• 饱和度（S）：0%~100%，代表纯度。
• 明度（V）：0%~100%，代表亮度。

RGB 到 HSV 转换公式： 需先将 RGB 归一化至 0~1，计算最大值、最小值及色差，再根据公式推导 H、S、V。

实现步骤：

1. 图像遍历：获取每个像素的 RGB 值。
2. 空间转换：调用转换函数得到 HSV 值。
3. 定义范围：设定目标颜色的 H、S、V 区间。
4. 判断标记：若像素值在范围内，标记为目标颜色。

void RGB_to_HSV(uint8_t R, uint8_t G, uint8_t B, float *H, float *S, float *V) {
    float r = R / 255.0f;
    float g = G / 255.0f;
    float b = B / 255.0f;
    float Cmax = fmaxf(fmaxf(r, g), b);
    float Cmin = fminf(fminf(r, g), b);
    float delta = Cmax - Cmin;

    // 计算色相
    if (delta == 0) { *H = 0; }
    else if (Cmax == r) { *H = 60 * fmodf(((g - b) / delta), 6); }
    else if (Cmax == g) { *H = 60 * (((b - r) / delta) + 2); }
    else { *H = 60 * (((r - g) / delta) + 4); }
    if (*H < 0) { *H += 360; }

    // 计算饱和度
    if (Cmax == 0) { *S = 0; }
    else { *S = (delta / Cmax) * 100; }

    // 计算明度
    *V = Cmax * 100;
}

void identify_color_with_HSV(uint16_t *frame_buffer, uint32_t width, uint32_t height) {
    for (uint32_t y = 0; y < height; y++) {
        for (uint32_t x = 0; x < width; x++) {
            uint16_t pixel = frame_buffer[y * width + x];
            uint8_t R = (pixel >> 11) & 0x1F;
            uint8_t G = (pixel >> 5) & 0x3F;
            uint8_t B = pixel & 0x1F;
            
            float H, S, V;
            RGB_to_HSV(R * 255 / 31, G * 255 / 63, B * 255 / 31, &H, &S, &V);
            
            // 判断是否为红色：H 在 [0, 10] 或 [350, 360]，S 和 V 都在 [50, 100]
            if ((H >= 0 && H <= 10 || H >= 350 && H <= 360) && S >= 50 && V >= 50) {
                frame_buffer[y * width + x] = 0xF800; // 标记为红色
            }
        }
    }
}

3. 颜色滤波器

颜色滤波器基于颜色空间转换与筛选，提取特定颜色区域。常用 RGB 和 HSV 空间，其中 HSV 更适合滤波。

工作流程：

1. 读取图像：加载数据到内存。
2. 转换空间：RGB 转 HSV。
3. 设定范围：定义感兴趣的颜色区间。
4. 像素检测：遍历像素，判断是否在范围内。
5. 输出结果：保留符合条件的像素，过滤背景。

五、代码工程开源

以下是 STM32 单片机驱动摄像头对颜色识别的关键代码片段，整体工程逻辑参考以下结构。

EasyTracer_color.h

#ifndef EASY_TRACERED_H
#define EASY_TRACERED_H
#define IMG_X 0
#define IMG_Y 0
#define IMG_W 240
#define IMG_H 300
#define ALLOW_FAIL_PER 3
#define ITERATE_NUM 7

typedef struct{
    unsigned char H_MIN;
    unsigned char H_MAX;
    unsigned char S_MIN;
    unsigned char S_MAX;
    unsigned char L_MIN;
    unsigned char L_MAX;
    unsigned int WIDTH_MIN;
    unsigned int HIGHT_MIN;
    unsigned int WIDTH_MAX;
    unsigned int HIGHT_MAX;
}TARGET_CONDI;

typedef struct{
    unsigned int x;
    unsigned int y;
    unsigned int w;
    unsigned int h;
}RESULT;

int Trace(const TARGET_CONDI *Condition, RESULT *Resu);
#endif

EasyTracer_color.c

#include "EasyTracer_color.h"
#include "LCD.h"
#define min3v(v1, v2, v3) ((v1)>(v2)? ((v2)>(v3)?(v3):(v2)):((v1)>(v3)?(v3):(v1)))
#define max3v(v1, v2, v3) ((v1)<(v2)? ((v2)<(v3)?(v3):(v2)):((v1)<(v3)?(v3):(v1)))

/* 数据类型备注（STM32F4）：
   typedef unsigned char uint8_t; u8
   typedef unsigned short int uint16_t; u16
   typedef unsigned int uint32_t; u32
*/

// RGB 颜色格式结构体
typedef struct {
    unsigned char red;
    unsigned char green;
    unsigned char blue;
}COLOR_RGB;

// 色相 (H)、饱和度 (S)、明度 (L) 颜色格式结构体
typedef struct {
    unsigned char hue;
    unsigned char saturation;
    unsigned char luminance;
}COLOR_HSL;

// 搜索图像窗口区域
typedef struct {
    unsigned int X_Start;
    unsigned int X_End;
    unsigned int Y_Start;
    unsigned int Y_End;
}SEARCH_AREA;

extern unsigned short LCD_ReadPoint(unsigned short x,unsigned short y);

static void ReadColor(unsigned int x,unsigned int y,COLOR_RGB *Rgb) {
    unsigned short C16;
    C16 = LCD_ReadPoint(x,y);
    Rgb->red = (unsigned char)((C16&0xf800)>>8);
    Rgb->green = (unsigned char)((C16&0x07e0)>>3);
    Rgb->blue = (unsigned char)((C16&0x001f)<<3);
}

static void RGBtoHSL(const COLOR_RGB *Rgb, COLOR_HSL *Hsl) {
    int h,s,l,maxVal,minVal,difVal;
    int r = Rgb->red;
    int g = Rgb->green;
    int b = Rgb->blue;
    maxVal = max3v(r, g, b);
    minVal = min3v(r, g, b);
    difVal = maxVal-minVal;
    l = (maxVal+minVal)*240/255/2;
    if(maxVal == minVal){
        h = 0; s = 0;
    } else {
        if(maxVal==r) {
            if(g>=b) h = 40*(g-b)/(difVal);
            else h = 40*(g-b)/(difVal) + 240;
        } else if(maxVal==g) h = 40*(b-r)/(difVal) + 80;
        else if(maxVal==b) h = 40*(r-g)/(difVal) + 160;
        if(l == 0) s=0;
        else if(l<=120) s = (difVal)*240/(maxVal+minVal);
        else s = (difVal)*240/(511 - (maxVal+minVal));
    }
    Hsl->hue = (unsigned char)(((h>240)? 240 : ((h<0)?0:h)));
    Hsl->saturation = (unsigned char)(((s>240)? 240 : ((s<0)?0:s)));
    Hsl->luminance = (unsigned char)(((l>240)? 240 : ((l<0)?0:l)));
}

static int ColorMatch(const COLOR_HSL *Hsl,const TARGET_CONDI *Condition) {
    if( Hsl->hue > Condition->H_MIN && Hsl->hue < Condition->H_MAX &&
        Hsl->saturation > Condition->S_MIN && Hsl->saturation < Condition->S_MAX &&
        Hsl->luminance > Condition->L_MIN && Hsl->luminance < Condition->L_MAX )
        return 1;
    else return 0;
}

static int SearchCentre(unsigned int *x,unsigned int *y,const TARGET_CONDI *Condition,const SEARCH_AREA *Area) {
    unsigned int SpaceX,SpaceY,i,j,k,FailCount=0;
    COLOR_RGB Rgb;
    COLOR_HSL Hsl;
    SpaceX = Condition->WIDTH_MIN/3;
    SpaceY = Condition->HIGHT_MIN/3;
    for(i=Area->Y_Start;i<Area->Y_End;i+=SpaceY){
        for(j=Area->X_Start;j<Area->X_End;j+=SpaceX){
            FailCount=0;
            for(k=0;k<SpaceX+SpaceY;k++){
                if(k<SpaceX) ReadColor(j+k,i+SpaceY/2,&Rgb);
                else ReadColor(j+SpaceX/2,i+(k-SpaceX),&Rgb);
                RGBtoHSL(&Rgb,&Hsl);
                if(!ColorMatch(&Hsl,Condition)) FailCount++;
                if(FailCount>((SpaceX+SpaceY)>>ALLOW_FAIL_PER)) break;
            }
            if(k==SpaceX+SpaceY){
                *x = j+SpaceX/2;
                *y = i+SpaceY/2;
                return 1;
            }
        }
    }
    return 0;
}

static int Corrode(unsigned int oldx,unsigned int oldy,const TARGET_CONDI *Condition,RESULT *Resu) {
    unsigned int Xmin,Xmax,Ymin,Ymax,i,FailCount=0;
    COLOR_RGB Rgb;
    COLOR_HSL Hsl;
    for(i=oldx;i>IMG_X;i--){
        ReadColor(i,oldy,&Rgb);
        RGBtoHSL(&Rgb,&Hsl);
        if(!ColorMatch(&Hsl,Condition)) FailCount++;
        if(FailCount>(((Condition->WIDTH_MIN+Condition->WIDTH_MAX)>>2)>>ALLOW_FAIL_PER)) break;
    }
    Xmin=i;
    FailCount=0;
    for(i=oldx;i<IMG_X+IMG_W;i++){
        ReadColor(i,oldy,&Rgb);
        RGBtoHSL(&Rgb,&Hsl);
        if(!ColorMatch(&Hsl,Condition)) FailCount++;
        if(FailCount>(((Condition->WIDTH_MIN+Condition->WIDTH_MAX)>>2)>>ALLOW_FAIL_PER)) break;
    }
    Xmax=i;
    FailCount=0;
    for(i=oldy;i>IMG_Y;i--){
        ReadColor(oldx,i,&Rgb);
        RGBtoHSL(&Rgb,&Hsl);
        if(!ColorMatch(&Hsl,Condition)) FailCount++;
        if(FailCount>(((Condition->HIGHT_MIN+Condition->HIGHT_MAX)>>2)>>ALLOW_FAIL_PER)) break;
    }
    Ymin=i;
    FailCount=0;
    for(i=oldy;i<IMG_Y+IMG_H;i++){
        ReadColor(oldx,i,&Rgb);
        RGBtoHSL(&Rgb,&Hsl);
        if(!ColorMatch(&Hsl,Condition)) FailCount++;
        if(FailCount>(((Condition->HIGHT_MIN+Condition->HIGHT_MAX)>>2)>>ALLOW_FAIL_PER)) break;
    }
    Ymax=i;
    Resu->x = (Xmin+Xmax)/2;
    Resu->y = (Ymin+Ymax)/2;
    Resu->w = Xmax-Xmin;
    Resu->h = Ymax-Ymin;
    if( ((Xmax-Xmin)>(Condition->WIDTH_MIN)) && ((Ymax-Ymin)>(Condition->HIGHT_MIN)) &&
        ((Xmax-Xmin)<(Condition->WIDTH_MAX)) && ((Ymax-Ymin)<(Condition->HIGHT_MAX)) )
        return 1;
    else return 0;
}

int Trace(const TARGET_CONDI *Condition,RESULT *Resu) {
    unsigned int i;
    static unsigned int x0,y0,flag=0;
    static SEARCH_AREA Area={IMG_X,IMG_X+IMG_W,IMG_Y,IMG_Y+IMG_H};
    RESULT Result;
    if(flag==0){
        if(SearchCentre(&x0,&y0,Condition,&Area)) flag=1;
        else {
            Area.X_Start= IMG_X ; Area.X_End = IMG_X+IMG_W ;
            Area.Y_Start= IMG_Y ; Area.Y_End = IMG_Y+IMG_H ;
            if(SearchCentre(&x0,&y0,Condition,&Area)){ flag=1; return 1; }
            else { flag=0; return 0; }
        }
    }
    Result.x = x0;
    Result.y = y0;
    for(i=0;i<ITERATE_NUM;i++) Corrode(Result.x,Result.y,Condition,&Result);
    if(Corrode(Result.x,Result.y,Condition,&Result)){
        x0=Result.x; y0=Result.y;
        Resu->x=Result.x; Resu->y=Result.y;
        Resu->w=Result.w; Resu->h=Result.h;
        flag=1;
        Area.X_Start= Result.x - ((Result.w)<<1);
        Area.X_End = Result.x + ((Result.w)<<1);
        Area.Y_Start= Result.y - ((Result.h)<<1);
        Area.Y_End = Result.y + ((Result.h)<<1);
        return 1;
    } else{
        flag=0; return 0;
    }
}

rgb565.c

#include <rgb565.h>
#include "EasyTracer_color.h"
#include "lcd.h"
const u8*EFFECTS_TBL[7]={"Normal","Negative","B&W","Redish","Greenish","Bluish","Antique"};

int x=0,y=0;
TARGET_CONDI Conditionred={215,240,20,240,30,160,15,15,200,200};
RESULT Resured;
u8 ov_frame=0;

void rgb565_test(void) {
    OV2640_RGB565_Mode();
    My_DCMI_Init();
    DCMI_DMA_Init((u32)&LCD->LCD_RAM,1,DMA_MemoryDataSize_HalfWord,DMA_MemoryInc_Disable);
    OV2640_OutSize_Set(240,300);
    DCMI_Start();
    while(1){ delay_ms(10); }
}

void DCMI_IRQHandler(void) {
    if(DCMI_GetITStatus(DCMI_IT_FRAME)==SET){
        DCMI_Stop();
        if(Trace(&Conditionred,&Resured)){
            LCD_Fill(Resured.x-Resured.w/2,Resured.y-Resured.h/2,Resured.x+Resured.w/2,Resured.y-Resured.h/2+1,0xf800);
            LCD_Fill(Resured.x-Resured.w/2,Resured.y-Resured.h/2,Resured.x-Resured.w/2+1,Resured.y+Resured.h/2,0xf800);
            LCD_Fill(Resured.x-Resured.w/2,Resured.y+Resured.h/2,Resured.x+Resured.w/2,Resured.y+Resured.h/2+1,0xf800);
            LCD_Fill(Resured.x+Resured.w/2,Resured.y-Resured.h/2,Resured.x+Resured.w/2+1,Resured.y+Resured.h/2,0xf800);
            LCD_Fill(Resured.x-2,Resured.y-2,Resured.x+2,Resured.y+2,0xf800);
            x=Resured.x; y=Resured.y;
        }
        ov_frame++;
        DCMI_Start();
        DCMI_ClearITPendingBit(DCMI_IT_FRAME);
        LED1=!LED1;
    }
}

void TIM3_IRQHandler(void) {
    if(TIM_GetITStatus(TIM3,TIM_IT_Update)==SET){
        printf("framerate is %d \r\n",ov_frame);ov_frame=0;
        printf("x is %d ，y is %d \r\n",x,y);
    }
    TIM_ClearITPendingBit(TIM3,TIM_IT_Update);
}