基于Cyclone V SoC利用HLS实现卷积手写体数字识别设计

本文链接：https://blog.csdn.net/m0_73063250/article/details/130240087

本文介绍了使用IntelCycloneVSoC开发板，结合HLS技术实现的手写体数字识别系统。系统利用高层综合工具将C++代码转化为FPGA硬件描述语言，加速了卷积神经网络和全连接神经网络的推理运算，实现了图像处理和识别。在硬件层面，设计包含了摄像头、显示屏、DDR3存储和FPGA逻辑等模块，通过软硬件协同工作，实现了手写体的实时识别。

摘要由CSDN通过智能技术生成

引文

本文是基于英特尔Cyclone V SoC开发板，利用HLS技术实现三层卷积两层池化两层全连接推理运算的手写体数字识别设计。

硬件环境：

Cyclone V SoC开发板
OV5640 摄像头
15.6寸 HDMI显示屏
SD卡
电脑

软件环境：

Windows 10
Quartus prime
Eclipse DS-5
MobaXterm
i++编译环境
HLS工具

语言：

C
Verilog HDL

项目介绍

项目框架以及数据流向

基于SoCFPGA的手写体识别项目，包括FPGA和HPS两大板块。在FPGA板块中，细分为OV5640摄像头、HDMI显示和算法处理三个模块。HPS板块包含DDR3和手写体算法控制两个模块。

数据流向如下：OV5640摄像头模块采集RGB565格式的图像数据，每个像素占两个字节，分辨率为1024x760，通过Avalon接口的memory_map Master接口输出给DDR3高速存储器。在DDR3中，设计了一块frame_buffer数据缓冲区，用于存储采集到的图像数据。同时，DDR3将采集到的数据和相应的控制命令通过Avalon接口的memory_map流接口时序输出给HDMI模块，将RGB888格式的三个字节数据发送到显示屏上，实现实时的图像显示。另外，DDR3中采集到的OV5640数据也同时传送给算法控制模块，进行手写体识别算法的处理。算法控制模块会对DDR3中的数据进行0填充等预处理操作，并输出处理后的数据和相应的控制命令给FPGA中的ACCSYSTEM数据处理模块。ACCSYSTEM数据处理模块会执行3层卷积、2层池化和2层全连接等操作，将处理后的特征映射传送回DDR3，并通过HDMI模块显示在屏幕上，从而实现手写体识别的正确结果展示。

模块介绍

DDR3模块：作为PS端的高速存储器，负责存储从OV5640摄像头模块采集到的图像数据和从手写体识别算法控制模块输出的数据。DDR3模块通过高速接口与PL端的其他模块进行数据传输。

手写体识别算法控制模块：负责控制PL端的ACCsystem推理算法模块的操作，并向DDR3模块写入图像数据和相应的控制命令。该模块可能包括卷积神经网络（CNN）和全连接神经网络（FCN）等手写体识别算法的实现，并根据输入图像进行推理和分类，生成识别结果。

HDMI的IP模块：负责与HDMI显示屏的连接和通信，将从PL端输出的图像数据转换为HDMI信号，通过HDMI接口输出到显示屏进行实时显示。

图像接收模块：负责从OV5640摄像头模块接收采集到的图像数据，并将其传输到PL端进行后续处理。可能包括图像数据的解析、格式转换等功能。 OV5640摄像头模块：负责采集手写体图像数据，并通过图像接收模块将RGB565格式的图像数据传输到PL端，作为手写体识别的输入。

ACCsystem推理算法模块：作为PL端的数据处理核心，负责接收来自DDR3模块和手写体识别算法控制模块的输入数据，并进行卷积、池化、全连接等推理算法的计算操作。经过处理后，将识别结果传输到DDR3模块和HDMI的IP模块，同时可能还包括与其他模块之间的数据传输和控制信号的处理。

设计流程

根据PL搭建的摄像头模块、图像采集处理模块、Avalon协议模块、HDMI图像输入输出模块编写对应的Verilog HDL代码满足功能和时序要求。
根据PS搭建的DDR3高速存储模块、手写体算法控制模块、三层卷积两层池化两层全连接推理算法模块编写对应的C代码满足存储、控制和算法要求。
根据C代码编写的三层卷积两层池化两层全连接推理算法，利用 i++ 环境下的HLS工具转换成Quartus工程并封装成IP。
根据AXI协议和Avalon协议完成PL和PS之间的传输。

项目文件结构

handwriting                                 # 项目名称
   └──  C5MB_GHRD_Mnist/                    # 黄金工程
             ├── C5MB_top.qpf               # 用于启动quartus的GUI界面
             ├── C5MB_top.v                 # 黄金工程.v设计文件
             ├── hps_0.h                    # 封装IP生成的头文件,用来保持寄存器地址
             ├── soc_system.dtb             # 用于烧入sd卡执行的文件
             ├── app/                       # ps端c代码设计源文件
             │    ├── MNIST_mb/             # 项目主文件
             │    │     └── *.c
             │    └── ...        
             │        
             ├── ip/                          # IP目录
             │    ├── pll/                    # 调用的pll源文件存放目录
             │    │     └── ...
             │    ├── hls/                    # hls高层次综合文件
             │    │     └── ...
             │    ├── DVP_CAPTURE/            # HDMI输入输出IP文件
             │    │     └── ...
             │    └── AccSystem/              # 自己封装的算法源文件存放目录
             │          └── ...
             │
             ├── src/                         # PL端的.v源文件
             │  ├── i2c_master/               # I2C接口时序源文件设计
             │  │     └── *.v
             │  ├── *.v
             │  └── ...      
             │   
             ├── output_files/
             │       ├── soc_system.rbf         # 用于烧入sd卡执行的文件
             │       └── ... 
             │
             └── ...

代码示例

全连接神经网络推理算法设计C代码示例

#include <stdio.h>
#include  "HLS/hls.h"
#include  "HLS/stdio.h"
#include "HLS/hls_internal.h"
#include "HLS/math.h"

#include"input_0.h"
#include"input_1.h"
#include"input_2.h"
#include"input_3.h"
#include"input_4.h"
#include"input_5.h"
#include"input_6.h"
#include"input_7.h"
#include"input_8.h"
#include"input_9.h"
#include"layer1_bais.h"
#include"layer1_weight.h"
#include"layer2_bais.h"
#include"layer2_weight.h"


hls_avalon_slave_component 

component int handwriting(hls_avalon_slave_memory_argument(784*sizeof(float))float *img,
                hls_avalon_slave_memory_argument(784*64*sizeof(float))float *w1,
                hls_avalon_slave_memory_argument(64*sizeof(float))float *b1,
                hls_avalon_slave_memory_argument(64*10*sizeof(float))float *w2,
                hls_avalon_slave_memory_argument(10*sizeof(float))float *b2)
{
    //输入层第一层
    int    ret1;
    int    i,j;
    float   a1[64]={0.0},a2[10]={0.0};
    for ( i = 0; i < 64; i++)//从什么时候开始跳
    {
      for ( j = 0; j < 784; j++)//跳64为拮据的次数
      {
          a1[i] += img[j]*w1[j*64+i];
      }
      a1[i] += b1[i];
    //加激活函数
    a1[i] = (a1[i]>0)? a1[i] : 0 ;
    }
//第二层
    for ( i = 0; i < 10; i++)//从什么时候开始跳
    {
      for ( j = 0; j < 64; j++)//跳10为拮据的次数
      {
          a2[i] += a1[j]*w2[j*10+i];
      }
    a2[i] += b2[i];
    //加激活函数
    //a2[i] = (a2[i]>0)? a2[i] : 0 ;
    }
    //判断输出识别数字
    float temp=0;
    for ( i = 0; i < 10; i++)
    {
        if (a2[i]>temp)
        {
            temp = a2[i];
            ret1 = i;
        }    
    } 
   return    ret1;
}
int  main()
{
    
    int i;
    float *a3[10]={input_0,input_1,input_2,input_3,input_4,input_5,input_6,input_7,input_8,input_9};
    for ( i = 0; i < 10; i++)
    {
        int ret0 = handwriting(a3[i],layer1_weight,layer1_bais,layer2_weight,layer2_bais);
       printf("input_%d.h检测结果为:%d\n",i,ret0);
       
    }
    return  0;
}

三层卷积两层池化两层全连接推理算法C代码示例

#define _INFER_GLOBLE
#define _PARA_GLOBLE
#include "include.h"
int chrinfer() {
	//----------------------------------------------
	//  第一卷积层
	//----------------------------------------------
	//将输入图像加载至FPGA的Map存储器中
	//基地址偏移为0
	//第一层为1通道输入，6通道输出，输入图像28x28
	//所以只需要首先加载一次图像数据
	//然后每次卷积时每个通道再单独加载权重
	//加载过程中处理Padding，保持输出图像与输入图像大小相同
	//即上下左右补2圈0
	PROCESS_TRACE("hls_conv", "loading");
	int i, j, channel, outchannel, inchannel, ner;
	//Padding后输入图像大小变为32x32
	for (i = 0; i < 32; i++) {
		for (j = 0; j < 32; j++) {
			//上下补0，即第0,1行与第30,31行，写入Map存储器中的数据全是0
			if ((i == 0) || (i == 31) || (i == 1) || (i == 30)) {
				*(acc_data_virtual_base + i * 32 + j) = 0.0;
			} 
			else {
				//左右补0，即第0,1列与第30,31列，写入Map存储器中的数据全是0
				if ((j == 0) || (j == 31) || (j == 1) || (j == 30)) {
					*(acc_data_virtual_base + i * 32 + j) = 0.0;
				} 
				else {
					//根据unit参数把字符图像写入Map存储器中
					*(acc_data_virtual_base + i * 32 + j) = plate.unit[i - 2][j - 2];
				}
			}
		}
	}

	INFO_TRACE("level 1 accconvolution");
	//第一层开始
	for (channel = 0; channel < L1CHAN; channel++) {
		//卷积
		//加载权重至FPGA Weight存储器中
		//基地址偏移为FPGA_Weight
		for (i = 0; i < ConvSize; i++) {
			for(j = 0; j < ConvSize; j++){
				*(acc_data_virtual_base + FPGA_Weight + i * 5 + j) = conv_w1[channel][i][j];
			}			
		}
		//配置卷积加速器
		//由于输入图像只有一个，因此不累加私有存储器图像(LocalMap)
		//后续需要偏置处理，因此结果输出到私有存储器中
		//卷积大小为Padding后的大小，即上下左右补零后的大小，即高宽各加2
		accconvolution(32, 32, 1, 0);//卷积结果输出到localmap
		//偏置与激活
		//加载偏置数据到FPGA的Weight存储器中
		//基地址偏移为FPGA_Weight
		*(acc_data_virtual_base + FPGA_Weight) = conv_b1[channel];
		//配置加速器
		//由于卷积输出保存在私有存储器中，因此偏置激活的输入数据来自于私有存储器
		//后续需要池化处理，因此输出到私有存储器
		//偏置激活的图像大小为卷积后图像大小，与原始输入图像保持相同
		//执行
		accbiasrelu(28, 28, 1, 1);//从localmap加载图像，输出到localmap
		//池化
		//配置加速器
		//由于偏置激活结果保存至私有存储器中，因此池化输入来自私有存储器
		//池化完成后第一层结束，后续无需任何操作，因此输出到FPGA Result存储器中
		//基地址偏移为FPGA_Result
		//池化图像大小与偏置激活后图像大小保持相同
		//执行
		accpool(28, 28, 1, 0);//从localmap加载图像，输出到result
		//读取结果
		//输出图像大小为池化后大小，即高宽各减半(14*14)
		for (i = 0; i < 14; i++) {
			for (j = 0; j < 14; j++) {
				layer1poolout[channel][i][j] = *(acc_data_virtual_base + FPGA_Result + i * 14 + j);
			}
		}
	}
	//----------------------------------------------
	//  第二卷积层
	//----------------------------------------------
	//与第一层卷积不同的是
	//第二层卷积有多个输入通道
	//因此每次独立卷积时都需要单独加载输入图像
	//L2CHAN个输出特征图
	INFO_TRACE("level 2 accconvolution");
	for (outchannel = 0; outchannel < L2CHAN; outchannel++) {
		//L1CHAN个输入特征图进行卷积并累加
		for (inchannel = 0; inchannel < L1CHAN; inchannel++) {
			//卷积
			//加载特征图
			//不加Padding
			for (i = 0; i < 14; i++) {
				for (j = 0; j < 14; j++) {
					*(acc_data_virtual_base + i * 14 + j) = layer1poolout[inchannel][i][j];			
				}
			}
			//加载权重
			for (i = 0; i < ConvSize; i++) {
				for(j = 0; j < ConvSize; j++){
				*(acc_data_virtual_base + FPGA_Weight + i * 5 + j) = conv_w2[outchannel][inchannel][i][j];
				}
			}
			//配置加速器
			//输出到私有存储器
			//每一个输出特征图，需要所有输入特征图分别卷积并累加结果
			//第一次计算不累加，其余累加
			//执行
			if (inchannel == 0){
				accconvolution(14, 14, 1, 0);
			}
			else{
				accconvolution(14, 14, 1, 1);
			}
		}

		//注意
		//此处inchannel循环已经结束
		//已经对所有输入特征图进行卷积并累加
		//配置加速器
		//来自私有存储器
		//输出到私有存储器
		*(acc_data_virtual_base + FPGA_Weight) = conv_b2[outchannel];
		//执行
		accbiasrelu(10, 10, 1, 1);
		//池化
		//配置加速器
		//来自私有存储器
		//输出到Result
		//执行
		accpool(10, 10, 1, 0);
		//取回池化结果
		for (i = 0; i < 5; i++) {
			for (j = 0; j < 5; j++) {
				layer2poolout[outchannel][i][j] = *(acc_data_virtual_base + FPGA_Result + i * 5 + j);
			}
		}
	}

	//----------------------------------------------
	//  第三卷积层
	//----------------------------------------------
	//第三卷积层与第二卷积层类似，不加padding
	INFO_TRACE("level 3 accconvolution");
	for (outchannel = 0; outchannel < L3CHAN; outchannel++) {
		for (inchannel = 0; inchannel < L2CHAN; inchannel++) {
			for (i = 0; i < 5; i++) {
				for (j = 0; j < 5; j++) {
					*(acc_data_virtual_base + i * 5 + j) = layer2poolout[inchannel][i][j];
				}
			}
			for (i = 0; i < ConvSize; i++) {
				for(j = 0; j < ConvSize; j++) {
					*(acc_data_virtual_base + FPGA_Weight + i * 5 + j) = conv_w3[outchannel][inchannel][i][j];
				}
			}
			if (inchannel == 0){
				accconvolution(5, 5, 1, 0);
			}
			else{
				accconvolution(5, 5, 1, 1);
			}
		}
		*(acc_data_virtual_base + FPGA_Weight) = conv_b3[outchannel];
		accbiasrelu(1, 1, 1, 0);
		layer3out[outchannel] = *(acc_data_virtual_base + FPGA_Result);
	}

	//----------------------------------------------
	//  第一层全连接
	//----------------------------------------------
	//全连接运算被拆分成16次乘累加的组合(单次全连接做16次乘累加运算)
	//总共NER个输出神经元
	INFO_TRACE("level 1 accfullconnect");
	for (ner = 0; ner < NER; ner++) {
		//初始化神经元
		neural_result[ner] = 0;
		//配置加速器
		//执行
		//输入layer3out[120], 120/16 = 7.5 ,需调用8次全连接算子
		for(j = 0; j < 8; j++){
			for ( i = 0;i < 16; i++){
				//超过图像大小的补0
				if((j == 7) && (i > 7)){
					*(acc_data_virtual_base + i) = 0.0;
					*(acc_data_virtual_base + FPGA_Weight + i) = 0.0;
				}
				else{
					*(acc_data_virtual_base + i) = layer3out[j * 16 + i];
					*(acc_data_virtual_base + FPGA_Weight + i) = fc_w1[ner][j * 16 + i];
				}
			}
			accfullconnect();
			//读取结果
			neural_result[ner] += *(acc_data_virtual_base + FPGA_Result);
		}
		//加偏置
		//此处channel循环已经结束
		//这里的加偏执由HPS完成
		neural_result[ner] += fc_b1[ner];
	}

	//----------------------------------------------
	//  第二层全连接
	//----------------------------------------------
	//  第二次全连接同样将运算拆分为16次乘累加的组合
	INFO_TRACE("level 2 accfullconnect");
	int outner, group, inner;
	//输出结果个数为ChrCls
	for (outner = 0; outner < ChrCls; outner++) {
		//初始化输出结果数组
		probability[outner] = 0;
		//由于第一次全连接输出了84个神经元，因此拆分成6x16=96次运算
		for (group = 0; group < 6; group++) {
			//加载16次乘累加的数据与权重
			for (inner = 0; inner < 16; inner++) {
				if((group == 5) && (inner > 3)){
					*(acc_data_virtual_base + inner) = 0.0;
					*(acc_data_virtual_base + inner + FPGA_Weight) = 0.0;
				}
				else{
					*(acc_data_virtual_base + inner) = neural_result[inner + group * 16];
					*(acc_data_virtual_base + inner + FPGA_Weight) = fc_w2[outner][inner + group * 16];
				}
			}
			//执行
			accfullconnect();
			//读取结果并由HPS完成6次结果的累加
			probability[outner] += *(acc_data_virtual_base + FPGA_Result);
		}
		//加偏置
		probability[outner] += fc_b2[outner];
	}
	PROCESS_TRACE("hls_conv", "done");
	//----------------------------------------------
	//  得到最终结果
	//----------------------------------------------
	//找到结果数组中最大的值，其对应的下标就是识别结果
	int result = 0;
	float max = probability[0];
	for (i = 0; i < ChrCls; i++) {
		INFO_TRACE("probability_hls[%d]:%f", i, probability[i]);
		if (probability[i] > max) {
			max = probability[i];
			result = i;
		}
	}
	chrfind(result);
	VALUEs_TRACE("chrinfer", chrret);
	strcat(license, chrret);
	return (result);
}

#undef _INFER_GLOBLE
#undef _PARA_GLOBLE