S04-CH10 自适应二值化MT9V034摄像头硬件实现

module MT_Sensor_ML(

    input CLK_i,

//---------------------------- CMOS sensor hardware interface --------------------------/

input cmos_vsync_i, //cmos vsync

input cmos_href_i, //cmos hsync refrence

input cmos_pclk_i, //cmos pxiel clock

output cmos_xclk_o, //cmos externl clock

input[7:0] cmos_data_i, //cmos data

output hs_o,//hs signal.

    output vs_o,//vs signal.

   // output de_o,//data enable.

    output [7:0] rgb_o,//data output,

    output vid_clk_ce

);

//----------------------视频输出解码模块---------------------------//

//wire  [7:0]rgb_o_r;

//assign rgb_o = {rgb_o_r[4:0]   ,3'd0 ,rgb_o_r[10:5]     ,2'd0,rgb_o_r[15:11],3'd0};

//assign rgb_o = {rgb_o_r,rgb_o_r,rgb_o_r};

reg [7:0]cmos_data_r;

reg cmos_href_r;

reg cmos_vsync_r;

always@(posedge cmos_pclk_i)

begin

   cmos_data_r <= cmos_data_i;

   cmos_href_r <= cmos_href_i;

   cmos_vsync_r<= cmos_vsync_i;

end

//assign rgb_o = 24'b11111111_00000000_11111111;

cmos_decode cmos_decode_u0(

//system signal.

.cmos_clk_i(CLK_i),//cmos senseor clock.

.rst_n_i(RESETn_i2c),//system reset.active low.

//cmos sensor hardware interface.

.cmos_pclk_i(cmos_pclk_i),//(cmos_pclk),//input pixel clock.

.cmos_href_i(cmos_href_r),//(cmos_href),//input pixel hs signal.

.cmos_vsync_i(cmos_vsync_r),//(cmos_vsync),//input pixel vs signal.

.cmos_data_i(cmos_data_r),//(cmos_data),//data.

.cmos_xclk_o(cmos_xclk_o),//(cmos_xclk),//output clock to cmos sensor.

//user interface.

.hs_o(hs_o),//hs signal.

.vs_o(vs_o),//vs signal.

// .de_o(de_o),//data enable.

.rgb565_o(rgb_o),//data output

.vid_clk_ce(vid_clk_ce)

    );

count_reset#(

        .num(20'hffff0)

    )(

        .clk_i(CLK_i),

        .rst_o(RESETn_i2c)

    );    

endmodule

#ifndef _TOP_H_

#define _TOP_H_

#include "hls_video.h"

#include "ap_int.h"

#include <math.h>

#define MAX_WIDTH  1920

#define MAX_HEIGHT 1080

#define INPUT_IMAGE           "QR.png"

//#define INPUT_IMAGE           "test_1080p.bmp"

#define OUTPUT_IMAGE          "result_1080p.bmp"

#define OUTPUT_IMAGE_GOLDEN   "result_1080p_golden.bmp"

// typedef video library core structures

typedef hls::stream<ap_axiu<8,1,1,1> >               AXI_STREAM;

typedef hls::Scalar<3, unsigned char>                 RGB_PIXEL;

typedef hls::Mat<MAX_HEIGHT, MAX_WIDTH, HLS_8UC3>     RGB_IMAGE;

typedef hls::Mat<MAX_HEIGHT, MAX_WIDTH, HLS_8UC1>     GRAY_IMAGE;

typedef hls::Scalar<1, unsigned char>                 GRAY_PIXEL;

typedef unsigned char    uchar;

typedef ap_uint<12>      int12_t;//自定义12位无符号整型

//顶层综合函数

void hls_otsu(AXI_STREAM& src_axi, AXI_STREAM& dst_axi, int rows, int cols);

#endif

#include "top.h"

#include "hls_math.h"

#define Simulation 0

#if Simulation

#include "iostream"

using namespace std;

#endif

namespace hls

{

template<int SRC_T, int DST_T,int ROW, int COL, int N>

void threshold(Mat<ROW, COL, SRC_T> &_src,Mat<ROW, COL, DST_T> &_dst,ap_uint<8> (&map)[N]){

const int NUM_STATES = 4; //

Window<1,NUM_STATES,ap_uint<8> > addr_win;

//OSTU

ap_uint<BitWidth<ROW*COL>::Value> hist_out[N];

Window<1,NUM_STATES,ap_uint<BitWidth<ROW*COL>::Value> > hist_win;

ap_uint<BitWidth<ROW*COL>::Value> hist;

ap_uint<8> addr;

ap_uint<8> addr_last;

ap_uint<BitWidth<ROW*COL>::Value> hist_last;

ap_uint<8> addr_flag;

ap_uint<BitWidth<ROW*COL>::Value> hist_flag;

ap_uint<8> addr_w;

ap_uint<BitWidth<ROW*COL>::Value> hist_w;

ap_uint<8> threshold = 0;

ap_uint<BitWidth<ROW*COL>::Value> tmp=0;

float pixelPro[256];

for(int i=0;i<NUM_STATES;i++) {

#pragma HLS UNROLL

addr_win(0,i)=i;//NUM_STATES

hist_win(0,i)=0;

}

for(int i=0;i<N;i++){

hist_out[i] = 0;

pixelPro[i] = 0.0f;

}

int cols=_src.cols;

int rows=_src.rows;

assert(rows <= ROW);

assert(cols <= COL);

loop_height: for(int i=0;i<rows;i++){

loop_width: for(int j=0;j<cols;j++){

#pragma HLS PIPELINE

#pragma HLS LOOP_FLATTEN OFF

#pragma HLS DEPENDENCE array inter false

ap_uint<4> flag=NUM_STATES;

HLS_TNAME(SRC_T) tempsrc=0;

HLS_TNAME(DST_T) tempdst=0;

_src.data_stream[0] >> tempsrc;

tempdst = map[tempsrc];

_dst.data_stream[0] << tempdst;

for (int m=0; m<NUM_STATES; m++){

if (tempsrc==addr_win(0,m)){

flag = m;

break;

}

}

latency_region:{

#pragma HLS latency min=0 max=1

addr_last = addr_win(0,NUM_STATES-1);

hist_last = hist_win(0,NUM_STATES-1)+1;

for (int m=NUM_STATES-1; m>0; m--){

addr = addr_win(0,m-1);

hist = hist_win(0,m-1);

if (m == NUM_STATES/2) {

addr_w = addr;

if (m == flag+1) {

hist_w = hist+1;

} else {

hist_w = hist;

}

}

if (m==flag+1) {

addr_flag = addr;

hist_flag = hist+1;

addr_win(0,m) = addr_flag;

hist_win(0,m) = hist_flag;

} else {

addr_win(0,m) = addr;

hist_win(0,m) = hist;

}

}

if (flag==NUM_STATES) {

hist_win(0,0) = hist_out[tempsrc]+1;

addr_win(0,0) = tempsrc;

} else if (flag==NUM_STATES-1) {

addr_win(0,0) = addr_last;

hist_win(0,0) = hist_last;

} else if (flag>=NUM_STATES/2) {

addr_win(0,0) = addr_flag;

hist_win(0,0) = hist_flag;

} else {

addr_win(0,0) = addr_w;

hist_win(0,0) = hist_w;

}

hist_out[addr_w] = hist_w;

}

}

}

for (int m=0; m<NUM_STATES/2; m++) {

#pragma HLS PIPELINE

hist_out[addr_win(0,m)]=hist_win(0,m);

}

float scale = 255.0f/(cols*rows);

ap_uint<BitWidth<ROW*COL>::Value> sum=0;

loop_normalize: for(int i=0;i<N;i++){

#pragma HLS PIPELINE

tmp = hist_out[i];

pixelPro[i] = (float)(tmp)/(float)(cols*rows);

}

float w0, w1, u0tmp, u1tmp, u0, u1,deltaTmp, deltaMax = 0.0f;

loop_forward:for(int i = 0; i < 256; i++){

#pragma HLS loop_flatten off

w0 = w1 = u0tmp = u1tmp = u0 = u1 = deltaTmp = 0.0f;

loop_front:for(int j = 0; j < i; j++){

#pragma HLS PIPELINE II=5

w0 += pixelPro[j];

u0tmp += (float)j * pixelPro[j];

}

loop_back:for(int j = i; j < 256; j++){

#pragma HLPELINE II=5

u1tmp += (float)j * pixelPro[j];

}

w1 = 1 - w0;

u0 = u0tmp / w0;

u1 = u1tmp / w1;

deltaTmp = w0*w1*(u0-u1)*(u0-u1);

if(deltaTmp > deltaMax){

deltaMax = deltaTmp;

threshold = i;

}

}

#if Simulation

cout << "The Threshold is " << (int)(threshold) << endl;

#endif

loop_map:for(int i=0;i<N;i++){

#pragma HLS PIPELINE

tmp = hist_out[i];

sum+=tmp;

ap_uint<8> val=sr_cast< ap_uint<8> > (sum*scale);

#if Simulation

cout << "The data is " << (int)(threshold) << endl;

#endif

ap_uint<8> data_val = (val > threshold) ? 255 : 0;

map[i]=data_val;

}

map[0]=0;

}

static  ap_uint<8> array_data[256];

template<int SRC_T, int DST_T,int ROW, int COL>

void ostu_threshold(

Mat<ROW, COL, SRC_T> &_src,

Mat<ROW, COL, DST_T> &_dst)

{

#pragma HLS INLINE

threshold(_src, _dst, array_data);

}

}

void hls_otsu(AXI_STREAM& INPUT_STREAM, AXI_STREAM& OUTPUT_STREAM, int rows, int cols)

{

#pragma HLS INTERFACE axis port=INPUT_STREAM

#pragma HLS INTERFACE axis port=OUTPUT_STREAM

#pragma HLS RESOURCE core=AXI_SLAVE variable=rows metadata="-bus_bundle CONTROL_BUS"

#pragma HLS RESOURCE core=AXI_SLAVE variable=cols metadata="-bus_bundle CONTROL_BUS"

#pragma HLS RESOURCE core=AXI_SLAVE variable=return metadata="-bus_bundle CONTROL_BUS"

#pragma HLS INTERFACE ap_stable port=rows

#pragma HLS INTERFACE ap_stable port=cols

   // RGB_IMAGE  img_0(rows, cols);

    GRAY_IMAGE img_0(rows, cols);

    GRAY_IMAGE img_1(rows, cols);

    GRAY_IMAGE img_2(rows, cols);

    GRAY_IMAGE img_3(rows, cols);

// RGB_IMAGE img_3(rows, cols);

#pragma HLS dataflow

hls::AXIvideo2Mat(INPUT_STREAM, img_0);

hls::ostu_threshold(img_0,img_1);

hls::Dilate(img_1,img_2);

hls::Erode(img_2,img_3);

    hls::Mat2AXIvideo(img_3,OUTPUT_STREAM);

}