搜档网
当前位置:搜档网 › 布斯算法乘法器和算术运算器

布斯算法乘法器和算术运算器

布斯算法乘法器和算术运算器
布斯算法乘法器和算术运算器

Booth算法16位乘法器

西安电子科技大学大三集成电路设计与集成系统专业尹俊镖

一乘法器原理分析

16位有符号乘法器可以分为三个部分:根据输入的被乘数和乘数产生部分

积、部分积压缩产生和和进位、将产生的和和进位相加。这三个部分分别对应着

编码方式、拓扑结构以及加法器。

1编码方式:

本设计采用booth2编码。

部分积是负数时S=1,部分积是正数时S=0;

当部分积是+0时,E=1,部分积是-0时,E=0,其余情况E=S取反。

2拓扑结构:

本设计采用二进制树的拓扑结构。二进制树拓扑结构排列的较为规整,且部分积压缩的速度也非常快。

部分积压缩的目的是为了减小进位传播的延时,采用进位保留加法器,根据当前位信息产生下一位的进位,仅仅产生而没有进位行波传播,这样就可以把当前的多位压缩到较少的位数。经过几次压后,把部分积压缩成和以及进位。

部分积主要是通过counter和compressor进行压缩,通常使用(3:2)counter 和(4:2)compressor。

(3:2)counter其实质就是一个全加器,进位输入为ci,进位输出为c;(4:2)compressor可以由两个全加器组成,ci为进位输入,Coin为内部进位,输入到下一位的进位输入Ci,Coex为输出进位。

上图为二进制树的拓扑结构图,每4个部分积输入到一个(4:2)compressor 中,产生两个输出,则8个部分积使用3次(4:2)compressor就可以得到和和

进位。部分积的压缩方式可以见下图。

如图中所示,加上最后一个部分积的进位,共有9个部分积,本设计把最后的进位位移到第一个部分积上,使用5个全加器,把进位融合到第一个部分积,这样就转变成8个部分积了,再使用两级二进制树压缩,所以总共使用了三级压缩,最终得到部分积的和和进位。为了免去不必要的硬件开销,对于部分积边上的位采用counter压缩。上文提到的符号位扩展的改进方法,其目的也就是减少硬件开销,所以在不影响性能的情况下,单独出来部分积的边缘位是十分有必要的。

3加法器

本设计采用超前进位加法器。为了使得乘法器的延时最小,最后一级的加法器采用传播延时最小的超前进位加法器。

超前进位加法器的原理及构成,在此不做详述。

二仿真验证

对于16位乘法器的仿真验证,若采用穷举法,则有232种情况,验证次数太

多,所以只能采用随机数的验证方法。产生两个随机数,加入到乘法器的两个输入端,如此循环10000次,若没有错误,则可以认为乘法器功能正确。

X,Y是产生的两个随机数,product是两数的乘积,product_check是用于验证结果是否正确。Count用于计数,循环10000次,error记录计算一万次错误的次数,若发生错误,则退出仿真。

三源程序代码

1Booth2模块

module mul_16(x,y,product);//generate partial product

input[15:0]x;

input[15:0]y;

output[31:0]product;

wire[19:0]pp1;//partial product

wire[20:0]pp2;

wire[20:0]pp3;

wire[20:0]pp4;

wire[20:0]pp5;

wire[20:0]pp6;

wire[20:0]pp7;

wire[19:0]pp8;

reg symb8;//ninth partial product

reg[16:0]tpp1;

reg[16:0]tpp2;

reg[16:0]tpp3;

reg[16:0]tpp4;

reg[16:0]tpp5;

reg[16:0]tpp6;

reg[16:0]tpp7;

reg[16:0]tpp8;

reg symb1;

reg symb2;

reg symb3;

reg symb4;

reg symb5;

reg symb6;

reg symb7;

//the first partial product

always@(y or x)begin

symb1=1'b0;

case(y[1:0])

2'b00:tpp1=17'b0;

2'b01:tpp1={x[15],x};

2'b10:begin

tpp1=~{x,1'b0};

symb1=1'b1;

end

2'b11:begin

tpp1=~{x[15],x};

symb1=1'b1;

end

endcase

end

//the sencod partial product

always@(y or x)begin

symb2=1'b0;

case(y[3:1])

3'b000:tpp2=17'b0;

3'b001,

3'b010:tpp2={x[15],x};

3'b011:tpp2={x,1'b0};

3'b100:begin

tpp2=~{x,1'b0};

symb2=1'b1;

end

3'b101,

3'b110:begin

tpp2=~{x[15],x};

symb2=1'b1;

end

3'b111:tpp2={1'b0,16'b0};

endcase

end

//the third partial product

always@(y or x)begin

symb3=1'b0;

case(y[5:3])

3'b000:tpp3=17'b0;

3'b001,

3'b010:tpp3={x[15],x};

3'b011:tpp3={x,1'b0};

3'b100:begin

tpp3=~{x,1'b0};

symb3=1'b1;

end

3'b101,

3'b110:begin

tpp3=~{x[15],x};

symb3=1'b1;

end

3'b111:tpp3={1'b0,16'b0};

endcase

end

//the fourth partial product

always@(y or x)begin

symb4=1'b0;

case(y[7:5])

3'b000:tpp4=17'b0;

3'b001,

3'b010:tpp4={x[15],x};

3'b011:tpp4={x,1'b0};

3'b100:begin

tpp4=~{x,1'b0};

symb4=1'b1;

end

3'b101,

3'b110:begin

tpp4=~{x[15],x};

symb4=1'b1;

end

3'b111:tpp4={1'b0,16'b0};

endcase

end

//the fifth partial product

always@(y or x)begin

symb5=1'b0;

case(y[9:7])

3'b000:tpp5=17'b0;

3'b001,

3'b010:tpp5={x[15],x};

3'b011:tpp5={x,1'b0};

3'b100:begin

tpp5=~{x,1'b0};

symb5=1'b1;

end

3'b101,

3'b110:begin

tpp5=~{x[15],x};

symb5=1'b1;

end

3'b111:tpp5={1'b0,16'b0};

endcase

end

//the sixth partial product

always@(y or x)begin

symb6=1'b0;

case(y[11:9])

3'b000:tpp6=17'b0;

3'b001,

3'b010:tpp6={x[15],x};

3'b011:tpp6={x,1'b0};

3'b100:begin

tpp6=~{x,1'b0};

symb6=1'b1;

end

3'b101,

3'b110:begin

tpp6=~{x[15],x};

symb6=1'b1;

end

3'b111:tpp6={1'b0,16'b0};

endcase

end

//the seventh partial product

always@(y or x)begin

symb7=1'b0;

case(y[13:11])

3'b000:tpp7=17'b0;

3'b001,

3'b010:tpp7={x[15],x};

3'b011:tpp7={x,1'b0};

3'b100:begin

tpp7=~{x,1'b0};

symb7=1'b1;

end

3'b101,

3'b110:begin

tpp7=~{x[15],x};

symb7=1'b1;

end

3'b111:tpp7={1'b0,16'b0};

endcase

end

//the eighth partial product

always@(y or x)begin

symb8=1'b0;

case(y[15:13])

3'b000:tpp8=17'b0;

3'b001,

3'b010:tpp8={x[15],x};

3'b011:tpp8={x,1'b0};

3'b100:begin

tpp8=~{x,1'b0};

symb8=1'b1;

end

3'b101,

3'b110:begin

tpp8=~{x[15],x};

symb8=1'b1;

end

3'b111:tpp8={1'b0,16'b0};

endcase

end

assign pp1[19:0]={!tpp1[16],tpp1[16],tpp1[16],tpp1};

assign pp2[20:0]={1'b1,!tpp2[16],tpp2,1'b0,symb1};

assign pp3[20:0]={1'b1,!tpp3[16],tpp3,1'b0,symb2};

assign pp4[20:0]={1'b1,!tpp4[16],tpp4,1'b0,symb3};

assign pp5[20:0]={1'b1,!tpp5[16],tpp5,1'b0,symb4};

assign pp6[20:0]={1'b1,!tpp6[16],tpp6,1'b0,symb5};

assign pp7[20:0]={1'b1,!tpp7[16],tpp7,1'b0,symb6};

assign pp8[19:0]={!tpp8[16],tpp8,1'b0,symb7};

compressor comprs(.pp1(pp1),

.pp2(pp2),

.pp3(pp3),

.pp4(pp4),

.pp5(pp5),

.pp6(pp6),

.pp7(pp7),

.pp8(pp8),

.symb8(symb8),

.product(product));

endmodule

2加法器

module adder_32(input[31:0]add_in1,add_in2,

//input c0,

output[31:0]add_out);

wire[31:0]p,g,psum;

//form the psum?propagate and generate signals from the input xor(psum[0],add_in1[0],add_in2[0]);

xor(psum[1],add_in1[1],add_in2[1]);

xor(psum[2],add_in1[2],add_in2[2]);

xor(psum[3],add_in1[3],add_in2[3]);

xor(psum[4],add_in1[4],add_in2[4]);

xor(psum[5],add_in1[5],add_in2[5]);

xor(psum[6],add_in1[6],add_in2[6]);

xor(psum[7],add_in1[7],add_in2[7]);

xor(psum[8],add_in1[8],add_in2[8]);

xor(psum[9],add_in1[9],add_in2[9]);

xor(psum[10],add_in1[10],add_in2[10]);

xor(psum[11],add_in1[11],add_in2[11]); xor(psum[12],add_in1[12],add_in2[12]); xor(psum[13],add_in1[13],add_in2[13]); xor(psum[14],add_in1[14],add_in2[14]); xor(psum[15],add_in1[15],add_in2[15]); xor(psum[16],add_in1[16],add_in2[16]); xor(psum[17],add_in1[17],add_in2[17]); xor(psum[18],add_in1[18],add_in2[18]); xor(psum[19],add_in1[19],add_in2[19]); xor(psum[20],add_in1[20],add_in2[20]); xor(psum[21],add_in1[21],add_in2[21]); xor(psum[22],add_in1[22],add_in2[22]); xor(psum[23],add_in1[23],add_in2[23]); xor(psum[24],add_in1[24],add_in2[24]); xor(psum[25],add_in1[25],add_in2[25]); xor(psum[26],add_in1[26],add_in2[26]); xor(psum[27],add_in1[27],add_in2[27]); xor(psum[28],add_in1[28],add_in2[28]); xor(psum[29],add_in1[29],add_in2[29]); xor(psum[30],add_in1[30],add_in2[30]); xor(psum[31],add_in1[31],add_in2[31]);

or(p[0],add_in1[0],add_in2[0]);

or(p[1],add_in1[1],add_in2[1]);

or(p[2],add_in1[2],add_in2[2]);

or(p[3],add_in1[3],add_in2[3]);

or(p[4],add_in1[4],add_in2[4]);

or(p[5],add_in1[5],add_in2[5]);

or(p[6],add_in1[6],add_in2[6]);

or(p[7],add_in1[7],add_in2[7]);

or(p[8],add_in1[8],add_in2[8]);

or(p[9],add_in1[9],add_in2[9]);

or(p[10],add_in1[10],add_in2[10]);

or(p[11],add_in1[11],add_in2[11]);

or(p[12],add_in1[12],add_in2[12]);

or(p[13],add_in1[13],add_in2[13]);

or(p[14],add_in1[14],add_in2[14]);

or(p[15],add_in1[15],add_in2[15]);

or(p[16],add_in1[16],add_in2[16]);

or(p[17],add_in1[17],add_in2[17]);

or(p[18],add_in1[18],add_in2[18]);

or(p[19],add_in1[19],add_in2[19]);

or(p[20],add_in1[20],add_in2[20]);

or(p[21],add_in1[21],add_in2[21]);

or(p[22],add_in1[22],add_in2[22]); or(p[23],add_in1[23],add_in2[23]); or(p[24],add_in1[24],add_in2[24]); or(p[25],add_in1[25],add_in2[25]); or(p[26],add_in1[26],add_in2[26]); or(p[27],add_in1[27],add_in2[27]); or(p[28],add_in1[28],add_in2[28]); or(p[29],add_in1[29],add_in2[29]); or(p[30],add_in1[30],add_in2[30]); or(p[31],add_in1[31],add_in2[31]);

and(g[0],add_in1[0],add_in2[0]); and(g[1],add_in1[1],add_in2[1]); and(g[2],add_in1[2],add_in2[2]); and(g[3],add_in1[3],add_in2[3]); and(g[4],add_in1[4],add_in2[4]); and(g[5],add_in1[5],add_in2[5]); and(g[6],add_in1[6],add_in2[6]); and(g[7],add_in1[7],add_in2[7]); and(g[8],add_in1[8],add_in2[8]); and(g[9],add_in1[9],add_in2[9]); and(g[10],add_in1[10],add_in2[10]); and(g[11],add_in1[11],add_in2[11]); and(g[12],add_in1[12],add_in2[12]); and(g[13],add_in1[13],add_in2[13]); and(g[14],add_in1[14],add_in2[14]); and(g[15],add_in1[15],add_in2[15]); and(g[16],add_in1[16],add_in2[16]); and(g[17],add_in1[17],add_in2[17]); and(g[18],add_in1[18],add_in2[18]); and(g[19],add_in1[19],add_in2[19]); and(g[20],add_in1[20],add_in2[20]); and(g[21],add_in1[21],add_in2[21]); and(g[22],add_in1[22],add_in2[22]); and(g[23],add_in1[23],add_in2[23]); and(g[24],add_in1[24],add_in2[24]); and(g[25],add_in1[25],add_in2[25]); and(g[26],add_in1[26],add_in2[26]); and(g[27],add_in1[27],add_in2[27]); and(g[28],add_in1[28],add_in2[28]); and(g[29],add_in1[29],add_in2[29]); and(g[30],add_in1[30],add_in2[30]); and(g[31],add_in1[31],add_in2[31]);

//first level of operator

wire[31:1]p1,g1;

wire[31:2]p2,g2;

wire[31:4]p3,g3;

wire[31:8]p4,g4;

wire[31:16]p5,g5;

op op11(.p1(p[0]),.p2(p[1]),.g1(g[0]),.g2(g[1]),

.p3(p1[1]),.g3(g1[1]));

op op12(.p1(p[1]),.p2(p[2]),.g1(g[1]),.g2(g[2]),

.p3(p1[2]),.g3(g1[2]));

op op13(.p1(p[2]),.p2(p[3]),.g1(g[2]),.g2(g[3]),

.p3(p1[3]),.g3(g1[3]));

op op14(.p1(p[3]),.p2(p[4]),.g1(g[3]),.g2(g[4]),

.p3(p1[4]),.g3(g1[4]));

op op15(.p1(p[4]),.p2(p[5]),.g1(g[4]),.g2(g[5]),

.p3(p1[5]),.g3(g1[5]));

op op16(.p1(p[5]),.p2(p[6]),.g1(g[5]),.g2(g[6]),

.p3(p1[6]),.g3(g1[6]));

op op17(.p1(p[6]),.p2(p[7]),.g1(g[6]),.g2(g[7]),

.p3(p1[7]),.g3(g1[7]));

op op18(.p1(p[7]),.p2(p[8]),.g1(g[7]),.g2(g[8]),

.p3(p1[8]),.g3(g1[8]));

op op19(.p1(p[8]),.p2(p[9]),.g1(g[8]),.g2(g[9]),

.p3(p1[9]),.g3(g1[9]));

op op110(.p1(p[9]),.p2(p[10]),.g1(g[9]),.g2(g[10]),

.p3(p1[10]),.g3(g1[10]));

op op111(.p1(p[10]),.p2(p[11]),.g1(g[10]),.g2(g[11]),

.p3(p1[11]),.g3(g1[11]));

op op112(.p1(p[11]),.p2(p[12]),.g1(g[11]),.g2(g[12]),

.p3(p1[12]),.g3(g1[12]));

op op113(.p1(p[12]),.p2(p[13]),.g1(g[12]),.g2(g[13]),

.p3(p1[13]),.g3(g1[13]));

op op114(.p1(p[13]),.p2(p[14]),.g1(g[13]),.g2(g[14]),

.p3(p1[14]),.g3(g1[14]));

op op115(.p1(p[14]),.p2(p[15]),.g1(g[14]),.g2(g[15]),

.p3(p1[15]),.g3(g1[15]));

op op116(.p1(p[15]),.p2(p[16]),.g1(g[15]),.g2(g[16]),

.p3(p1[16]),.g3(g1[16]));

op op117(.p1(p[16]),.p2(p[17]),.g1(g[16]),.g2(g[17]),

.p3(p1[17]),.g3(g1[17]));

op op118(.p1(p[17]),.p2(p[18]),.g1(g[17]),.g2(g[18]),

.p3(p1[18]),.g3(g1[18]));

op op119(.p1(p[18]),.p2(p[19]),.g1(g[18]),.g2(g[19]),

.p3(p1[19]),.g3(g1[19]));

op op120(.p1(p[19]),.p2(p[20]),.g1(g[19]),.g2(g[20]),

.p3(p1[20]),.g3(g1[20]));

op op121(.p1(p[20]),.p2(p[21]),.g1(g[20]),.g2(g[21]),

.p3(p1[21]),.g3(g1[21]));

op op122(.p1(p[21]),.p2(p[22]),.g1(g[21]),.g2(g[22]),

.p3(p1[22]),.g3(g1[22]));

op op123(.p1(p[22]),.p2(p[23]),.g1(g[22]),.g2(g[23]),

.p3(p1[23]),.g3(g1[23]));

op op124(.p1(p[23]),.p2(p[24]),.g1(g[23]),.g2(g[24]),

.p3(p1[24]),.g3(g1[24]));

op op125(.p1(p[24]),.p2(p[25]),.g1(g[24]),.g2(g[25]),

.p3(p1[25]),.g3(g1[25]));

op op126(.p1(p[25]),.p2(p[26]),.g1(g[25]),.g2(g[26]),

.p3(p1[26]),.g3(g1[26]));

op op127(.p1(p[26]),.p2(p[27]),.g1(g[26]),.g2(g[27]),

.p3(p1[27]),.g3(g1[27]));

op op128(.p1(p[27]),.p2(p[28]),.g1(g[27]),.g2(g[28]),

.p3(p1[28]),.g3(g1[28]));

op op129(.p1(p[28]),.p2(p[29]),.g1(g[28]),.g2(g[29]),

.p3(p1[29]),.g3(g1[29]));

op op130(.p1(p[29]),.p2(p[30]),.g1(g[29]),.g2(g[30]),

.p3(p1[30]),.g3(g1[30]));

op op131(.p1(p[30]),.p2(p[31]),.g1(g[30]),.g2(g[31]),

.p3(p1[31]),.g3(g1[31]));

//second level

op op22(.p1(p[0]),.p2(p1[2]),.g1(g[0]),.g2(g1[2]),

.p3(p2[2]),.g3(g2[2]));

op op23(.p1(p1[1]),.p2(p1[3]),.g1(g1[1]),.g2(g1[3]),

.p3(p2[3]),.g3(g2[3]));

op op24(.p1(p1[2]),.p2(p1[4]),.g1(g1[2]),.g2(g1[4]),

.p3(p2[4]),.g3(g2[4]));

op op25(.p1(p1[3]),.p2(p1[5]),.g1(g1[3]),.g2(g1[5]),

.p3(p2[5]),.g3(g2[5]));

op op26(.p1(p1[4]),.p2(p1[6]),.g1(g1[4]),.g2(g1[6]),

.p3(p2[6]),.g3(g2[6]));

op op27(.p1(p1[5]),.p2(p1[7]),.g1(g1[5]),.g2(g1[7]),

.p3(p2[7]),.g3(g2[7]));

op op28(.p1(p1[6]),.p2(p1[8]),.g1(g1[6]),.g2(g1[8]),

.p3(p2[8]),.g3(g2[8]));

op op29(.p1(p1[7]),.p2(p1[9]),.g1(g1[7]),.g2(g1[9]),

.p3(p2[9]),.g3(g2[9]));

op op210(.p1(p1[8]),.p2(p1[10]),.g1(g1[8]),.g2(g1[10]), .p3(p2[10]),.g3(g2[10]));

op op211(.p1(p1[9]),.p2(p1[11]),.g1(g1[9]),.g2(g1[11]), .p3(p2[11]),.g3(g2[11]));

op op212(.p1(p1[10]),.p2(p1[12]),.g1(g1[10]),.g2(g1[12]), .p3(p2[12]),.g3(g2[12]));

op op213(.p1(p1[11]),.p2(p1[13]),.g1(g1[11]),.g2(g1[13]), .p3(p2[13]),.g3(g2[13]));

op op214(.p1(p1[12]),.p2(p1[14]),.g1(g1[12]),.g2(g1[14]), .p3(p2[14]),.g3(g2[14]));

op op215(.p1(p1[13]),.p2(p1[15]),.g1(g1[13]),.g2(g1[15]), .p3(p2[15]),.g3(g2[15]));

op op216(.p1(p1[14]),.p2(p1[16]),.g1(g1[14]),.g2(g1[16]), .p3(p2[16]),.g3(g2[16]));

op op217(.p1(p1[15]),.p2(p1[17]),.g1(g1[15]),.g2(g1[17]), .p3(p2[17]),.g3(g2[17]));

op op218(.p1(p1[16]),.p2(p1[18]),.g1(g1[16]),.g2(g1[18]), .p3(p2[18]),.g3(g2[18]));

op op219(.p1(p1[17]),.p2(p1[19]),.g1(g1[17]),.g2(g1[19]), .p3(p2[19]),.g3(g2[19]));

op op220(.p1(p1[18]),.p2(p1[20]),.g1(g1[18]),.g2(g1[20]), .p3(p2[20]),.g3(g2[20]));

op op221(.p1(p1[19]),.p2(p1[21]),.g1(g1[19]),.g2(g1[21]), .p3(p2[21]),.g3(g2[21]));

op op222(.p1(p1[20]),.p2(p1[22]),.g1(g1[20]),.g2(g1[22]), .p3(p2[22]),.g3(g2[22]));

op op223(.p1(p1[21]),.p2(p1[23]),.g1(g1[21]),.g2(g1[23]), .p3(p2[23]),.g3(g2[23]));

op op224(.p1(p1[22]),.p2(p1[24]),.g1(g1[22]),.g2(g1[24]), .p3(p2[24]),.g3(g2[24]));

op op225(.p1(p1[23]),.p2(p1[25]),.g1(g1[23]),.g2(g1[25]), .p3(p2[25]),.g3(g2[25]));

op op226(.p1(p1[24]),.p2(p1[26]),.g1(g1[24]),.g2(g1[26]), .p3(p2[26]),.g3(g2[26]));

op op227(.p1(p1[25]),.p2(p1[27]),.g1(g1[25]),.g2(g1[27]), .p3(p2[27]),.g3(g2[27]));

op op228(.p1(p1[26]),.p2(p1[28]),.g1(g1[26]),.g2(g1[28]), .p3(p2[28]),.g3(g2[28]));

op op229(.p1(p1[27]),.p2(p1[29]),.g1(g1[27]),.g2(g1[29]), .p3(p2[29]),.g3(g2[29]));

op op230(.p1(p1[28]),.p2(p1[30]),.g1(g1[28]),.g2(g1[30]), .p3(p2[30]),.g3(g2[30]));

op op231(.p1(p1[29]),.p2(p1[31]),.g1(g1[29]),.g2(g1[31]), .p3(p2[31]),.g3(g2[31]));

//third level

op op34(.p1(p[0]),.p2(p2[4]),.g1(g[0]),.g2(g2[4]),

.p3(p3[4]),.g3(g3[4]));

op op35(.p1(p1[1]),.p2(p2[5]),.g1(g1[1]),.g2(g2[5]),

.p3(p3[5]),.g3(g3[5]));

op op36(.p1(p2[2]),.p2(p2[6]),.g1(g2[2]),.g2(g2[6]),

.p3(p3[6]),.g3(g3[6]));

op op37(.p1(p2[3]),.p2(p2[7]),.g1(g2[3]),.g2(g2[7]),

.p3(p3[7]),.g3(g3[7]));

op op38(.p1(p2[4]),.p2(p2[8]),.g1(g2[4]),.g2(g2[8]),

.p3(p3[8]),.g3(g3[8]));

op op39(.p1(p2[5]),.p2(p2[9]),.g1(g2[5]),.g2(g2[9]),

.p3(p3[9]),.g3(g3[9]));

op op310(.p1(p2[6]),.p2(p2[10]),.g1(g2[6]),.g2(g2[10]),

.p3(p3[10]),.g3(g3[10]));

op op311(.p1(p2[7]),.p2(p2[11]),.g1(g2[7]),.g2(g2[11]),

.p3(p3[11]),.g3(g3[11]));

op op312(.p1(p2[8]),.p2(p2[12]),.g1(g2[8]),.g2(g2[12]),

.p3(p3[12]),.g3(g3[12]));

op op313(.p1(p2[9]),.p2(p2[13]),.g1(g2[9]),.g2(g2[13]),

.p3(p3[13]),.g3(g3[13]));

op op314(.p1(p2[10]),.p2(p2[14]),.g1(g2[10]),.g2(g2[14]),

.p3(p3[14]),.g3(g3[14]));

op op315(.p1(p2[11]),.p2(p2[15]),.g1(g2[11]),.g2(g2[15]),

.p3(p3[15]),.g3(g3[15]));

op op316(.p1(p2[12]),.p2(p2[16]),.g1(g2[12]),.g2(g2[16]),

.p3(p3[16]),.g3(g3[16]));

op op317(.p1(p2[13]),.p2(p2[17]),.g1(g2[13]),.g2(g2[17]),

.p3(p3[17]),.g3(g3[17]));

op op318(.p1(p2[14]),.p2(p2[18]),.g1(g2[14]),.g2(g2[18]),

.p3(p3[18]),.g3(g3[18]));

op op319(.p1(p2[15]),.p2(p2[19]),.g1(g2[15]),.g2(g2[19]),

.p3(p3[19]),.g3(g3[19]));

op op320(.p1(p2[16]),.p2(p2[20]),.g1(g2[16]),.g2(g2[20]),

.p3(p3[20]),.g3(g3[20]));

op op321(.p1(p2[17]),.p2(p2[21]),.g1(g2[17]),.g2(g2[21]),

.p3(p3[21]),.g3(g3[21]));

op op322(.p1(p2[18]),.p2(p2[22]),.g1(g2[18]),.g2(g2[22]),

.p3(p3[22]),.g3(g3[22]));

op op323(.p1(p2[19]),.p2(p2[23]),.g1(g2[19]),.g2(g2[23]),

.p3(p3[23]),.g3(g3[23]));

.p3(p3[24]),.g3(g3[24]));

op op325(.p1(p2[21]),.p2(p2[25]),.g1(g2[21]),.g2(g2[25]),

.p3(p3[25]),.g3(g3[25]));

op op326(.p1(p2[22]),.p2(p2[26]),.g1(g2[22]),.g2(g2[26]),

.p3(p3[26]),.g3(g3[26]));

op op327(.p1(p2[23]),.p2(p2[27]),.g1(g2[23]),.g2(g2[27]),

.p3(p3[27]),.g3(g3[27]));

op op328(.p1(p2[24]),.p2(p2[28]),.g1(g2[24]),.g2(g2[28]),

.p3(p3[28]),.g3(g3[28]));

op op329(.p1(p2[25]),.p2(p2[29]),.g1(g2[25]),.g2(g2[29]),

.p3(p3[29]),.g3(g3[29]));

op op330(.p1(p2[26]),.p2(p2[30]),.g1(g2[26]),.g2(g2[30]),

.p3(p3[30]),.g3(g3[30]));

op op331(.p1(p2[27]),.p2(p2[31]),.g1(g2[27]),.g2(g2[31]),

.p3(p3[31]),.g3(g3[31]));

//firth level

op op48(.p1(p[0]),.p2(p3[8]),.g1(g[0]),.g2(g3[8]),

.p3(p4[8]),.g3(g4[8]));

op op49(.p1(p1[1]),.p2(p3[9]),.g1(g1[1]),.g2(g3[9]),

.p3(p4[9]),.g3(g4[9]));

op op410(.p1(p2[2]),.p2(p3[10]),.g1(g2[2]),.g2(g3[10]),

.p3(p4[10]),.g3(g4[10]));

op op411(.p1(p2[3]),.p2(p3[11]),.g1(g2[3]),.g2(g3[11]),

.p3(p4[11]),.g3(g4[11]));

op op412(.p1(p3[4]),.p2(p3[12]),.g1(g3[4]),.g2(g3[12]),

.p3(p4[12]),.g3(g4[12]));

op op413(.p1(p3[5]),.p2(p3[13]),.g1(g3[5]),.g2(g3[13]),

.p3(p4[13]),.g3(g4[13]));

op op414(.p1(p3[6]),.p2(p3[14]),.g1(g3[6]),.g2(g3[14]),

.p3(p4[14]),.g3(g4[14]));

op op415(.p1(p3[7]),.p2(p3[15]),.g1(g3[7]),.g2(g3[15]),

.p3(p4[15]),.g3(g4[15]));

op op416(.p1(p3[8]),.p2(p3[16]),.g1(g3[8]),.g2(g3[16]),

.p3(p4[16]),.g3(g4[16]));

op op417(.p1(p3[9]),.p2(p3[17]),.g1(g3[9]),.g2(g3[17]),

.p3(p4[17]),.g3(g4[17]));

op op418(.p1(p3[10]),.p2(p3[18]),.g1(g3[10]),.g2(g3[18]),

.p3(p4[18]),.g3(g4[18]));

op op419(.p1(p3[11]),.p2(p3[19]),.g1(g3[11]),.g2(g3[19]),

.p3(p4[19]),.g3(g4[19]));

.p3(p4[20]),.g3(g4[20]));

op op421(.p1(p3[13]),.p2(p3[21]),.g1(g3[13]),.g2(g3[21]),

.p3(p4[21]),.g3(g4[21]));

op op422(.p1(p3[14]),.p2(p3[22]),.g1(g3[14]),.g2(g3[22]),

.p3(p4[22]),.g3(g4[22]));

op op423(.p1(p3[15]),.p2(p3[23]),.g1(g3[15]),.g2(g3[23]),

.p3(p4[23]),.g3(g4[23]));

op op424(.p1(p3[16]),.p2(p3[24]),.g1(g3[16]),.g2(g3[24]),

.p3(p4[24]),.g3(g4[24]));

op op425(.p1(p3[17]),.p2(p3[25]),.g1(g3[17]),.g2(g3[25]),

.p3(p4[25]),.g3(g4[25]));

op op426(.p1(p3[18]),.p2(p3[26]),.g1(g3[18]),.g2(g3[26]),

.p3(p4[26]),.g3(g4[26]));

op op427(.p1(p3[19]),.p2(p3[27]),.g1(g3[19]),.g2(g3[27]),

.p3(p4[27]),.g3(g4[27]));

op op428(.p1(p3[20]),.p2(p3[28]),.g1(g3[20]),.g2(g3[28]),

.p3(p4[28]),.g3(g4[28]));

op op429(.p1(p3[21]),.p2(p3[29]),.g1(g3[21]),.g2(g3[29]),

.p3(p4[29]),.g3(g4[29]));

op op430(.p1(p3[22]),.p2(p3[30]),.g1(g3[22]),.g2(g3[30]),

.p3(p4[30]),.g3(g4[30]));

op op431(.p1(p3[23]),.p2(p3[31]),.g1(g3[23]),.g2(g3[31]),

.p3(p4[31]),.g3(g4[31]));

//fifth level

op op516(.p1(p[0]),.p2(p4[16]),.g1(g[0]),.g2(g4[16]),

.p3(p5[16]),.g3(g5[16]));

op op517(.p1(p1[1]),.p2(p4[17]),.g1(g1[1]),.g2(g4[17]),

.p3(p5[17]),.g3(g5[17]));

op op518(.p1(p2[2]),.p2(p4[18]),.g1(g2[2]),.g2(g4[18]),

.p3(p5[18]),.g3(g5[18]));

op op519(.p1(p2[3]),.p2(p4[19]),.g1(g2[3]),.g2(g4[19]),

.p3(p5[19]),.g3(g5[19]));

op op520(.p1(p3[4]),.p2(p4[20]),.g1(g3[4]),.g2(g4[20]),

.p3(p5[20]),.g3(g5[20]));

op op521(.p1(p3[5]),.p2(p4[21]),.g1(g3[5]),.g2(g4[21]),

.p3(p5[21]),.g3(g5[21]));

op op522(.p1(p3[6]),.p2(p4[22]),.g1(g3[6]),.g2(g4[22]),

.p3(p5[22]),.g3(g5[22]));

op op523(.p1(p3[7]),.p2(p4[23]),.g1(g3[7]),.g2(g4[23]),

.p3(p5[23]),.g3(g5[23]));

op op524(.p1(p4[8]),.p2(p4[24]),.g1(g4[8]),.g2(g4[24]),

.p3(p5[24]),.g3(g5[24]));

.p3(p5[25]),.g3(g5[25]));

op op526(.p1(p4[10]),.p2(p4[26]),.g1(g4[10]),.g2(g4[26]),

.p3(p5[26]),.g3(g5[26]));

op op527(.p1(p4[11]),.p2(p4[27]),.g1(g4[11]),.g2(g4[27]),

.p3(p5[27]),.g3(g5[27]));

op op528(.p1(p4[12]),.p2(p4[28]),.g1(g4[12]),.g2(g4[28]),

.p3(p5[28]),.g3(g5[28]));

op op529(.p1(p4[13]),.p2(p4[29]),.g1(g4[13]),.g2(g4[29]),

.p3(p5[29]),.g3(g5[29]));

op op530(.p1(p4[14]),.p2(p4[30]),.g1(g4[14]),.g2(g4[30]),

.p3(p5[30]),.g3(g5[30]));

op op531(.p1(p4[15]),.p2(p4[31]),.g1(g4[15]),.g2(g4[31]),

.p3(p5[31]),.g3(g5[31]));

wire[31:1]co;

//assign co[1]=g[0]|(p[0]&c0);

//assign co[2]=g1[1]|(p1[1]&c0);

//assign co[3]=g2[2]|(p2[2]&c0);

assign co[1]=g[0];

assign co[2]=g1[1];

assign co[3]=g2[2];

assign co[4]=g2[3];

assign co[5]=g3[4];

assign co[6]=g3[5];

assign co[7]=g3[6];

assign co[8]=g3[7];

assign co[9]=g4[8];

assign co[10]=g4[9];

assign co[11]=g4[10];

assign co[12]=g4[11];

assign co[13]=g4[12];

assign co[14]=g4[13];

assign co[15]=g4[14];

assign co[16]=g4[15];

assign co[17]=g5[16];

assign co[18]=g5[17];

assign co[19]=g5[18];

assign co[20]=g5[19];

assign co[21]=g5[20];

assign co[22]=g5[21];

assign co[23]=g5[22];

assign co[24]=g5[23];

assign co[25]=g5[24];

assign co[26]=g5[25];

assign co[27]=g5[26];

assign co[28]=g5[27];

assign co[29]=g5[28];

assign co[30]=g5[29];

assign co[31]=g5[30];

//assign add_out[32]=g5[31];

//xor(add_out[0],psum[0],c0);

assign add_out[0]=psum[0];

xor(add_out[1],psum[1],co[1]);

xor(add_out[2],psum[2],co[2]);

xor(add_out[3],psum[3],co[3]);

xor(add_out[4],psum[4],co[4]);

xor(add_out[5],psum[5],co[5]);

xor(add_out[6],psum[6],co[6]);

xor(add_out[7],psum[7],co[7]);

xor(add_out[8],psum[8],co[8]);

xor(add_out[9],psum[9],co[9]);

xor(add_out[10],psum[10],co[10]);

xor(add_out[11],psum[11],co[11]);

xor(add_out[12],psum[12],co[12]);

xor(add_out[13],psum[13],co[13]);

xor(add_out[14],psum[14],co[14]);

xor(add_out[15],psum[15],co[15]);

xor(add_out[16],psum[16],co[16]);

xor(add_out[17],psum[17],co[17]);

xor(add_out[18],psum[18],co[18]);

xor(add_out[19],psum[19],co[19]);

xor(add_out[20],psum[20],co[20]);

xor(add_out[21],psum[21],co[21]);

xor(add_out[22],psum[22],co[22]);

xor(add_out[23],psum[23],co[23]);

xor(add_out[24],psum[24],co[24]);

xor(add_out[25],psum[25],co[25]);

xor(add_out[26],psum[26],co[26]);

xor(add_out[27],psum[27],co[27]);

xor(add_out[28],psum[28],co[28]);

xor(add_out[29],psum[29],co[29]);

xor(add_out[30],psum[30],co[30]);

xor(add_out[31],psum[31],co[31]); endmodule

//operator carry_propagate and generate

module op(input p1,p2,g1,g2,

output p3,g3);

assign p3=p1&p2;

assign g3=g2|(p2&g1);

endmodule

3拓扑结构

module compressor(pp1,pp2,pp3,pp4,pp5,pp6,pp7,pp8,symb8,product);

input[19:0]pp1;

input[20:0]pp2;

input[20:0]pp3;

input[20:0]pp4;

input[20:0]pp5;

input[20:0]pp6;

input[20:0]pp7;

input[19:0]pp8;

input symb8;

//output[31:0]sum;

//output[31:0]carry;

output[31:0]product;

wire[31:0]sum;

wire[31:0]carry;

//************************************************************ //***********************first level compressor**********

wire sum14;

wire sum15;

wire sum16;

wire sum17;

wire sum18;

wire sum19;

wire co15;

wire co16;

wire co17;

wire co18;

wire co19;

ha ha14(.a(symb8),

.b(pp1[14]),

.sum(sum14),

运算方法和运算器习题参考答案

1. 写出下列各数的原码、反码、补码、移码表示(用8位二进制数)。其中MSB是最高位(又是符号位)LSB是最低位。如果是小数,小数点在MSB之后;如果是整数,小数点在LSB之后。 (1) -35/64 (2) 23/128 (3) -127 (4) 用小数表示-1 (5) 用整数表示-1 解:(1)先把十进制数-35/64写成二进制小数: (-35/64)10=(-100011/1000000)2=(-100011×2-110)2=(-0.100011)2 令x=-0.100011B ∴ [x]原=1.1000110 (注意位数为8位) [x]反=1.0111001 [x]补=1.0111010 [x]移=0.0111010 (2) 先把十进制数23/128写成二进制小数: (23/128)10=(10111/)2=(10111×2-111)2=(0.0001011)2 令x=0.0001011B ∴ [x]原=0.0001011 [x]反=0.0001011 [x]补=0.0001011 [x]移=1.0001011 (3) 先把十进制数-127写成二进制小数: (-127)10=(-1111111)2 令x= -1111111B ∴ [x]原=1.1111111 [x]反=1.0000000 [x]补=1.0000001 [x]移=1.0000001 (4) 令x=-1.000000B ∴ 原码、反码无法表示 [x]补=1.0000000 [x]移=0.0000000 (5) 令Y=-1=-0000001B ∴ [Y]原= [Y]反= [Y]补= [Y]移=01111111 2. 设[X]补= a0,a1,a2…a6 , 其中a i取0或1,若要x>-0.5,求a0,a1,a2,…,a6的取值。 解:a0= 1,a1= 0, a2,…,a6=1…1。 3. 有一个字长为32位的浮点数,阶码10位(包括1位阶符),用移码表示;尾数22位(包括1位尾符)用补码表示,基数R=2。请写出: (1) 最大数的二进制表示; (2) 最小数的二进制表示; (3) 规格化数所能表示的数的范围; (4) 最接近于零的正规格化数与负规格化数。 解:(1)11 0111111 (2)11 0000000

计算机组成原理第3章 运算器和运算方法

第三章运算方法和运算器3.1补码的移位运算 1、左移运算:各位依次左移,末位补0 对于算术左移,若没有改变符号位,左移相当于乘以2。 2、右移运算: 算术右移:符号位不变,各位(包括符号位)依次右移。(相当于除以2)逻辑右移:最高位补0,其余各位依次右移 例1:已知X=0.1011 ,Y=-0.0101 求 [0.5X]补;[0.25X]补; [-X]补;2[-X]补;[0.5Y]补;[0.25Y]补; [-Y]补;2[-Y]补[X]补=0.1011 [Y]补=1.1011 [0.5X]补=0.01011 [0.5Y]补=1.11011 [0.25X]补=0.001011 [0.25Y]补=1.111011 [-X]补=1.0101 [-Y]补=0.0101 2[-X]补=0.1010 (溢出) 2[-Y]补=0.1010 3.2定点加减法运算及其实现 3.2.1 补码加减法运算方法 由于计算机中的进行定点数的加减运算大都是采用补码。 (1)公式: [X+Y]补=[X]补+[Y]补 [X-Y]补=[X]补+[-Y]补(证明过程见教材P38) 例1 X=0.001010 Y=-0.100011 求[X-Y]补,[X+Y]补 解:[X]补=0.001010 [-Y]补=0.100011 则 [X-Y]补=[X]补+[-Y]补=0.001010 + 0.100011=0.101101 [X]补=0.001010 [Y]补=1.011101 则 [X+Y]补=[X]补+[Y]补=0.001010 + 1.011101=1.100111 例2:已知X=+0.25,Y=-0.625,求X+Y; X-Y写出计算的过程. 例3:已知X=25,Y=-9,求X+Y; X-Y写出计算的过程. 例4:已知X=-25,Y=-9,求X+Y; X-Y写出计算的过程.

板式换热器换热量的计算

板式换热器例题 1、换热器换热量的计算 w t Gc Q 1046750)2065(41873600 20000=-??=?= 2、外网进入热水供应用户的水流量 s kg t c Q G /10) 7095(418710467500=-=?= 3、加热水的流通断面积 换热器内水的流速取0.1~0.5m/s 。加热水的平均温度为(95+70)/2=82.5℃,该温度下水的密度为970.2kg/m 3。 200206.02 .9705.010m w G f r r r =?==ρ 4、被加热水的流通断面积 换热器内水的流速取0.1~0.5m/s 。被加热水的平均温度为(65+20)/2=42.5℃,该温度下水的密度为991.2kg/m 3。 201868.02 .9913.0360020000m w G f l l l =??==ρ 5、选型 初选BR12型板式换热器,单片换热面积为0.12m 2/片,单通道流通断面积为0.72×10-3。 6、实际流速 加热水流道数为 2810 72.00206.03=?==-d r r f f n 被加热水流道数为 261072.001868.03=?== -d l l f f n 取流道数为28。 加热水实际流速 s m f n G w r d r r /5.02 .9701072.0281030=???==-ρ 被加热水实际流速 s m f n G w l d l l /28.02 .9911072.02856.53=???==-ρ 7、传热系数 查图知传热系数为3600w/m 2.K 。 8、传热温差

()()()()℃396595207065952070) ()() ()(112 21122=-----=-----=?In t t In t t t p ττττ 9、传热面积 246.739 36001046750m t K Q F p =?=?= 10、需要的片数 6212 .046.7===d F F N 11、实际片数 考虑一个富裕量。 62×1.25=78

计算机组成原理第三章运算方法与运算器(含答案)

第三章运算方法与运算器 3.1定点数运算及溢出检测随堂测验 1、定点运算器可直接进行的运算是() (单选) A、十进制数加法运算 B、定点数运算 C、浮点数运算 D、定点数和浮点数运算 2、设计计算机字长为8位,两个十进制数X = -97 ,Y = 63, [x]补- [y]补的结果为()(单选) A、01100000 B、11011110 C、负溢出 D、正溢出 3、下列关于定点运算溢出的描述中,正确的是( ) (多选) A、补码数据表时,同号数相加可能发生溢出 B、补码数据表时,异号数相减可能发生溢出 C、参加运算的两个数,当作为有符号数和无符号数进行加法运算时,不可能两者都溢出 D、溢出检测既可用硬件实现,也可用软件实现 4、设X为被加(减)数,Y为加(减)数,S为运算结果,均采用补码数据表示,下列关于溢出电路设计的描述中,正确的是()(多选) A、采用单符号位时,直接用X、Y和S的符号位就可设计溢出监测电路 B、采用双符号位时,可直接用S的双符号位设计溢出检测电路 C、采用单符号位时,可直接用X、Y最高有效数据位运算后的进位位和S的进位设计溢出监测电路 D、对无符号数的加/减运算,可利用运算器的进位信号设计溢出检测电路 3.2 定点数补码加、减运算器设计随堂测验 1、如图所示为基于FA的运算器:为了利用一位全加器FA并配合使用控制信号P,当P= 0/1时实现A、B两个数的加法/减法运算,图中空白方框处电路的逻辑功能应该是()(单选)

A、与门 B、或门 C、异或门 D、非门 2、如图所示为带溢出检测功能的运算器该电路完成的溢出检测功能是()(多选)

运算方法和运算器

第二章运算方法与运算器 2.1.1 数值数据在机内的表示 在选择计算机的数值数的表示方式时,需要考虑以下几个因素:(1)要表示的数的类型(小数、整数、实数和复数);(2)可能遇到的数值范围;(3)数值精确度;(4)数据存储和处理所需要的硬件代价。 2.1.1.1 定点数与浮点数 计算机处理的数值数据多数带有小数,小数点在计算机中通常有两种表示方法,一种是约定所有数值数据的小数点隐含在某一个固定位置上,称为定点表示法,简称定点数;另一种是小数点位置可以浮动,称为浮点表示法,简称浮点数。 1. 定点数表示法(fixed-point) 所谓定点格式,即约定机器中所有数据的小数点位置是固定不变的。在计算机中通常采用两种简单的约定:将小数点的位置固定在数据的最高位之前,或者是固定在最低位之后。一般常称前者为定点小数,后者为定点整数。 定点小数是纯小数,约定的小数点位置在符号位之后、有效数值部分最高位之前。 2. 浮点数表示法(floating-point number) 与科学计数法相似。 2.1.1.2 数的机器码表示 1. 原码表示法 原码表示法是一种比较直观的表示方法,其符号位表示该数的符号,正用“0”表示,负用“1”表示;而数值部分仍保留着其真值的特征。 2. 补码表示法 由于计算机的运算受一定字长的限制,属于有模运算,所以,在计算机中可以使用补码进行计算。在定点小数机器中数最大不超过1,也就是负的小数对“1”的补码是等价的。但实际上,负数的符号位还有一个“1”,要把它看成数的一部分,所以要对2求补码,也就是以2为模数。 3. 反码表示方法

反码表示法中,符号的表示法与原码相同。正数的反码与正数的原码形式相同;负数的反码符号位为1,数值部分通过将负数原码的数值部分各位取反(0变1,1变0)得到。 4. 移码表示法 移码通常用于表示浮点数的阶码。 2.1.2 非数值数据在机内的表示 计算机中数据的概念是广义的,机内除了有数值的信息之外,还有数字、字母、通用符号、控制符号等字符信息有逻辑信息、图形、图像、语音等信息,这些信息进入计算机都转变成0、1表示的编码,所以称为非数值数据。 2.1.2.1 字符的表示方法 字符主要指数字、字母、通用符号、控制符号等,在机内它们都被变换成计算机能够识别的十进制编码形式。这些字符编码方式有很多种,国际上广泛采用的是美国国家信息交换标准代码(American Standard Code for Information Interchange),简称ASCII 码。 2.1.2.2 汉字的表示方法 1. 汉字的输入码 目前,计算机一般是使用西文标准键盘输入的,为了能直接使用西文标准键盘输入汉字,必须给汉字设计相应的输入编码方法。其编码方案有很多种,主要的分为三类:数字编码、拼音码和字形编码。 2. 汉字的内码 3. 汉字字形码 2.2.1 补码加法运算 补码加法的公式是: [ x ]补+ [ y ]补= [ x + y ]补( mod 2 ) 含义是:两个数的补码之和等于两个数之和的补码。 2.2.2 补码减法运算 [x-y]补=[x]补-[y]补=[x]补+[-y]补( mod 2 )

板式换热器的换热计算方法Word版

板式换热器的计算方法 板式换热器的计算是一个比较复杂的过程,目前比较流行的方法是对数平均温差法和NTU法。在计算机没有普及的时候,各个厂家大多采用计算参数近似估算和流速-总传热系数曲线估算方法。目前,越来越多的厂家采用计算机计算,这样,板式换热器的工艺计算变得快捷、方便、准确。以下简要说明无相变时板式换热器的一般计算方法,该方法是以传热和压降准则关联式为基础的设计计算方法。 以下五个参数在板式换热器的选型计算中是必须的: ?总传热量(单位:kW). ?一次侧、二次侧的进出口温度 ?一次侧、二次侧的允许压力降 ?最高工作温度 ?最大工作压力 如果已知传热介质的流量,比热容以及进出口的温度差,总传热量即可计算得出。 温度 T1 = 热侧进口温度 T2 = 热侧出口温度 t1 = 冷侧进口温度 t2= 冷侧出口温度 热负荷 热流量衡算式反映两流体在换热过程中温度变化的相互关系,在换热器保温良好,无热损失的情况下,对于稳态传热过程,其热流量衡算关系为: (热流体放出的热流量)=(冷流体吸收的热流量)

在进行热衡算时,对有、无相变化的传热过程其表达式又有所区别。

(1)无相变化传热过程 式中 Q----冷流体吸收或热流体放出的热流量,W; m h,m c-----热、冷流体的质量流量,kg/s; C ph,C pc------热、冷流体的比定压热容,kJ/(kg·K); T1,t1 ------热、冷流体的进口温度,K; T2,t2------热、冷流体的出口温度,K。 (2)有相变化传热过程 两物流在换热过程中,其中一侧物流发生相变化,如蒸汽冷凝或液体沸腾,其热流量衡算式为: 一侧有相变化 两侧物流均发生相变化,如一侧冷凝另一侧沸腾的传热过程 式中 r,r1,r2--------物流相变热,J/kg; D,D1,D2--------相变物流量,kg/s。 对于过冷或过热物流发生相变时的热流量衡算,则应按以上方法分段进行加和计算。

运算方法和运算器练习题

运算方法和运算器练习题 一、填空题 1.补码加减法中,()作为数的一部分参加运算,()要丢掉。 2.为判断溢出,可采用双符号位补码,此时正数的符号用()表示,负数的符号用()表 示。 3.采用双符号位的方法进行溢出检测时,若运算结果中两个符号位(),则表明发生了溢 出。若结果的符号位为(),表示发生正溢出;若为(),表示发生负溢出。 4.采用单符号位进行溢出检测时,若加数与被加数符号相同,而运算结果的符号与操作数 的符号(),则表示溢出;当加数与被加数符号不同时,相加运算的结果()。 5.浮点加减运算在()情况下会发生溢出。 6.原码一位乘法中,符号位与数值位(),运算结果的符号位等于()。 7.一个浮点数,当其补码尾数右移一位时,为使其值不变,阶码应该()。 8.左规的规则为:尾数(),阶码()。 9.右规的规则是:尾数(),阶码()。 10.影响进位加法器速度的关键因素是(进位信号的传递问题)。 11.当运算结果的尾数部分不是()的形式时,则应进行规格化处理。当尾数符号位为() 或()时,需要右规;当运算结果的符号位和最高有效位为()或()时,需要左规。 12.(进位信号的产生与传递逻辑)称为进位链。 13.()称为进位产生函数,()称为进位传递函数。 14.ALU的基本逻辑结构是()加法器,它比行波进位加法器优越,具有先行进位逻辑,不 仅可以实现高速运算,还能完成逻辑运算。 二、选择题 1.两个补码数相加,采用1位符号位,当()时表示结果溢出。 A、符号位有进位 B、符号位进位和最高数位进位异或结果为0 C、符号位为1 D、符号位进位和最高数位进位异或结果为1 2.运算器的主要功能是进行() A、逻辑运算 B、算术运算 C、逻辑运算和算术运算 D、只作加法 3.运算器虽有许多部件组成,但核心部件是() A、数据总线 B、算术逻辑运算单元 C、多路开关 D、累加寄存器 4.在定点二进制运算中,减法运算一般通过()来实现。 A、原码运算的二进制减法器 B、补码运算的二进制减法器 C、补码运算的的十进制加法器 D、补码运算的的二进制加法器 5.在定点运算器中,无论采用双符号位还是单符号位,必须有(),它一般用()来实现。 A、译码电路,与非门 B、编码电路,或非门 C、溢出判断电路,异或门 D、移位电路,与或非门 6.ALU属于()部件。 A、运算器 B、控制器 C、存储器 D、寄存器 7.乘法器的硬件结构通常采用() A、串行加法器和串行移位器 B、并行加法器和串行左移 C、并行加法器和串行右移 D、串行加法器和串行右移 8.器件74SL181是4位的ALU芯片,使用它来构成一个16位的ALU,需要使用()片。 A、2 B、4 C、8 D、16

板式换热器选型与计算方法

板式换热器选型与计算方法 板式换热器的选型与计算方法 板式换热器的计算方法 板式换热器的计算是一个比较复杂的过程,目前比较流行的方法是对数平均温差法和NTU法。在计算机没有普及的时候,各个厂家大多采用计算参数近似估算和流速-总传热系数曲线估算方法。目前,越来越多的厂家采用计算机计算,这样,板式换热器的工艺计算变得快捷、方便、准确。以下简要说明无相变时板式换热器的一般计算方法,该方法是以传热和压降准则关联式为基础的设计计算方法。 以下五个参数在板式换热器的选型计算中是必须的: 总传热量(单位:kW). 一次侧、二次侧的进出口温度 一次侧、二次侧的允许压力降 最高工作温度 最大工作压力 如果已知传热介质的流量,比热容以及进出口的温度差,总传热量即可计算得出。 温度 T1 = 热侧进口温度 T2 = 热侧出口温度 t1 = 冷侧进口温度 t2= 冷侧出口温度 热负荷 热流量衡算式反映两流体在换热过程中温度变化的相互关系,在换热器保温良好,无热损失的情况下,对于稳态传热过程,其热流量衡算关系为: (热流体放出的热流量)=(冷流体吸收的热流量)

在进行热衡算时,对有、无相变化的传热过程其表达式又有所区别。 (1)无相变化传热过程 式中 Q----冷流体吸收或热流体放出的热流量,W; mh,mc-----热、冷流体的质量流量,kg/s; Cph,Cpc------热、冷流体的比定压热容,kJ/(kg·K); T1,t1 ------热、冷流体的进口温度,K; T2,t2------热、冷流体的出口温度,K。 (2)有相变化传热过程 两物流在换热过程中,其中一侧物流发生相变化,如蒸汽冷凝或液体沸腾,其热流量衡算式为: 一侧有相变化 两侧物流均发生相变化,如一侧冷凝另一侧沸腾的传热过程 式中 r,r1,r2--------物流相变热,J/kg; D,D1,D2--------相变物流量,kg/s。 对于过冷或过热物流发生相变时的热流量衡算,则应按以上方法分段进行加和计算。 对数平均温差(LMTD) 对数平均温差是换热器传热的动力,对数平均温差的大小直接关系到换热器传热难易程度.在某些特殊情况下无法计算对数平均温差,此时用算术平均温差代替对数平均温差,介质在逆流情况和在并流情况下的对数平均温差的计算方式是不同的。在一些特殊情况下,用算术平均温差代替对数平均温差。 逆流时: 并流时:

运算方法与运算器教案

第二章运算方法和运算器 学习重点 ●数据与文字的表示 ●定点加法、减法运算 ●定点运算器的组成 ●浮点运算的步骤 2.1 数据与文字的表示方法 2.1.1 数据格式 计算机中使用的数据可分成两大类: 数值数据:数字数据的表示 (定点、浮点) 符号数据:非数字符号的表示 (ASCII、汉字、图形等) 数值数据的表示格式有定点数、浮点数两种 1.定点数的表示方法 小数点的位置固定不变,通常表示成纯小数或纯整数。 用n+1位字表示定点数X, x= x n x n-1x n-2 (x1x0) 纯小数时表示范围: 0≤|X|≤1-2-n 纯整数时表示范围: 0≤|X|≤2n-1 2.浮点数的表示方法 任意进制数N表示:N=R e·M M为尾数,数的精度; e为指数(整数),数的范围; R为基数,二进制为2,十进制为10; 浮点数由阶码、尾数及其符号位组成。 规格化:若不对浮点数的表示作出明确规定,同一个浮点数的表示就不是惟一的。例如: 0.01010010×211 0.001010010×2100 0.1010010×210 IEEE754标准 (规定了浮点数的表示格式,运算规则等) 规则规定了32位和64位两种基本格式 规则中,尾数用原码,指数用移码(便于对阶和比较),基数为2 尾数域的最高有效位为1,称为浮点数的规格化表示。 32位的浮点数 S数的符号位,1位,在最高位,“0”表示正数,“1”表示负数。 E是阶码,8位,采用移码表示。移码比较大小方便。 M是尾数,23位,在低位部分,采用纯小数表示。 规格化的浮点数尾数域最左位(最高有效位)总是1,故这一位经常不予存储,而认为隐藏在小数点的左边(1.M) 。 采用这种方式时,将浮点数的指数真值e变成阶码E时,应将指数e加上一个固定的偏移值127(01111111),即E=e+127。

换热器及其基本计算

姓名:杜鑫鑫学号:0903032038 合肥学院 材 料 工 程 基 础 姓名: 班级:09无机非二班 学号:\ 课题名称:换热器及其基本计算 指导教师:胡坤宏

换热器及其基本计算 一、换热器基础知识 (1)换热器的定义: 换热器是指在两种温度不同的流体中进行换热的设备。 (2)换热器的分类: 由于应用场合不同,工程上应用的换热器种类很多,这些换热器照工作原理、结构和流体流程分类。 二、几个不同的换热器 (1)管壳式换热器 管壳式换热器又称列管式换热器,是一种通用的标准换热设备。它具有结构简单、坚固耐用、造价低廉、用材广泛、清洗方便、适应性强等优点,应用最为广泛,在换热设备中占据主导地位。 管壳式换热器是把换热管束与管板连接后,再用筒体与管箱包起来,形成两个独立的空间。管内的通道及与其相贯通的管箱称为管程;管外的通道及与其相贯通的部分称为壳程。一种流体在管内流动,而另一种流体在壳与管束之间从管外表面流过,为了保证壳程流体能够横向流过管束,以形成较高的传热速率,在外壳上装有许多挡板。 而壳管式换热器又可根据不同分为U形管式换热器、固定管板换热器、浮头式换热器、填料函式换热器几类。 (2) 套管式换热器 套管式换热器是用两种尺寸不同的标准管连接而成同心圆套管,外面的叫壳程,内部的叫管程。两种不同介质可在壳程和管程内逆向流动(或同向)以达到换热的效果。 套管式换热器以同心套管中的内管作为传热元件的换热器。两种不同直径的管子套在一起组成同心套管,每一段套管称为“一程”,程的内管(传热管)借U形肘管,而外管用短管依次连接成排,固定于支架上。热量通过内管管壁由一种流体传递给另一种流体。通常,热流体由上部引入,而冷流体则由下部引入。套管中外管的两端与内管用焊接或法兰连接。内管与U形肘管多用法兰连接,便于传热管的清洗和增减。每程传热管的有效长度取4~7米。这种换热器传热面积最高达18平方米,故适用于小容量换热。当内外管壁温差较大时,可在外管设置U形膨胀节或内外管间采用填料函滑动密封,以减小温差应力。管子可用钢、铸铁、陶瓷和玻璃等制成,若选材得当,它可用于腐蚀性介质的换热。这种换热器具有若干突出的优点,所以至今仍被广泛用于石油化工等工业部门。

计算机组成原理习题 第二章运算方法和运算器

第二章习题 一、填空题: 1.一个定点数由A.______和B.______两部分组成,根据小数点位置不同,定点数有 C.______和 D.______两种表示方法。 2.数的真值变成机器码可采用A. ______表示法,B. ______表示法,C.______表示法,移码表示法。 3.若[ x1 ]补 = 11001100, [x2 ]原 = 1.0110 ,则数x1和x2的十进制数真值分别是 A.______和 B.______。 4.移码表示法主要用于表示浮点数的A.______码,以利于比较两个B.______数的大小和进行C.______操作。 5.按IEEE754标准,一个浮点数由A.___, 阶码E, 尾数M三个域组成。其中阶码E 的值等于指数的B.___, 加上一个固定C.___。 6.若浮点数格式中阶码的基数已定,且尾数采用规格化表示法,则浮点数的表示范围取决于A. 的位数,而精度取决于B. 的位数。 二、选择题: 1.(2000)10化成十六进制数是______。 A.(7CD)16 B.(7D0)16 C.(7E0)16 D.(7FO)16 2.在小型或微型计算机里,普遍采用的字符编码是______。 A. BCD码 B. 16进制 C. 格雷码 D. ASCⅡ码 3.下列有关运算器的描述中,______是正确的。 A.只做算术运算,不做逻辑运算 B. 只做加法 C.能暂时存放运算结果 D. 既做算术运算,又做逻辑运算 4.某机字长32位。其中1位符号位,31位表示尾数。若用定点整数表示,则最大正 整数为______。 A. +(231-1) B. +(230-1) C. +(231+1) D. +(230+1) 5.至今为止,计算机中的所有信息仍以二进制方式表示的理由是______。 A.节约元件 B. 运算速度快 C. 物理器件性能决定 D. 信息处理方便 6.某机字长32位,其中1位符号位,31位表示尾数。若用定点整数表示,则最小负 整数为______。 A. -(231-1) B. -(230-1) C. -(231+1) D. -(230+1) 7.x=+0.1011, y=+0.0110,则用补码运算[x-y]补=______。 A. 0.0101 B. 0.0001 C. 1.1011 D. 1.1111 8.在定点二进制运算器中,减法运算一般通过______来实现。 A. 原码运算的二进制减法器 B. 补码运算的二进制减法器 C. 补码运算的十进制加发器 D. 补码运算的二进制加法器 9.某机字长32位。其中1位符号位,31位表示尾数。若用定点小数表示,则最大正 小数为______。 A. +(1-2-32) B. +(1-2-31) C. +(1-2-30) D.2-31-1 10.运算器的核心部分是______。 A. 数据总线 B. 多路开关 C. 算术逻辑运算单元 D. 累加寄存器

简单计算板式换热器板片面积

选用板式换热器就是要选择板片的面积的简单方法: Q=K×F×Δt, Q——热负荷 K——传热系数 F——换热面积 Δt——传热温差(一般用对数温差) 传热系数取决于换热器自身的结构,每个不同流道的板片,都有自身的经验公式,如果不严格的话,可以取2000~3000。最后算出的板换的面积要乘以一定的系数如1.2。 艾瑞德板式换热器(江阴)有限公司作为专业的可拆式板式换热器生产商和制造商,专注于可拆式板式换热器的研发与生产。ARD艾瑞德专业生产可拆式板式换热器(PHE)、换热器密封垫(PHEGASKET)、换热器板片(PHEPLATE)并提供板式换热器维护服务(PHEMAINTENANCE)的专业换热器厂家。

ARD艾瑞德拥有卓越的设计和生产技术以及全面的换热器专业知识,一直以来ARD致力于为全球50多个国家和地区的石油、化工、工业、食品饮料、电力、冶金、造船业、暖通空调等行业的客户提供高品质的板式换热器,良好地运行于各行业,ARD已发展成为可拆式板式换热器领域卓越的厂家。 ARD艾瑞德同时也是板式换热器配件(换热器板片和换热器密封垫)领域专业的供应商和维护商。能够提供世界知名品牌(包括:阿法拉伐/AlfaLaval、斯必克/SPX、安培威/APV、基伊埃/GEA、传特/TRANTER、舒瑞普/SWEP、桑德斯/SONDEX、艾普尔.斯密特/API.Schmidt、风凯/FUNKE、萨莫威孚/Thermowave、维卡勃Vicarb、东和恩泰/DONGHWA、艾克森ACCESSEN、MULLER、FISCHER、REHEAT等)的所有型号将近2000种的板式换热器板片和垫片,ARD艾瑞德实现了与各品牌板式换热器配件的完全替代。全球几十个国家的板式换热器客户正在使用ARD 提供的换热器配件或接受ARD的维护服务(包括定期清洗、维修及更换配件等维护服务)。 无论您身在何处,无论您有什么特殊要求,ARD都能为您提供板式换热器领域的系统解决方案。

板式换热器选型计算

板式换热器选型计算 板式换热器是一种高效紧凑型热交换设备,它具有传热效率高、阻力损失小、结构紧凑、拆装方便、操作灵活等优点,目前广泛应用于冶金、机械、电力、石油、化工、制药、纺织、造纸、食品、城镇小区集中供热等各个行业和领域,因此掌握板式换热器的选型计算对每个工程设计人员都是非常重要的。目前板式换热器的选型计算一般分为手工简易算法、手工标准算法及计算机算法三种,以下就三种算法的特点进行简要的说明。 一、手工简易算法 计算公式: F=Wq/(K*△T) 式中 F —换热面积 m2 Wq—换热量 W K —传热系数 W/m2·℃ △T—平均对数温差℃ 根据选定换热系统的有关参数,计算换热量、平均对数温差,设定传热系数,求出换热面积。选定厂家及换热器型号,计算板间流速,通过厂家样本提供的传热特性曲线及流阻特性曲线,查出实际传热系数及压降。若实际传热系数小于设定传热系数,则应降低设定传热系数,重新计算。若实际传热系数大于设定传热系数,而实际压降大于设定压降,则应进一步降低设定传热系数,增大换热面积,重新计算。经过反复校核,直到计算结果满足换热系统的要求,最终确定换热器型号及换热面积大小。这种算法的优点是计算简单,步骤少,时间短;缺点是结果不准确,应用范围窄。造成结果不准确的原因主要是样本所提供的传热特性曲线及流阻特性曲线是一定工况条件下的曲线,而设计工况可能与之不符。此外样本所提供的传热特性曲线及流阻特性曲线仅为水―水换热系统,在使用中有很大的局限性。 以下给出佛山显像管厂总装厂房低温冷却水及40℃热水两套换热系统实例加以说明采用手工简易算法得出的计算结果与实测结果的差别:

板式换热器计算公式

板式换热器计算公式 板式换热器是由一系列具有一定波纹形状的金属片叠装而成的一种新式高效换热器。对于各个厂家和运用商来说,板式换热器选型计算方法及公式都是比照首要的,由于选好换热器对于出产和车间的作业是很关键的。 板片型式或波纹式应根据换热场合的实际需要而定。对流量大答应压降小的情况,应选用阻力小的板型,反之选用阻力大的板型。根据流体压力和温度的情况,判定选择可拆卸式,仍是钎焊式。判定板型时不宜选择单板面积太小的板片,避免板片数量过多,板间流速偏小,传热系数过低,对较大的换热器更应留心这个疑问。 流程和流道的选择 流程指板式换热器内一种介质同一活动方向的一组并联流道,而流道指板式换热器内,相邻两板片构成的介质活动通道。一般情况下,将若干个流道按并联或串联的方法连接起来,以构成冷、热介质通道的不一样组合。 流程组合方式应根据换热和流体阻力计算,在满足技能条件恳求下判定。尽量使冷、热水流道内的对流换热系数相等或靠近,然后得到最佳的传热作用。由于在传热表面两边对流换热系数相等或靠近时传热系数获得较大值。虽然板式换热器各板间流速不等,但在换热和流体

阻力计算时,仍以均匀流速进行计算。由于“U”形单流程的接纳都固定在压紧板上,拆装便当。 计算方法及公式 (1) 求热负荷QQ=G.ρ.CP.Δt (2) 求冷热流体进出口温度t2=t1+ Q /G .ρ .CP (3) 冷热流体流量G= Q / ρ .CP .(t2-t1 (4) 求均匀温度差ΔtmΔtm=(T1-t2)-(T2-t1)/In(T1-t2)/(T2-t1)或 Δtm=(T1-t2)+(T2-t1)/2 (5) 选择板型若一切的板型选择完,则进行效果剖析。 (6) 由K值规划,计算板片数规划Nmin,NmaxNmin = Q / Kmax .Δtm .F P .βNmax = Q / Kmin .Δtm .F P .β

板式换热器选型计算的方法及公式

(1)求热负荷Q Q=G.ρ.CP.Δt (2)求冷热流体进出口温度 t2=t1+ Q /G .ρ .CP (3)冷热流体流量 G= Q / ρ .CP .(t2-t1 (4)求平均温度差Δtm Δtm=(T1-t2)-(T2-t1)/In(T1-t2)/(T2-t1)或Δtm=(T1-t2)+(T2-t1)/2 (5)选择板型 若所有的板型选择完,则进行结果分析。 (6)由K值范围,计算板片数范围Nmin,Nmax Nmin = Q/ Kmax .Δtm .F P .β Nmax = Q/ Kmin .Δtm .F P .β (7)取板片数N(Nmin≤N≤Nmax ) 若N已达Nmax,做(5)。 (8)取N的流程组合形式,若组合形式取完则做(7)。 (9)求Re,Nu Re = W .de / ν Nu =a1.Re a2.Pr a3 (10)求a,K传热面积F a = Nu .λ / de K= 1 / 1/a h+1/ a c+γc+γc+δ/λ0

F = Q /K .Δtm .β (11)由传热面积F求所需板片数NN NN= F/ Fp + 2 (12)若N <NN ,做(8)。 (13)求压降Δp Eu = a 4.Re a 5 Δp = Eu .ρ.W 2 .ф (14) 若Δp >Δ允 ,做(8); 若Δp ≤Δ允 ,记录结果 ,做(8)。 注: 1.(1)、(2)、(3)根据已知条件的情况进行计算。 2.当T 1 -t 2=T 2-t 1时采用Δtm = (T 1-t2)+(T2-t1)/2 3.修正系数β一般0.7~0.9。 4.压降修正系数ф ,单流程ф度=1~1.2 ,二流程、三流程ф=1.8~2.0,四流程ф=2.6~2.8。 5.a 1、a2、a3、a4、a5为常系数。

板式换热器选型计算的方法及公式

板式换热器选型计算的方法及公式 (1)求热负荷Q Q=G .ρ.CP .Δt (2)求冷热流体进出口温度 t 2=t 1+Q/G .ρ.CP (3)冷热流体流量 G=Q/ρ.CP .(t2-t1 (4)求平均温度差Δtm Δtm=(T1-t2)-(T2-t1)/In(T1-t2)/(T2-t1)或Δtm=(T 1-t2)+(T2-t1)/2 (5)选择板型 若所有的板型选择完,则进行结果分析。 (6)由K值范围,计算板片数范围Nmin ,Nmax Nmin=Q/Kmax .Δtm.FP .β Nmax=Q/Kmin .Δtm.FP .β (7)取板片数N (Nmin ≤N≤Nmax ) 若N 已达Nmax ,做(5)。 (8)取N 的流程组合形式,若组合形式取完则做(7)。 (9)求Re ,Nu Re=W .de/ν Nu=a 1.Re a 2.Pr a 3 (10)求a ,K 传热面积F a=Nu .λ/de K=1/1/a h+1/a c+γc+γc+δ/λ0 F=Q/K .Δtm.β

艾瑞德板式换热器(江阴)有限公司作为专业的可拆式板式换热器生产商和制造商,专注于可拆式板式换热器的研发与生产。ARD 艾瑞德专业生产可拆式板式换热器(PHE )、换热器密封垫(PHEGASKET )、换热器板片(PHEPLATE)并提供板式换热器维护服务(PHEMAINTENANCE )的专业换热器厂家。 ARD 艾瑞德拥有卓越的设计和生产技术以及全面的换热器专业知识,一直以来ARD 致力于为全球50多个国家和地区的石油、化工、工业、食品饮料、电力、冶金、造船业、暖通空调等行业的客户提供高品质的板式换热器,良好地运行于各行业,ARD 已发展成为可拆式板式换热器领域卓越的厂家。 ARD 艾瑞德同时也是板式换热器配件(换热器板片和换热器密封垫)领域专业的供应商和维护商。能够提供世界知名品牌(包括:阿法拉伐/AlfaLaval 、斯必克/SPX 、安培威/APV 、基伊埃/GEA 、传特/TRANTER 、舒瑞普/SWEP 、桑德斯/SONDEX 、艾普尔.斯密特/API.Schmidt 、风凯/FUNKE 、萨莫威孚/Thermowave 、维卡勃Vicarb 、东和恩泰/DONGHWA 、艾克森ACCESSEN 、MULLER 、FISCHER 、REHEAT 等)的所有型号将近2000种的板式换热器板片和垫片,ARD 艾瑞德实现了与各品牌板式换热器配件的完全替代。全球几十个国家的板式换热器客户正在使用ARD 提供的换热器配件或接受ARD 的维护服务(包括定期清洗、维修及更换配件等维护服务)。 无论您身在何处,无论您有什么特殊要求,ARD 都能为您提供板式换热器领域的系统解决方案。 (11)由传热面积F求所需板片数NN NN=F/Fp+2 (12)若N <NN ,做(8)。 (13)求压降Δp Eu=a 4.Re a 5 Δp=Eu .ρ.W 2 .ф (14)若Δp >Δ允 ,做(8); 若Δp ≤Δ允 ,记录结果,做(8)。

板式换热器选型计算(DOC)

板式换热器选型计算

(四)计算换热量 Wq=Qh*γh*Cph*(Th1-Th2)=Qc*γc*Cpc*(Tc2-Tc1) W (五)设备选型 根据样本提供的型号结合流量定型号,主要依据于角孔流速。即:Wl=4*Q/(3600*π*D2) ≤3.5~4.5m/s Wl—角孔流速m/s Q —介质流量m3/h D —角孔直径m (六)定型设备参数(样本提供) 单板换热面积s m2 单通道横截面积 f m2 板片间距l m 平均当量直径de m (d≈2*l) 传热准则方程式Nu=a*Re b*Pr m 压降准则方程式Eu=x*Re y Nu—努塞尔数Eu—欧拉数 a.b.x.y—板形有关参数、指数 Re—雷诺数 Pr—普朗特数 m —指数热介质m=0.3 冷介质m=0.4 (七)拟定板间流速初值Wh 或Wc Wc=Wh*Qc/Qh (纯逆流时) W取0.1~0.4m/s (八)计算雷诺数 Re=W*de/ν W —计算流速m/s de—当量直径m ν—运动粘度m2/s (九)计算努塞尔数 Nu=a*Re b*Pr m

(十)计算放热系数 α=Nu*λ/de α—放热系数W/m2·℃ λ—导热系数W/m·℃ 分别得出αh、αc热冷介质放热系数(十一)计算传热系数 K=1/(1/αh+1/αc+r p+r h+r c) W/m2·℃ r p—板片热阻0.0000459m2·℃/W r h—热介质污垢热阻0.0000172~0.0000258m2·℃/W r c—冷介质污垢热阻0.0000258~0.0000602m2·℃/W (十二)计算理论换热面积 Fm=Wq/(K*△T) (十三)计算换热器单组程流道数 n=Q/(3600*f*W) (圆整为整数) Q—流量m3/h f—单通道横截面积m2 W—板间流速m/s (十四)计算换热器程数 N=(Fm/s+1)/(2*n)N为≥1的整数s—单板换热面积m2 (十五)计算实际换热面积 F=(2*N*n-1)*s (纯逆流) (十六)计算欧拉数 Eu=x*Re y (十七)计算压力损失 △P=Eu*γ*W2*N*10-6 MPa γ—介质重度Kg/m3 W—板间流速m/s N—换热器程数

板式换热器工艺计算

4.3.9 换热器设计举例 对一段预热器进行换热器设计。甲苯废气经过换热器加热后进入二段预热器,此热量交换介质为水蒸气,冷物流走管程,热物流出料走壳程,逆流传热。 (1)计算热负荷 根据物料衡算得出进入甲苯废气流量为719842.816kg/h ,混合比热容为1.021KJ/kg/℃,计算公式如下 )(W Q 21T T C ph h -= 带入数据得 719842.816 1.021(13040)66146356.36 /Q KJ h =??-= (2)计算两流体的平均温差 ℃99.73ln 1 21 2=???-?= ?t t t t t m 而5625.04020040130t 1112=--=--= t T t P ,667.040 130140 2001221=--=--=t t T T R 经查表查得: 95.0=?t ?,所以℃29.7099.7395.0=?=?=??m t m t T ? 初选换热器规格。根据两流体情况,假设)( ℃./W 1200K 2m = 2Q 66146356.361000 S 217.84K 120070.293600 m m T ?= ==??? 20S 1.2261.4S m =?= 4.3.10初选换热器规格 (1)管径与流速 选取管热管规格: 表4.5 换热管规格一览表 材料 钢管标准 外径×厚度(mm×mm ) 外径偏差/mm 壁厚偏差 碳钢 GB8163 25×2.5 ±0.20 +12%,-10% 取管内流速为u=2m/s

(2)管程数和传热管数 以单管程传热管数计算: u d q n i v 24 π= 式中:qv ——管程体积流量,由物料衡算计算结果知719842.816kg/h,换算为562.93m3/h; n ——单程传热管数目; di ——传热管内径,mm ; u ——管内流体流速,m/s 。 带入已知数据计算得: 根24999.2482 02.0785.03600 /93.5622 ≈=??= n 传热管所需长度计算: s n d S L 0π= 式中:L ——按单程管计算得传热管长度; S ——传热面积; d 0——传热管外径,mm ; 带入数据得: m L 14.11249 025.014.3217.83 =??= 由计算结果知,单程的传热管过长,则需采用多管程,管程数计算如下: l L N p = 式中:l ——取单程管长度,本设计取6000mm; Np ——管程数;

板式换热器计算

板式换热器计算: 由公式Q=K?F?△tm得出, F=Q/K.Δtm Q——热流量(W) △tm——对数平均温差(℃) F——传热面积(m*m) 板片型式或波纹式应根据换热场合的实际需要而定。对流量大允许压降小的情况,应选用阻力小的板型,反之选用阻力大的板型。 根据流体压力和温度的情况,确定选择可拆卸式,还是钎焊式。确定板型时不宜选择单板面积太小的板片,以免板片数量过多,板间流速偏小,传热系数过低,对较大的换热器更应注意这个问题。 计算方法及公式 (1)求热负荷Q Q=G.ρ.CP.Δt (2)求冷热流体进出口温度 t2=t1+Q/G.ρ.CP (3)冷热流体流量 G=Q/ρ.CP.(t2-t1) (4)求平均温度差Δtm Δtm=(T1-t2)-(T2-t1)/In(T1-t2)/(T2-t1)或Δtm=(T1-t2)+(T2-t1)/2 (5)选择板型

若所有的板型选择完,则进行结果分析。 (6)由K值范围,计算板片数范围Nmin,Nmax Nmin=Q/Kmax.Δtm.F P.β Nmax=Q/Kmin.Δtm.F P.β 关于传热系数和压降的计算,由各个厂家产品的性能曲线计算得到。性能曲线(准则关联式)一般来自于产品的性能测试。对于缺少性能测试的板型,也可通过参考尺寸法,根据板型的特性几何尺寸获得板型的准则关联式,国际上的一些通用软件均采用这种方法。 原理: 可拆卸板式换热器是由许多冲压有波纹薄板按一定间隔,四周通过垫片密封,并用框架和压紧螺旋重叠压紧而成,板片和垫片的四个角孔形成了流体的分配管和汇集管,同时又合理地将冷热流体分开,使其分别在每块板片两侧的流道中流动,通过板片进行热交换。 板式换热器的优化设计计算,就是在已知温差比NTUE的条件下,合理地确定其型号、流程和传热面积,使NTUp等于NTUE。 板式换热器已广泛应用于冶金、矿山、石油、化工、电力、医药、食品、化纤、造纸、轻纺、船舶、供热等部门,可用于加热、冷却、蒸发、冷凝、杀菌消毒、余热回收等各种情况。 太阳能利用:参与太阳能集热板中传热介质乙二醇等防冻液热量交换过程,以达到利用太阳能目的。 化学工业:制造氧化钛、酒精发酵、合成氨、树脂合成、制造橡胶、冷却磷酸、冷却甲醛水、碱炭工业、电解制碱。

相关主题