单周期单精度加法器

最新推荐文章于 2022-10-20 20:54:01 发布
最新推荐文章于 2022-10-20 20:54:01 发布
阅读量312 收藏 1
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43294951/article/details/119732853
版权

verilog

test_add.v

module test_add    //不同符号的浮点数据相加
(
	input wire MAIN_CLK,    
	input wire [31:0] a,
	input wire [31:0] b,
	
	output wire [31:0] ab
);
 
reg [7:0] pow_a;
reg [7:0] pow_b;
reg [22:0] val_a;
reg [22:0] val_b;
reg flag_a;
reg flag_b;
reg flag;

//比较指数大小提取指数差值
reg [24:0] val_max;
reg [24:0] val_min; 
reg [7:0] pow_diff;
reg [7:0] pow_ab1;
reg flag1;

//计数输出时的数值部分
reg [7:0] pow_ab2;
reg [24:0] val_ab1;
reg flag2;

//对最后的输出指数部分和数据部分进行校准
reg [8:0] pow_ab3;
reg [23:0] val_ab2;
reg flag3;


always @(* )
begin

	flag_a = a[31];   //提取符号
	flag_b= b[31];
	flag = flag_a^flag_b;
	pow_a = a[30:23];
	pow_b = b[30:23];
	val_a = a[22:0];
	val_b = b[22:0];
	if (flag ) begin 
		if(pow_a > pow_b)    
		begin
			flag1 = flag_a;  //输出符号随a
			pow_ab1 = pow_a;
			pow_diff = pow_a - pow_b;
			val_max = {2'b01,val_a};
			val_min = {2'b01,val_b};
		end
	else if(pow_a < pow_b) 
		begin
			flag1 = flag_b;  //输出符号随b
			pow_ab1 = pow_b;
			pow_diff = pow_b - pow_a;
			val_max = {2'b01,val_b};
			val_min = {2'b01,val_a};
		end
	else
		begin
			pow_ab1 = pow_a;
			pow_diff = 0;
			if(val_a > val_b)
				begin
					flag1 = flag_a;  //输出符号随a
					val_max = {2'b01,val_a};
					val_min = {2'b01,val_b};
				end
			else //if(val_a < val_b)
				begin
					flag1 = flag_b;  //输出符号随b
					val_max = {2'b01,val_b};
					val_min = {2'b01,val_a};
				end 
		end 
	end
	
	else begin
		flag1 = flag_a;
	if(pow_a > pow_b)    
		begin
			pow_ab1 = pow_a;
			pow_diff = pow_a - pow_b;
			val_max = {2'b01,val_a};
			val_min = {2'b01,val_b};
		end
	else 
		begin
			pow_ab1 = pow_b;
			pow_diff = pow_b - pow_a;
			val_max = {2'b01,val_b};
			val_min = {2'b01,val_a};
		end
	
	end
	
		flag2 = flag1;
	pow_ab2 = pow_ab1;
	if (flag) begin
	case(pow_diff)
		0: begin val_ab1 = val_max - val_min; end
		1: begin val_ab1 = val_max - {1'b0,val_min[24:1]}; end
		2: begin val_ab1 = val_max - {2'b0,val_min[24:2]}; end
		3: begin val_ab1 = val_max - {3'b0,val_min[24:3]}; end
		4: begin val_ab1 = val_max - {4'b0,val_min[24:4]}; end
		5: begin val_ab1 = val_max - {5'b0,val_min[24:5]}; end
		6: begin val_ab1 = val_max - {6'b0,val_min[24:6]}; end
		7: begin val_ab1 = val_max - {7'b0,val_min[24:7]}; end
		8: begin val_ab1 = val_max - {8'b0,val_min[24:8]}; end
		9: begin val_ab1 = val_max - {9'b0,val_min[24:9]}; end
		10: begin val_ab1 = val_max - {10'b0,val_min[24:10]}; end
		11: begin val_ab1 = val_max - {11'b0,val_min[24:11]}; end
		12: begin val_ab1 = val_max - {12'b0,val_min[24:12]}; end
		13: begin val_ab1 = val_max - {13'b0,val_min[24:13]}; end
		14: begin val_ab1 = val_max - {14'b0,val_min[24:14]}; end
//		15: begin val_ab1 <= val_max - {15'b0,val_min[24:15]}; end
//		16: begin val_ab1 <= val_max - {16'b0,val_min[24:16]}; end
//		17: begin val_ab1 <= val_max - {17'b0,val_min[24:17]}; end
//		18: begin val_ab1 <= val_max - {18'b0,val_min[24:18]}; end
//		19: begin val_ab1 <= val_max - {19'b0,val_min[24:19]}; end
//		20: begin val_ab1 <= val_max - {20'b0,val_min[24:20]}; end
//		21: begin val_ab1 <= val_max - {21'b0,val_min[24:21]}; end
//		22: begin val_ab1 <= val_max - {22'b0,val_min[24:22]}; end
//		23: begin val_ab1 <= val_max - {23'b0,val_min[24:23]}; end
		default: begin val_ab1 = val_max; end
	endcase 
	end
	else begin
	case(pow_diff)
		0: begin val_ab1 = val_max + val_min; end
		1: begin val_ab1 = val_max + {1'b0,val_min[24:1]}; end
		2: begin val_ab1 = val_max + {2'b0,val_min[24:2]}; end
		3: begin val_ab1 = val_max + {3'b0,val_min[24:3]}; end
		4: begin val_ab1 = val_max + {4'b0,val_min[24:4]}; end
		5: begin val_ab1 = val_max + {5'b0,val_min[24:5]}; end
		6: begin val_ab1 = val_max + {6'b0,val_min[24:6]}; end
		7: begin val_ab1 = val_max + {7'b0,val_min[24:7]}; end
		8: begin val_ab1 = val_max + {8'b0,val_min[24:8]}; end
		9: begin val_ab1 = val_max + {9'b0,val_min[24:9]}; end
		10: begin val_ab1 = val_max + {10'b0,val_min[24:10]}; end
		11: begin val_ab1 = val_max + {11'b0,val_min[24:11]}; end
		12: begin val_ab1 = val_max + {12'b0,val_min[24:12]}; end
		13: begin val_ab1 = val_max + {13'b0,val_min[24:13]}; end
		14: begin val_ab1 = val_max + {14'b0,val_min[24:14]}; end
//		15: begin val_ab1 <= val_max + {15'b0,val_min[24:15]}; end
//		16: begin val_ab1 <= val_max + {16'b0,val_min[24:16]}; end
//		17: begin val_ab1 <= val_max + {17'b0,val_min[24:17]}; end
//		18: begin val_ab1 <= val_max + {18'b0,val_min[24:18]}; end
//		19: begin val_ab1 <= val_max + {19'b0,val_min[24:19]}; end
//		20: begin val_ab1 <= val_max + {20'b0,val_min[24:20]}; end
//		21: begin val_ab1 <= val_max + {21'b0,val_min[24:21]}; end
//		22: begin val_ab1 <= val_max + {22'b0,val_min[24:22]}; end
//		23: begin val_ab1 <= val_max + {23'b0,val_min[24:23]}; end
		default: begin val_ab1 = val_max; end
	endcase 
	end
	
	if (flag) begin 
	flag3 = flag2;
	if(val_ab1[23] == 1)   //说明减法过程中数据没有借位
		begin
			pow_ab3 = pow_ab2;
			val_ab2 = val_ab1[23:0]; //得到最后输出的小数部分
		end
	else if(val_ab1[22] == 1)
		begin
			pow_ab3 = pow_ab2 - 1;
			val_ab2 = {val_ab1[22:0],1'b0}; //得到最后输出的小数部分			
		end
	else if(val_ab1[21] == 1)
		begin
			pow_ab3 = pow_ab2 - 2;
			val_ab2 = {val_ab1[21:0],2'b0}; //得到最后输出的小数部分			
		end
	else if(val_ab1[20] == 1)
		begin
			pow_ab3 = pow_ab2 - 3;
			val_ab2 = {val_ab1[20:0],3'b0}; //得到最后输出的小数部分			
		end
	else if(val_ab1[19] == 1)
		begin
			pow_ab3 = pow_ab2 - 4;
			val_ab2 = {val_ab1[19:0],4'b0}; //得到最后输出的小数部分			
		end
	else if(val_ab1[18] == 1)
		begin
			pow_ab3 = pow_ab2 - 5;
			val_ab2 = {val_ab1[18:0],5'b0}; //得到最后输出的小数部分			
		end
	else if(val_ab1[17] == 1)
		begin
			pow_ab3 = pow_ab2 - 6;
			val_ab2 = {val_ab1[17:0],6'b0}; //得到最后输出的小数部分			
		end
	else if(val_ab1[16] == 1)
		begin
			pow_ab3 = pow_ab2 - 7;
			val_ab2 = {val_ab1[16:0],7'b0}; //得到最后输出的小数部分			
		end
	else if(val_ab1[15] == 1)
		begin
			pow_ab3 = pow_ab2 - 8;
			val_ab2 = {val_ab1[15:0],8'b0}; //得到最后输出的小数部分			
		end
	else if(val_ab1[14] == 1)
		begin
			pow_ab3 = pow_ab2 - 9;
			val_ab2 = {val_ab1[14:0],9'b0}; //得到最后输出的小数部分			
		end
	else if(val_ab1[13] == 1)
		begin
			pow_ab3 = pow_ab2 - 10;
			val_ab2 = {val_ab1[13:0],10'b0}; //得到最后输出的小数部分			
		end
	else if(val_ab1[12] == 1)
		begin
			pow_ab3 = pow_ab2 - 11;
			val_ab2 = {val_ab1[12:0],11'b0}; //得到最后输出的小数部分			
		end
	else if(val_ab1[11] == 1)
		begin
			pow_ab3 = pow_ab2 - 12;
			val_ab2 = {val_ab1[11:0],12'b0}; //得到最后输出的小数部分			
		end
	else if(val_ab1[10] == 1)
		begin
			pow_ab3 = pow_ab2 - 13;
			val_ab2 = {val_ab1[10:0],13'b0}; //得到最后输出的小数部分			
		end		
	else
		begin
			pow_ab3 = 0;
			val_ab2 = 0;  
		end 
	end
	
	else begin
	flag3 = flag2;
	if(val_ab1[24] == 1)   //说明加法过程中数据有溢出
		begin
			pow_ab3 = pow_ab2 + 1;
			val_ab2 = val_ab1[24:1]; //得到最后输出的小数部分
		end
	else
		begin
			pow_ab3 = pow_ab2;
			val_ab2 = val_ab1[23:0]; //得到最后输出的小数部分
		end 
	end
	

end

//对输出进行打包 
assign ab = flag ?(pow_ab3[8]==1)?{32'h0}:{flag3,pow_ab3[7:0],val_ab2[22:0]} : {flag3,pow_ab3[7:0],val_ab2[22:0]};
 
endmodule

add_tb.v

`timescale 1ns/1ps

module add_tb;
	reg clk;
	initial clk = 0;
	always #5 clk=~clk;
	
	reg [31:0] rnd1mem [0:999];
	reg [31:0] rnd2mem [0:999];
	reg [10:0] addr;
	wire [31:0] data_o;
	wire [31:0] a,b;
	//mul m1(clk,rnd1mem[addr],data);
	reg [3:0] clk_10;
	reg flag;

	
	initial begin
       $readmemh("rnd1hex.txt",rnd1mem);
		 $readmemh("rnd2hex.txt",rnd2mem);
       addr = 0;
		 clk_10 = 0;
		 flag = 0;
	end
	integer file1;
	initial begin
	file1 = $fopen("add_result.txt","w");
	end
	always @(posedge clk ) begin
		$fwrite(file1,"%h\n",data_o);
		if (addr >= 999) begin
		$fclose(file1);
		$stop;
		end
		else  begin addr = addr + 1;
		
		end
	end
	
	initial
        begin            
            $dumpfile("add_tb.vcd");
            $dumpvars(0,add_tb);
        end


	/*always @(posedge clk) begin
		clk_10 <= clk_10 + 1;
		if (clk_10 == 8)
		flag <= 1;
		else if (clk_10 > 9) begin
		flag <= 0;
		clk_10 <= 0;
		end
		else 
		flag <= 0;
	end
*/
	assign a =rnd1mem[addr];
	assign b =rnd2mem[addr];
	test_add a1(.MAIN_CLK(clk),.a(a),.b(b),.ab(data_o));
endmodule

rnd1mem、rnd2mem是通过python生成的1000组随机数，并使用matlab转换成32位表示

python代码

import random

with open("rnd1.txt", "w") as f1:
    with open("rnd2.txt", "w") as f2:
        with open("mul.txt", "w") as f3:
            for i in range(1000):
                rnd1 = round(random.uniform(-10, 10), 6)
                rnd2 = round(random.uniform(-10, 10), 6)
                mul = rnd1 * rnd2
                f1.write(str(rnd1) + "\n")
                f2.write(str(rnd2) + "\n")
                f3.write(str(round(mul, 6)) + "\n")

import numpy as np

r1=np.loadtxt("rnd1.txt",delimiter="\n",dtype="double")
r2=np.loadtxt("rnd2.txt",delimiter="\n",dtype="double")
add=r1+r2
np.savetxt("add.txt",add,fmt='%.08f')

matlab代码

a=textread("rnd1.txt");
number_dec = single(a);
hexString = num2hex(number_dec);
dlmwrite('rnd1hex.txt', hexString, 'delimiter', '', 'newline', 'pc');

a=textread("rnd2.txt");
number_dec = single(a);
hexString = num2hex(number_dec);
dlmwrite('rnd2hex.txt', hexString, 'delimiter', '', 'newline', 'pc');

a=textread("mul.txt");
number_dec = single(a);
hexString = num2hex(number_dec);
dlmwrite('mulhex.txt', hexString, 'delimiter', '', 'newline', 'pc');

a=textread("add.txt");
number_dec = single(a);
hexString = num2hex(number_dec);
dlmwrite('addhex.txt', hexString, 'delimiter', '', 'newline', 'pc');

通过iverilog进行编译仿真，使用gtkwave观察波形。生成上述文件后，运行下列bash命令

iverilog -o "add_tb.vvp" add_tb.v test_add.v

vvp -n "add_tb.vvp"

gtkwave add_tb.vcd

python count_loss.py

pause

count_loss.py用于计算误差

import numpy as np
import struct

a=np.loadtxt("add_result.txt",delimiter="\n",dtype="str")

add_result=np.zeros(a.shape[0])
for i in range(a.shape[0]):
    add_result[i]=struct.unpack('!f', bytes.fromhex(a[i]))[0]

add=np.loadtxt("add.txt",delimiter="\n",dtype="double")

count=sum(abs(add-add_result))/a.shape[0]

print(count)

最终结果如下
单周期结果图
误差如下
在这里插入图片描述

鹏鹏诶
关注
单周期CPU及流水线CPU设计（1）---logisim部件设计
TONNE_YANG的专栏
12-27 2万+
logisim的设计是设计CPU的基础，在往后的CPU的代码书写的过程中必然时刻伴随着设计图纸的需求。 （如有转载，请注明出处，否则将追究） （1）基本介绍 Logisim 允许用户使用图形用户接口设计并仿真数字电路，它自身包含一些库，库中已有诸如基础门电路，存储器、多路选择器、译码器等简单器件。在后续的实验中，你将使用这些器件搭建自己的 CPU。在本实验中，我们将在 logis
高速流水线浮点加法器的FPGA实现
01-19
由于浮点数系统操作比较复杂，需要专用硬件来完成相关的操作(在浮点运算中的浮点加法运算几乎占到全部运算操作的一半以上)，所以，浮点加法器是现代信号处理系统中重要的部件之一。FPGA是当前数字电路研究开发的一种...
4位快速加法器电路图logisim_年轻人第一个CPU——logisim单周期CPU【我的祭祖生活0x0a】...
weixin_39579726的博客
11-27 3183
さようなら Logisim (永别了Logisim)致终将发生的爱情今天P3考完了，我又没有AK我好菜啊(本菜鸡从课下到课上来谈谈在设计logisim单周期CPU时的一点点经验和踩过的坑理论知识要掌握经过理论课老师们的细心讲解和作业的轰炸(高老板班的没事了)，想必大家一定对单周期的数据通路有了基础的了解，对每个模块的功能与作用也有了相应的认识这个完全没想法的可以滚到课程...
设计一个简单的单周期CPU
潜行者的博客
08-27 4975
设计一个简单的单周期 CPU 1.1 设计单周期 CPU 时的总体思路 设计输入是指令系统规范，设计输出是一个数字逻辑电路,这个数字逻辑电路能够实现指令系统规范所定义的各项功能。 1.1.1 指令系统规范 指令系统规范是指令系统的规范文件，规范性文档是很严谨的，包含大量的细节，一般没有废话，因此建议：反复多看几遍，把正文、注解中的每个字、每个上下标、每个符号都看到。 1.1.2 CPU一般性设计方法 从宏观来看，设计一个CPU就是设计它的数据通路+控制逻辑 基本方法：对指令系统中定义的指令进行功能的分
计算机组成原理——加法器的设计
qq_45760401的博客
03-29 4694
一、加法器设计基本单元 A / B 表示进行运算的两个数 F 表示输出 Cn 表示低位来的进位 C(n + 4) 表示走向高位的进位 M 控制进行逻辑运算还是算数运算 S 控制181进行的运算种类 A= B 判断 a == b ? 1 : 0; G 进位产生函数（A 和 B 的对应位置作与，判断是否产生进位） P 进位传递函数（A 和 B 的对应位置做异或，结果与上一进位做与，判断进位是否传递） Gi 低位传递上来的进位产生函数 Pi 低位传递上来的进位传递函数 C(n + x
流水线加法器的实现（verilog)
weixin_45239657的博客
10-20 4535
对于FPGA来说，器件的延迟如T1、T2、T3相对于触发器的Tco要长的多，并且寄存器的建立时间Tsu也要比器件的延迟快的多。​ 如果某个设计可以分为若干步骤进行处理，而且整个数据处理过程是单向的，即没有反馈运算或者迭代运算，前一个步骤的输入即使下一个步骤的输出，就可以考虑采用流水线设计方法来提高系统的工作频率。第一级延迟：max（T1，T3）+ Tco，即第一级寄存器所具有的总的延迟为T1和T3两个延迟中的最大值加上寄存器的Tco（触发时间）。：将（从输入到输出）最长的路径进行初始化所需要的时间总量。
单精度浮点数加法器电路设计
qq_44837820的博客
01-17 4941
用VerilogHDL语言设计一个符合IEEE754标准的32位单精度浮点加法器。
单周期CPU实验之学习之旅
Kiloveyousmile的博客
04-13 1928
单周期CPU实验设计。这一篇，我们先来学习一些基础知识，主要包括MIPS指令集和Verilog语言。
基于FPGA的最佳精度定点加法器的设计与实现.pdf
07-13
以上知识点详细阐述了FPGA技术在定点加法器设计中的应用，同时也指出了在设计时需要关注的多个关键技术问题，如资源利用率、运算速度和精度之间的平衡，以及如何通过VHDL语言实现这些设计。通过这样的设计与优化，...
元器件应用中的基于流水线加法器的数字相关器设计
11-05
主要问题在于高位数加法器的进位延迟，这导致在一个采样时钟周期内无法完成一次完整的累加运算，进而可能造成相关运算的错误。虽然FPGA（Field-Programmable Gate Array）技术的进步提高了器件速度，但依然无法满足...
一种基于FPGA的高精度单周期TDC设计.pdf
07-13
通过在FPGA上设计多路选择器阵列和加法器构成的编码器，能够在时钟周期内对多个信号沿进行采样，从而将测量死时间降低到1个时钟周期，大幅度提高TDC的时间测量效率。 #### 自校准机制 在FPGA中实现的高精度TDC，...
单周期CPU设计与实现
热门推荐
lllllyt的博客
06-07 5万+
单周期CPU设计与实现 实验内容： 学校资料
实验四、单周期 CPU 设计与实现——单指令 CPU
lalala_HFUT的博客
06-21 1万+
实验四、单周期CPU设计与实现——单指令CPU 一、实验目的: 通过设计并实现支持一条指令的CPU，理解和掌握CPU设计的基本原理和过程。 二、实验内容: 设计和实现一个支持加法指令的单周期CPU。要求该加法指令(表示为add r1，r2，r3)格式约定如下: 采用寄存器寻址，r1，r2，r3为寄存器编号，r1和r2存放两个源操作数，r3为目标寄存器，其...
多台三相逆变器并联（本模型为三台并联，市面上多为两台并联）matlab simulink仿真 功能：实现并联系统中各逆变器输出
最新发布
10-09
多台三相逆变器并联（本模型为三台并联，市面上多为两台并联）matlab simulink仿真。 功能：实现并联系统中各逆变器输出功率均分。 （有能力的话还可以研究下垂特性、功率指令以及静态功工作点三者之间的联系） 控制策略：VSG控制策略（同步机控制） 逆变器主电路：三相逆变器，LCL滤波电路，VSG控制模块。 VSG控制模块：定、转子方程，dq变，电压电流双闭环，预同步，pwm发生器。
Ringtones波点音乐-《Lightning Moment》.mp3
10-09
Ringtones波点音乐-《Lightning Moment》.mp3
onnx2onnx-0.3.1.tar.gz
10-09
onnx2onnx-0.3.1.tar
网页商城系统 SSM毕业设计 源码+数据库+论文（JAVA+SpringBoot+Vue.JS）.zip
10-09
网页商城系统 SSM毕业设计 源码+数据库+论文（JAVA+SpringBoot+Vue.JS） 启动教程：https://www.bilibili.com/video/BV1GK1iYyE2B
实现卡尔曼滤波器,扩展卡尔曼滤波器,双卡尔曼滤波器和平方根卡尔曼滤波器Matlab代码.rar
10-09
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值