Conexión del módulo de cámara OV7670 con STONE Módulo de visualización

2023-03-02 / Proyectos

Este artículo presentará la conexión del módulo de cámara ov7670 con el STONE módulo de visualización visualización de imágenes de la cámara a través de un módulo de visualización en serie. Los métodos y el código descritos en este artículo son solo para pruebas de desarrolladores individuales y no pueden garantizar la estabilidad comercial.

Conexión del módulo de cámara ov7670 con el STONE módulo de visualización, la función principal

  1. La pantalla muestra las imágenes recopiladas por la cámara en tiempo real
  2. Haga clic en el botón para tomar una imagen y guardarla en la tarjeta TF
  3. Cambiar colores y escala de grises
  4. La resolución se puede cambiar (240*320, 240*240, 160*160, 80*80)
  5. Puede cambiar al modo de visualización de imágenes.
  6. Puedes navegar por la última imagen.
  7. Puedes navegar a la siguiente imagen.

Antes de continuar con este proyecto, echemos un vistazo a los módulos de hardware que se necesitan.

  1. STONE Módulo de pantalla serie de resolución 7*800 de 480 pulgadas
  2. STM32F103ZE placa de desarrollo
  3. Módulo de cámara OV7670
  4. Una pequeña cantidad de alambre relevante

Placa de desarrollo STM32F103ZE

ov7670-módulo-de-cámara-conexión-con STONE-módulo de pantalla

Esta placa de desarrollo tiene una serie de características integradas

  1. Chip de núcleo Cortex-m3, STM32F103ZET6,
  2. perno 144P
  3. Oscilador de cristal externo 8M, oscilador de cristal de reloj 32768Hz
  4. Enchufe estándar de 20P, interfaz JTAG, utilizado para descargar programas de depuración como Jlink, Ulink y st-link
  5. Inserción estándar de pin 4P, interfaz SWD, use comunicación de 2 hilos para depurar y descargar el programa
  6. Todos los puertos de E/S se utilizan para insertar agujas para una expansión conveniente del experimento
  7. Circuito de conversión de puerto serial USB-TTL, realizando comunicación de puerto serial de interfaz USB
  8. circuito adaptador de descarga automática, use la descarga del puerto serie sin cambios frecuentes, una clave para descargar
  9. Circuito de conversión MAX232, adecuado para línea serial externa
  10. Receptor de infrarrojos integrado, función de recepción de infrarrojos remota del usuario
  11. Zócalo DS18B20, insertado directamente en el chip para lograr la función de medición de temperatura digital
  12. con batería de respaldo de reloj, mantenga el reloj y la información importante sin pérdida de energía
  13. Chip EEPROM 24c02 para almacenar información de usuario común y usar IIC para comunicación
  14. FLASH chip W25Q64,8M de memoria, puede almacenar imágenes, datos del sistema y otra información
  15. Soporte de tarjeta SD en modo SPI, tarjeta TF, comunicación PI
  16. Soporte de tarjeta SD en modo SDIO, tarjeta TF, interfaz SDIO dedicada, alta velocidad, estable.
  17. Zócalo RF24L01 para probar la comunicación inalámbrica (se requieren al menos 2 máquinas)
  18. Función de entrada de tecla normal de 3 vías, interfaz hombre-máquina
  19. Botón de activación de 1 vía, utilizado para despertar desde el bajo consumo de energía o el modo de espera
  20. Lámpara LED del usuario de 2 vías, haciendo instrucciones básicas de estado y operación
  21. 1 interfaz de dispositivo USB, utilizada para depurar funciones de dispositivos USB, como lector de tarjetas, funciones de puerto serie USB
  22. La interfaz LCD de pantalla a color TFT, incluida la interfaz de pantalla táctil, se puede insertar directamente en la pantalla de soporte
  23. Interfaz reservada de la cámara, compatible con el módulo de la cámara para lograr la función de presentación de video
  24. Zumbador n° 1
  25. 1 función de botón táctil
  26. fusible de autorecuperación para proteger la computadora de daños
  27. Botón de reinicio
  28. Indicador de encendido
  29. Elija insertar el pin
  30. Seleccione el pin con voltaje de referencia VREF
  31. PUEDE, pasador de interruptor USB
  32. Inserción del pin de la fuente de alimentación externa de 3.3v
  33. Inserción del pin de la fuente de alimentación de expansión externa de 5V

Pero, de hecho, solo usamos la interfaz de su cámara y el puerto serie, y la interfaz de la tarjeta TF

STONE Módulo de visualización TFT-LCD

STONE STVC070WT-01 es un módulo de pantalla de 7 pulgadas con una resolución de 800*480. Este módulo de visualización puede adquirirse en STONEel sitio web oficial de o desde STONEEnlace de la plataforma de compras en línea.
El modo de comunicación de STONE stvc070wt-01 es uart-rs232 y uart-ttl. En este proyecto, utilicé el modo de comunicación uart-TTL.
La forma de desarrollo del módulo de visualización es simple, la MCU solo necesita a través de UART enviar una instrucción al STONE, el contenido del módulo de visualización, el control está bien, el mismo principio cuando un usuario toca el STONE pantalla de visualización, módulo de visualización e instrucciones relacionadas enviadas a MCU a través de UART, y luego MCU para controlar los dispositivos correspondientes (como rotación del motor, interruptor de luz, etc.).

7 pulgadas STONE STVC070WT-01

Los materiales proporcionados por el fabricante son los siguientes:

ov7670-módulo-de-cámara-conexión-con STONE-módulo de pantalla

Lista de empaque principal

  1. Transferencia de conexión y conexión.
  2. Placa adaptadora USB-TTL
  3. Unidad flash USB (incluidos los materiales de desarrollo)
  4. cable USB micro
  5. placa de transferencia USB
  6. STONE Módulo de visualización STVC070WT-01
  7. Adaptador de corriente 12V

STONE Perfil del módulo de pantalla

STVC070WT-01 es una pantalla TFT y un controlador táctil. Incluye procesador, programa de control, controlador, flash, puerto RS232/RS485/TTL, pantalla táctil, fuente de alimentación, etc., es un potente sistema de visualización
El sistema operativo es simple y puede ser controlado por cualquier microcomputadora de un solo chip. STVC070WT-01 puede usarse para realizar todas las funciones básicas, como visualización de texto, visualización de imágenes, visualización de curvas, función táctil, función de video y audio, etc.

  • CPU y controladores Cortex incorporados
  • Puede ser controlado por cualquier microordenador de un solo chip.
  • mostrar imágenes/texto/curvas
  • 65536 pantalla TFT a color
  • - se puede tocar
  • Interfaz RS232 / RS485 / TTL UART y puerto USB
  • amplio rango de voltaje

STVC070WT-01 Principio de control del módulo de visualización

El módulo TFT-LCD se comunica con la MCU mediante el comando (hexadecimal) y la MCU funcionará de acuerdo con el comando que reciba.

ov7670-módulo-de-cámara-conexión-con STONE-módulo de pantalla

Se requieren tres pasos para completar el desarrollo del firmware del STONE módulo de visualización

Usar STONEEl módulo TFT-LCD de solo requiere 3 pasos:

  1. Diseñe un conjunto de imágenes hombre-máquina (UI).
  2. UART-TTL se conecta directamente a la MCU del cliente.
  3. Escriba un programa simple, por la MCU a través del módulo TFT-LCD de control de comando. (código hexadecimal).

El marco de comando en serie del módulo TFT LCD consta de cinco bloques de datos, todos los cuales están representados en formato hexadecimal. La forma en que se transfieren los datos a MSB. Por ejemplo, para 0x1234, primero se envía 0x12 y luego se envía 0x34.

diseño de imagen de interfaz de usuario

El usuario diseña la interfaz de usuario usando Photoshop u otro software
La interfaz que diseñé es la siguiente:

ov7670-módulo-de-cámara-conexión-con STONE-módulo de pantalla

La primera imagen es la imagen de la pantalla principal y la segunda imagen es el efecto cuando se presiona el botón.

Use el conjunto de software TOOL2019 para generar el archivo de configuración del módulo LCD

ov7670-módulo-de-cámara-conexión-con STONE-módulo de pantalla

Haga clic en el botón de flecha para generar el archivo de configuración y luego descargue el archivo de configuración en el módulo de visualización para mostrar la interfaz de usuario que diseñamos.
No entraré en los detalles de esta parte del contenido y del tutorial, puede ir a la STONE sitio web para descargar un tutorial muy detallado.
Además, también necesitamos diseñar una imagen idéntica al efecto cuando se presiona el botón. Solo necesitamos cambiar el color de la posición del botón a la siguiente tabla.

ov7670-módulo-de-cámara-conexión-con STONE-módulo de pantalla

STM32 MCU y VO7670 Cableado y soldadura

En el contenido anterior, introduje la operación de desarrollo relevante de STONE STVC070WT-01. En el siguiente contenido, me centraré en el MCU STM32 y la cámara VO7670. Antes de hacer eso, echemos un vistazo a cómo se conecta la parte de hardware del proyecto.

Un diagrama de cableado completo para el STONE proyecto

ov7670-módulo-de-cámara-conexión-con STONE-módulo de pantalla

Módulo OV7670 — Placa de desarrollo STM32:

OV_D0 ~ D7 — — — — — — — — — — – PC0 ~ 7
OV_SCL — — — — — — — — — — — — — PD3
OV_SDA — — — — — — — — — — — — PG13
OV_VSYNC — — — — — — — — — — — — PA8
FIFO_RRST — — — — — — — — — — – PG14
FIFO_OE — — — — — — — — — — – PG15
FIFO_WRST — — — — — — — — — — — — PD6
FIFO_WEN — — — — — — — — — — — — — PB3
FIFO_RCLK — — — — — — — — — — — — — PB4

El adaptador de corriente es de 12 V y necesita alimentar el STONE módulo de pantalla stvc070wt-01 y encienda el módulo MCU y el OV7670 a través del reductor de CC-CC a 5 voltios.

Accesorios utilizados en el proyecto.

Los principales accesorios son:

  1. Placa de desarrollo STM32F103ZE
  2. Módulo reductor dc-dc
  3. Conmutación UART

Dado que el modo de comunicación predeterminado de STONE STVC070WT-01 es uart-TTL, no necesitamos la interfaz de RS232 para cambiar la conexión y eliminar la interfaz de RS232:

ov7670-módulo-de-cámara-conexión-con STONE-módulo de pantalla

Soldadura

Al soldar estas partes juntas, el efecto es el siguiente:

ov7670-módulo-de-cámara-conexión-con STONE-módulo de pantalla

ov7670-módulo-de-cámara-conexión-con STONE-módulo de pantalla

Cuando esta parte esté lista, puede escribir el programa para la MCU.

Módulo de cámara OV7670

Diagrama de bloques funcional de OV7670

OV7670 es un tipo de sensor de imagen, la temperatura de funcionamiento es de -30 ℃-70 ℃, el voltaje analógico es de 2.5-3.0 v, la matriz fotosensible es de 640*480 y el consumo de energía es de 60 mW/15 fps. Menos de 20 uA en latencia .
Tamaño pequeño, bajo voltaje de funcionamiento, que proporciona todas las funciones de una sola cámara VGA y procesador de imagen. A través del control del bus SCCB, puede ingresar el cuadro completo, el submuestreo, la ventana y otras formas de varios datos de imagen de resolución de 8 bits. La imagen VGA del producto alcanza un máximo de 30 fotogramas por segundo. Los usuarios tienen control total sobre la calidad de la imagen, el formato de datos y la transmisión. Todas las funciones de procesamiento de imágenes, incluida la curva gamma, el balance de blancos, la saturación, el croma, etc., se pueden programar a través de la interfaz SCCB. Al reducir o eliminar los defectos ópticos o electrónicos, como el ruido de patrón fijo, el soporte de la cola, la flotación, etc., se puede mejorar la calidad de la imagen para obtener imágenes en color claras y estables.
OV7670 es un sensor de imagen CMOS VGA de 1/6 de pulgada producido por OV (OmniVision). La detección
El dispositivo es de tamaño pequeño, bajo voltaje de trabajo y ofrece todas las funciones de una sola cámara VGA y procesador de imágenes. A través del control del bus SCCB, puede generar el cuadro completo, el submuestreo, la ventana y otras formas de datos de imagen de 8 bits de varias resoluciones. La imagen VGA del producto alcanza un máximo de 30 fotogramas por segundo. Los usuarios tienen control total sobre la calidad de la imagen, el formato de datos y la transmisión. Todos los procesos de procesamiento de imágenes, incluidos la curva gamma, el balance de blancos, el grado, el color, etc., se pueden programar a través de la interfaz SCCB. El sensor de imagen OmniVision UTILIZA una tecnología de sensor única para mejorar la calidad de la imagen al reducir o eliminar los defectos ópticos o electrónicos, como el ruido de patrón fijo. , soporte de cola, flotante, etc., para obtener imágenes en color claras y estables.
Las características de OV7670 incluyen:

  1.  Alta sensibilidad, bajo voltaje adecuado para aplicaciones integradas
  2. Interfaz SCCB estándar, compatible con la interfaz IIC
  3. Compatible con RawRGB, RGB(gbr4:2:2, RGB565/RGB555/RGB444), YUV(4:2:2) y YCbCr
  4. Admite VGA, CIF y todos los tamaños desde CIF hasta 40*30
  5. Admite control de exposición automático, control de ganancia automático, balance de blancos automático y eliminación automática de rayas de luz
  6. Calibración automática del nivel de negro y otras funciones de control automático. Al mismo tiempo, admite saturación de color, tono, gamma, nitidez y otras configuraciones.
  7. Soporte para Flash
  8. Soporta escalado de imagen

El sensor OV7670 incluye los siguientes módulos funcionales.

1. Matriz de imágenes

OV7670 tiene un total de 656*488 píxeles, de los cuales 640*480 son válidos (es decir, los píxeles efectivos son 30 W).

2. Generador de tiempo de video

El generador de secuencias tiene las siguientes funciones: control de secuencia completa y generación de velocidad de fotogramas (salida en 7 formatos diferentes), generador de señal interna 535 y distribución, temporización de velocidad de fotogramas, control de exposición automático y salida de temporización externa (VSYNC, HREF/HSYNC, y PCLK).

3. Procesamiento de señales analógicas

Procesamiento de señales analógicas todas las funciones analógicas e incluye ganancia automática (AGC) y balance de blancos automático (AWB).

4. Conversión A/D (A/D)

Después de que la señal original pasa por el módulo del procesador analógico, ingresa a un convertidor A/D de 10 bits a través de los canales G y BR.
El conversor A/D funciona a una frecuencia A de 12M, totalmente sincronizado con la frecuencia de píxeles (la frecuencia de conversión está relacionada con la velocidad de fotogramas).
El producto de rango A/D y el control de rango A/D establecen conjuntamente el rango A/D y el máximo, lo que permite al usuario ajustar el brillo de la imagen según la aplicación.
A continuación, presentemos el formato de salida de datos de imagen de OV7670. Primero, introduzcamos brevemente algunas definiciones:
VGA, es decir, el modo de salida con una resolución de 640*480;
QVGA, el formato de salida con una resolución de 320*240, es el formato que necesitamos en este capítulo.
QQVGA, es decir, el formato de salida con una resolución de 160*120;
PCLK, o reloj de píxeles, un reloj PCLK, genera un píxel (o medio píxel).
VSYNC, la señal de sincronización de cuadro. HREF /HSYNC, la señal de sincronización de línea.
La salida de datos de imagen del OV7670 (a través de D[7:0]) se controla en PCLK, VSYNC y HREF/ HSYNC
Debajo. Primero, eche un vistazo a la sincronización de la salida de la fila, como se muestra en la figura:

ov7670-módulo-de-cámara-conexión-con STONE-módulo de pantalla

Como se puede ver en la figura anterior, los datos de la imagen se emiten cuando el HREF es alto y cuando el HREF es alto cuando cada PCLK
Reloj, salida de un byte de datos. Por ejemplo, usamos temporización VGA, salida en formato RGB565, cada 2 bytes constituyen un color de píxel (bytes altos antes, bytes bajos después) para que la salida de cada línea tenga un total de 640*2 ciclos PCLK, la salida de 640* 2 bytes
Temporización de fotogramas (modo VGA):

ov7670-módulo-de-cámara-conexión-con STONE-módulo de pantallaov7670-módulo-de-cámara-conexión-con STONE-módulo de pantalla

La figura anterior muestra claramente la salida de datos del OV7670 en modo VGA. Tenga en cuenta el HSYNC y HREF en la figura
En realidad, es una señal del mismo pin, pero de diferentes maneras en diferentes situaciones, estamos usando HREF en este capítulo.
Dado que el reloj de píxeles (PCLK) de OV7670 puede alcanzar hasta 24 Mhz, usamos el puerto IO de STM32F103ZET6 para captar directamente, lo cual es muy difícil y requiere mucha CPU (el puerto IO se puede capturar reduciendo la frecuencia de salida de PCLK , pero no se recomienda).
En este proyecto, utilicé el modo RGB565 y los datos de imagen capturados fueron los datos originales de RGB, que luego se transfirieron al STONE módulo de visualización a través de UART.

ov7670-módulo-de-cámara-conexión-con STONE-módulo de pantalla

El código del controlador para el módulo de cámara OV7670

u8 OV7670_Init(void)
{
u8 temp;
u16 i=0;
GPIO_InitTypeDef  GPIO_InitStructure;
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_GPIOB|RCC_APB2Periph_GPIOC|RCC_APB2Periph_GPIOD|RCC_APB2Periph_GPIOG, ENABLE);
GPIO_InitStructure.GPIO_Pin  = GPIO_Pin_8;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3|GPIO_Pin_4;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_Init(GPIOB, &GPIO_InitStructure);
GPIO_SetBits(GPIOB,GPIO_Pin_3|GPIO_Pin_4);
GPIO_InitStructure.GPIO_Pin  = 0xff;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
GPIO_Init(GPIOC, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin  = GPIO_Pin_6;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_Init(GPIOD, &GPIO_InitStructure);
GPIO_SetBits(GPIOD,GPIO_Pin_6);
GPIO_InitStructure.GPIO_Pin  = GPIO_Pin_14|GPIO_Pin_15;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_Init(GPIOG, &GPIO_InitStructure);
GPIO_SetBits(GPIOG,GPIO_Pin_14|GPIO_Pin_15);
GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable,ENABLE); //SWD
SCCB_Init();         //³õʼ»¯SCCB µÄIO¿Ú
if(SCCB_WR_Reg(0x12,0x80))return 1; //¸´Î»SCCB
delay_ms(50);
temp=SCCB_RD_Reg(0x0b);
if(temp!=0x73)return 2;
temp=SCCB_RD_Reg(0x0a);
if(temp!=0x76)return 2;
//³õʼ»¯ÐòÁÐ
for(i=0;i<sizeof(ov7670_init_reg_tbl_rgb565) sizeof=""></sizeof(ov7670_init_reg_tbl_rgb565)>
{
SCCB_WR_Reg(ov7670_init_reg_tbl_RGB565[i][0],ov7670_init_reg_tbl_RGB565[i][1]);
delay_ms(2);
}
return 0x00; //ok
}
OV7670_CONFIG ov7670_config;
//ÅäÖÃOV7670µÄÊä³ö
void config_ov7670_OutPut(u16 xsta,u16 ysta,u16 width,u16 height,u8 ouput_mode){
int i=0;
ov7670_config.xsta = xsta;
ov7670_config.ysta = ysta;
ov7670_config.width = width;
ov7670_config.height = height;
ov7670_config.mode = ouput_mode;
if(ouput_mode){ //²ÊÉ«Êä³ö
for(i=0;i<sizeof(ov7670_init_reg_tbl_yuv) sizeof=""></sizeof(ov7670_init_reg_tbl_yuv)>
{
SCCB_WR_Reg(ov7670_init_reg_tbl_YUV[i][0],ov7670_init_reg_tbl_YUV[i][1]);
delay_ms(2);
}
}else{ //ºÚ°×Êä³ö
for(i=0;i<sizeof(ov7670_init_reg_tbl_rgb565) sizeof=""></sizeof(ov7670_init_reg_tbl_rgb565)>
{
SCCB_WR_Reg(ov7670_init_reg_tbl_RGB565[i][0],ov7670_init_reg_tbl_RGB565[i][1]);
delay_ms(2);
}
}
OV7670_Window_Set(176,10,width,height); //ÉèÖô°¿Ú
LCD_Clear(WHITE);
}
void OV7670_Light_Mode(u8 mode)
{
u8 reg13val=0XE7;
u8 reg01val=0;
u8 reg02val=0;
switch(mode)
{
case 1://sunny
reg13val=0XE5;
reg01val=0X5A;
reg02val=0X5C;
break;
case 2://cloudy
reg13val=0XE5;
reg01val=0X58;
reg02val=0X60;
break;
case 3://office
reg13val=0XE5;
reg01val=0X84;
reg02val=0X4c;
break;
case 4://home
reg13val=0XE5;
reg01val=0X96;
reg02val=0X40;
break;
}
SCCB_WR_Reg(0X13,reg13val);
SCCB_WR_Reg(0X01,reg01val);
SCCB_WR_Reg(0X02,reg02val);
}
void OV7670_Color_Saturation(u8 sat)
{
u8 reg4f5054val=0X80;
u8 reg52val=0X22;u8 reg53val=0X5E;
switch(sat)
{
case 0://-2
reg4f5054val=0X40;
reg52val=0X11;
reg53val=0X2F;
break;
case 1://-1
reg4f5054val=0X66;
reg52val=0X1B;
reg53val=0X4B;
break;
case 3://1
reg4f5054val=0X99;
reg52val=0X28;
reg53val=0X71;
break;
case 4://2
reg4f5054val=0XC0;
reg52val=0X33;
reg53val=0X8D;
break;
}
SCCB_WR_Reg(0X4F,reg4f5054val);
SCCB_WR_Reg(0X50,reg4f5054val);
SCCB_WR_Reg(0X51,0X00);
SCCB_WR_Reg(0X52,reg52val);
SCCB_WR_Reg(0X53,reg53val);
SCCB_WR_Reg(0X54,reg4f5054val);
SCCB_WR_Reg(0X58,0X9E);
}
void OV7670_Brightness(u8 bright)
{
u8 reg55val=0X00;//ĬÈϾÍÊÇbright=2
switch(bright)
{
case 0://-2
reg55val=0XB0;
break;
case 1://-1
reg55val=0X98;
break;
case 3://1
reg55val=0X18;
break;
case 4://2
reg55val=0X30;
break;
}
SCCB_WR_Reg(0X55,reg55val);
}
void OV7670_Contrast(u8 contrast)
{
u8 reg56val=0X40;
switch(contrast)
{
case 0://-2
reg56val=0X30;
break;
case 1://-1
reg56val=0X38;
break;
case 3://1
reg56val=0X50;
break;
case 4://2
reg56val=0X60;
break;
}
SCCB_WR_Reg(0X56,reg56val);
}
void OV7670_Special_Effects(u8 eft)
{
u8 reg3aval=0X04;//ĬÈÏΪÆÕͨģʽ
u8 reg67val=0XC0;
u8 reg68val=0X80;
switch(eft)
{
case 1:
reg3aval=0X24;
reg67val=0X80;
reg68val=0X80;
break;
case 2:
reg3aval=0X14;
reg67val=0X80;
reg68val=0X80;
break;
case 3:
reg3aval=0X14;
reg67val=0Xc0;
reg68val=0X80;
break;
case 4:
reg3aval=0X14;
reg67val=0X40;
reg68val=0X40;
break;
case 5:
reg3aval=0X14;
reg67val=0X80;
reg68val=0XC0;
break;
case 6:
reg3aval=0X14;
reg67val=0XA0;
reg68val=0X40;
break;
}
SCCB_WR_Reg(0X3A,reg3aval);
SCCB_WR_Reg(0X68,reg67val);
SCCB_WR_Reg(0X67,reg68val);
}
void OV7670_Window_Set(u16 sx,u16 sy,u16 width,u16 height)
{
u16 endx;
u16 endy;
u8 temp;
endx=(sx+width*2)%784; //   sx:HSTART endx:HSTOP
endy=sy+height*2; //   sy:VSTRT endy:VSTOP
//ÉèÖÃHREF
temp=SCCB_RD_Reg(0X32);
temp&=0XC0;
temp|=((endx&0X07)<<3)|(sx&0X07);
SCCB_WR_Reg(0X032,temp);
SCCB_WR_Reg(0X17,sx>>3);
SCCB_WR_Reg(0X18,endx>>3);
//ÉèÖÃVREF
temp=SCCB_RD_Reg(0X03);
temp&=0XF0;
temp|=((endy&0X03)<<2)|(sy&0X03);
SCCB_WR_Reg(0X03,temp);
SCCB_WR_Reg(0X19,sy>>2);
SCCB_WR_Reg(0X1A,endy>>2);
}

Controlador de tarjeta TF

El proyecto también requiere una tarjeta TF para almacenar las imágenes tomadas. Debido a que el controlador de la tarjeta TF es demasiado largo, no lo publicaré aquí. Puede buscar el código relevante en la red para usar.

STM32F103ZE

Hay mucha información y documentos de desarrollo sobre este chip en la red, aquí hay una breve introducción a este chip.

ov7670-módulo-de-cámara-conexión-con STONE-módulo de pantalla

No diré mucho sobre este chip. El código de descarga del chip UTILIZA j-link, como se muestra en la siguiente figura:

ov7670-módulo-de-cámara-conexión-con STONE-módulo de pantalla

Esta es una versión simple de j-link que solo admite la depuración y descarga de SWD, no JTAG. Pero para el desarrollo de chips STM32, la depuración de SWD es suficiente.

Descarga el código al chip STM32

Asegúrese de que la conexión entre j-link y STM32F103ZE sea correcta, y luego el chip se puede identificar en el entorno de desarrollo de KEIL:

ov7670-módulo-de-cámara-conexión-con STONE-módulo de pantalla

Haga clic en el botón de descarga para descargar el código al chip:

ov7670-módulo-de-cámara-conexión-con STONE-módulo de pantalla

Código de control STM32

La recepción de datos de la STONE El módulo de visualización solo puede recibir 255 bytes a la vez, mientras que el tamaño de la imagen de un único dato RGB565 es 240*320*2=153600Byte= 153.6kb, por lo que debe subdistribuirse.
Además, debido a la limitación de la tasa de comunicación en serie, el efecto de la actualización de la imagen en tiempo real no es muy bueno. La velocidad en baudios del puerto serie está configurada en 921600, que también es la velocidad en baudios de comunicación más alta para el STONE módulo de visualización en serie.
Los botones y el texto de la pantalla tienen direcciones correspondientes. En este proyecto, la dirección del componente de visualización es la siguiente:
BOTÓN TOMAR FOTO: 0X002A
BOTÓN COLOR Y GRIS: 0X002B
BOTÓN CAMBIO RACIÓN:0X002C
BOTÓN DE IMAGEN ANTERIOR: 0X002D
BOTÓN IMAGEN SIGUIENTE:0X002E
BOTÓN EXAMINAR: 0X002F

El código de la función principal es el siguiente:

#include "led.h"
#include "delay.h"
#include "key.h"
#include "sys.h"
#include "lcd.h"
#include "usart.h"
#include "string.h"
#include "ov7670.h"
#include "tpad.h"
#include "timer.h"
#include "exti.h"
#include "usmart.h"
#include "dma.h"
#include "sdio_sdcard.h"
extern u8 ov_sta;
extern u8 img_dis_cnt;
extern u8 data_ready;
extern u8 USART_RX_END;
u16 user_width=240;
u16 user_heigh=240;
#define PIC_TOTAL     20
u8 sd_select=1;
u16 color_r;
u16 color_g;
u16 color_b;
void UART1_Send_Array(u8 send_array[],u16 num)
{
u16 i=0;
while(i<num)< span=""></num)<>
{
USART_SendData(USART1,send_array[i]);
while( USART_GetFlagStatus(USART1,USART_FLAG_TC)!= SET);
i++;
}
}
void ov7670_clock_set(u8 PLL)
{
u8 temp=0;
RCC->CFGR&=0XFFFFFFFC;
RCC->CR&=~0x01000000;
RCC->CFGR&=~(0XF<<18);
PLL-=2;//µÖÏû2¸öµ¥Î»
RCC->CFGR|=PLL<<18;
RCC->CFGR|=1<<16;    //PLLSRC ON
FLASH->ACR|=0x12;
RCC->CR|=0x01000000;   //PLLON
while(!(RCC->CR>>25));
RCC->CFGR|=0x02;
while(temp!=0x02)
{
temp=RCC->CFGR>>2;
temp&=0x03;
}
}
#define SEND_BUF_SIZE   169
#define LCD_X_H         5
#define LCD_X_L         6
#define LCD_Y_H         7
#define LCD_Y_L         8
u8 lcd_send_buf[SEND_BUF_SIZE]={0xa5,0x5a,0xa6,0x85,0x00,0x00,0x00,0x00,0x00};
u8 lcd_send_buf1[512]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
u8 upda_flag=1;
u16 dis_fixel=0;
void camera_refresh()
{
u16 i=0,j=0,k=0;
u8 color;
u8 cnt=9;
u16 user_x_cnt=0,user_x_start=0,lcd_send_times=0;
u16 user_width1=user_width;
u16 user_heigh1=user_heigh;
if(user_width1==240)
{
user_x_cnt=2;
user_x_start=450;
}
else if(user_width1==320)
{
user_x_cnt=3;
user_x_start=410;
}
else if(user_width1==160)
{
user_x_cnt=1;
user_x_start=490;
}
else if(user_width1==80)
{
user_x_cnt=0;
user_x_start=530;
}
if(ov_sta==2)
{
OV7670_RRST=0;
OV7670_RCK_L;
OV7670_RCK_H;
OV7670_RCK_L;
OV7670_RRST=1;
OV7670_RCK_H;
upda_flag=0;
for(i=0;i<user_heigh1;i++)< span=""></user_heigh1;i++)<>
{
k=i+150;
lcd_send_buf[LCD_Y_L] = (u8)(k & 0x00ff);
lcd_send_buf[LCD_Y_H] = (u8)(k >> 8);
cnt=9;
lcd_send_times=0;
for(j=0;j<user_width1*2;j++)></user_width1*2;j++)>
{
OV7670_RCK_L;
color=(u8)GPIOC->IDR&0XFF;
OV7670_RCK_H;
lcd_send_buf[cnt++]=color;
if(cnt > 168)
{
if(lcd_send_times==0)
{
dis_fixel=user_x_start;
lcd_send_buf[LCD_X_H] =(u8)(dis_fixel >> 8);
lcd_send_buf[LCD_X_L] = (u8)(dis_fixel & 0x00ff);
}
else if(lcd_send_times==1)
{
dis_fixel+=80;
lcd_send_buf[LCD_X_H] =(u8)(dis_fixel >> 8);
lcd_send_buf[LCD_X_L] = (u8)(dis_fixel & 0x00ff);
}
else if(lcd_send_times==2)
{
dis_fixel+=80;
lcd_send_buf[LCD_X_H] =(u8)(dis_fixel >> 8);
lcd_send_buf[LCD_X_L] = (u8)(dis_fixel & 0x00ff);
}
else if(lcd_send_times==3)
{
dis_fixel+=80;
lcd_send_buf[LCD_X_H] =(u8)(dis_fixel >> 8);
lcd_send_buf[LCD_X_L] = (u8)(dis_fixel & 0x00ff);
}
if(USART_RX_END==1)
{
EXTI_ClearITPendingBit(EXTI_Line8);
ov_sta=0;
upda_flag=1;
return;
}
else
{
UART1_Send_Array(lcd_send_buf,169);
}
lcd_send_times++;
if(lcd_send_times>user_x_cnt)
lcd_send_times=0;
cnt=9;
}
}
}
EXTI_ClearITPendingBit(EXTI_Line8);
ov_sta=0;
upda_flag=1;
}
}
void clear_display()
{
u16 i=0,j=0,k=0;
u8 cnt=9,lcd_send_times=0;
u8 color;
u16 user_x_cnt=0,user_x_start=0;
u16 user_width1=user_width;
u16 user_heigh1=user_heigh;
if(user_width1==240)
{
user_x_cnt=2;
user_x_start=450;
}
else if(user_width1==320)
{
user_x_cnt=3;
user_x_start=410;
}
else if(user_width1==160)
{
user_x_cnt=1;
user_x_start=490;
}
else if(user_width1==80)
{
user_x_cnt=0;
user_x_start=530;
}
upda_flag=0;
for(i=0;i<user_heigh1;i++)< span=""></user_heigh1;i++)<>
{
k=i+150;
lcd_send_buf[LCD_Y_L] = (u8)(k & 0x00ff);
lcd_send_buf[LCD_Y_H] = (u8)(k >> 8);
cnt=9;
lcd_send_times=0;
for(j=0;j<user_width1*2;j++)></user_width1*2;j++)>
{
OV7670_RCK_L;
color=(u8)GPIOC->IDR&0XFF;
OV7670_RCK_H;
lcd_send_buf[cnt++]=0xff;
if(cnt > 168)
{
if(lcd_send_times==0)
{
dis_fixel=user_x_start;
lcd_send_buf[LCD_X_H] =(u8)(dis_fixel >> 8);
lcd_send_buf[LCD_X_L] = (u8)(dis_fixel & 0x00ff);
}
else if(lcd_send_times==1)
{
dis_fixel+=80;
lcd_send_buf[LCD_X_H] =(u8)(dis_fixel >> 8);
lcd_send_buf[LCD_X_L] = (u8)(dis_fixel & 0x00ff);
}
else if(lcd_send_times==2)
{
dis_fixel+=80;
lcd_send_buf[LCD_X_H] =(u8)(dis_fixel >> 8);
lcd_send_buf[LCD_X_L] = (u8)(dis_fixel & 0x00ff);
}
else if(lcd_send_times==3)
{
dis_fixel+=80;
lcd_send_buf[LCD_X_H] =(u8)(dis_fixel >> 8);
lcd_send_buf[LCD_X_L] = (u8)(dis_fixel & 0x00ff);
}
UART1_Send_Array(lcd_send_buf,169);
lcd_send_times++;
if(lcd_send_times>user_x_cnt)
lcd_send_times=0;
cnt=9;
}
}
}
EXTI_ClearITPendingBit(EXTI_Line8);
ov_sta=0;
upda_flag=1;
}
void user_save_image()
{
u16 i=0,j=0,k=0;
u8 color;
u8 cnt=9,m_cnt=0;
u16 user_x_cnt=0,user_x_start=0,lcd_send_times=0;
u16 user_width1=user_width;
if(user_width1==240)
{
user_x_cnt=2;
user_x_start=450;
}
else
{
return;
}
while(ov_sta!=2);
if(ov_sta==2)
{
OV7670_RRST=0;
OV7670_RCK_L;
OV7670_RCK_H;
OV7670_RCK_L;
OV7670_RRST=1;
OV7670_RCK_H;
upda_flag=0;
for(i=0;i<240;i++)
{
k=i+150;
lcd_send_buf[LCD_Y_L] = (u8)(k & 0x00ff);
lcd_send_buf[LCD_Y_H] = (u8)(k >> 8);
cnt=9;
lcd_send_times=0;
for(j=0;j<240*2;j++)
{
OV7670_RCK_L;
color=(u8)GPIOC->IDR&0XFF;
OV7670_RCK_H;
lcd_send_buf[cnt++]=color;
if(cnt > 168)
{
m_cnt=0;
if(lcd_send_times==0)
{
dis_fixel=user_x_start;
lcd_send_buf[LCD_X_H] =(u8)(dis_fixel >> 8);
lcd_send_buf[LCD_X_L] = (u8)(dis_fixel & 0x00ff);
for(m_cnt=0;m_cnt<169;m_cnt++)
{
lcd_send_buf1[m_cnt]=lcd_send_buf[m_cnt];
}
}
else if(lcd_send_times==1)
{
dis_fixel+=80;
lcd_send_buf[LCD_X_H] =(u8)(dis_fixel >> 8);
lcd_send_buf[LCD_X_L] = (u8)(dis_fixel & 0x00ff);
for(m_cnt=0;m_cnt<169;m_cnt++)
{
lcd_send_buf1[m_cnt+169]=lcd_send_buf[m_cnt];
}
}
else if(lcd_send_times==2)
{
dis_fixel+=80;
lcd_send_buf[LCD_X_H] =(u8)(dis_fixel >> 8);
lcd_send_buf[LCD_X_L] = (u8)(dis_fixel & 0x00ff);
for(m_cnt=0;m_cnt<169;m_cnt++)
{
lcd_send_buf1[m_cnt+169*2]=lcd_send_buf[m_cnt];
}
}
UART1_Send_Array(lcd_send_buf,169);
lcd_send_times++;
if(lcd_send_times>user_x_cnt)
{
SD_WriteDisk(lcd_send_buf1,i+240*sd_select,1);
lcd_send_times=0;
}
cnt=9;
}
}
}
}
EXTI_ClearITPendingBit(EXTI_Line8);
ov_sta=0;
upda_flag=1;
}
void read_image()
{
u8 i=0;
for(i=0;i<240;i++)
{
if(SD_ReadDisk(lcd_send_buf1,i+240*sd_select,1)==0)
{
UART1_Send_Array(lcd_send_buf1,507);
}
}
}
int main(void)
{
u8 pixel_ch_flag=0,user_effect_flag=0;
delay_init();
NVIC_Configuration();
uart_init(921600);
LED_Init();
LCD_Init();
delay_ms(1000);
delay_ms(1000);
while(OV7670_Init())//³õʼ»¯OV7670
{
delay_ms(200);
}
while(SD_Init())
{
delay_ms(500);
LED0=!LED0;
}
if(SD_ReadDisk(lcd_send_buf1,240*(PIC_TOTAL+10),1)==0)
{
sd_select=lcd_send_buf1[0];
if(sd_select>=PIC_TOTAL )
{
lcd_send_buf1[0]=0x00;
SD_WriteDisk(lcd_send_buf1,240*(PIC_TOTAL+10),1);
sd_select=0;
}
}
//show_sdcard_info();
EXTI8_Init();
OV7670_CS=0;
config_ov7670_OutPut(20,60,user_width,user_heigh,0);
while(1)
{
if(USART_RX_END==1)
{
switch(USART_RX_BUF[5])
{
case 0x2c:
clear_display();
pixel_ch_flag+=1;//!pixel_ch_flag;
if(pixel_ch_flag>3)
pixel_ch_flag=0;
if(pixel_ch_flag==1)
{
user_width=160;
user_heigh=160;
}
else if(pixel_ch_flag==2)
{
user_width=80;
user_heigh=80;
}
else if(pixel_ch_flag==3)
{
user_width=320;
user_heigh=240;
}
else
{
user_width=240;
user_heigh=240;
}
config_ov7670_OutPut(20,60,user_width,user_heigh,0);
if(user_effect_flag)
OV7670_Special_Effects(1);
else
OV7670_Special_Effects(0);
break;
case 0x2b:
user_effect_flag=!user_effect_flag;
if(user_effect_flag)
OV7670_Special_Effects(1);
else
OV7670_Special_Effects(0);
break;
case 0x2a:
if(user_width!=240)break;
if(img_dis_cnt==0)
{
img_dis_cnt=1;
}
else
{
if(SD_ReadDisk(lcd_send_buf1,240*(PIC_TOTAL+10),1)==0)
{
if(lcd_send_buf1[0]>=PIC_TOTAL)
{
lcd_send_buf1[0]=PIC_TOTAL;
sd_select=1;
}
else
{
sd_select=lcd_send_buf1[0]+1;
lcd_send_buf1[0]=sd_select;
}
SD_WriteDisk(lcd_send_buf1,240*(PIC_TOTAL+10),1);
user_save_image();
//sd_select=lcd_send_buf1[0];
}
}
break;
case 0x2d:
if(SD_ReadDisk(lcd_send_buf1,240*(PIC_TOTAL+10),1)==0)
{
if(lcd_send_buf1[0]==0)
break;
else
{
sd_select-=1;
if(sd_select==0)sd_select=lcd_send_buf1[0];
}
if(sd_select>lcd_send_buf1[0])
sd_select=1;
}
if(user_width==320)
clear_display();
read_image();
img_dis_cnt=0;
break;
case 0x2e:
if(SD_ReadDisk(lcd_send_buf1,240*(PIC_TOTAL+10),1)==0)
{
if(lcd_send_buf1[0]==0)
break;
if(sd_select>=lcd_send_buf1[0])
{
sd_select=1;
}
else
{
sd_select+=1;
}
}
if(user_width==320)
clear_display();
read_image();
img_dis_cnt=0;
break;
case 0x2f:
img_dis_cnt=0;
break;
default:
break;
}
USART_RX_END=0;
USART_RX_STA=0;
}
else
{
// USART_RX_END=0;
// USART_RX_STA=0;
if(img_dis_cnt==1)
camera_refresh();
}
}
}

 

Finalmente, el código se descarga al chip STM32 y luego la placa de circuito completa se conecta a la pantalla y se garantiza que la fuente de alimentación sea estable. Puede ver las imágenes tomadas por VO7670 a través de la STONE módulo de visualización

Conexión del módulo de cámara ov7670 con STONE módulo de visualización final del proyecto.

Efecto de carrera

ov7670-módulo-de-cámara-conexión-con STONE-módulo de pantalla

ov7670-módulo-de-cámara-conexión-con STONE-módulo de pantalla

Artículos Relacionados:

  1. Raspberry PI Pico y STONE Sistema de control de luz deslumbrante de pantalla
  2. Prueba de módulo ultrasónico con STONE Módulo LCD
  3. Por el cliente : STONE Guía para principiantes de pantalla táctil TFT inteligente
  4. STONE Pantalla táctil+ ESP32 para sillón de masaje
  5. La estructura y el principio de visualización de LCD de alto brillo
  6. STONE STVC070WT-01 Pantalla HMI+Arduino+Metrónomo Musical
  7. Interfaz gráfica de usuario de Raspberry Pi utilizando STONE Módulo de pantalla táctil HMI
  8. Pantalla LCD en máquina expendedora de bocadillos
  9. STONE Pantalla de teléfono móvil de transmisión transparente HMI + BC1110 Bluetooth sincrónicamente
  10. STWI056WT-01 Función de interacción HM de belleza láser de desarrollo de pantalla en serie
Ir al Inicio