半加器

c++
//文件：half_adder.h

#pragma once
#include <systemc>
using namespace sc_core;

/*
 * @brief 半加器模块
 * 
 * 该模块实现了一个基本的半加器功能，接收两个输入位并产生一个和位和一个进位输出。
 * 
 * @param a 输入位a
 * @param b 输入位b
 * @param sum 输出的和位
 * @param carry 输出的进位
 */
SC_MODULE(half_adder){
    sc_in <bool> a,b; // 输入端口
    sc_out<bool>sum,carry; // 输出端口

    /*
     * @brief 半加器的处理函数
     * 
     * 该函数负责计算输入位a和b的和以及产生的进位。
     */
    void prc_half_adder();

    /*
     * @brief 半加器的构造函数
     * 
     * 初始化半加器模块，将prc_half_adder函数注册为响应函数，当输入a或b发生变化时触发。
     */
    SC_CTOR(half_adder){
        SC_METHOD(prc_half_adder);
        sensitive << a << b;
    }

};

//文件：half_adder.cpp

#include "half_adder.h"
/**
 * @brief 实现半加器逻辑
 * 
 * 该函数不接受参数，也不返回值，但会修改类内的sum和carry成员变量。
 * 它完成两个二进制位a和b的加法操作，计算出它们的和(sum)以及进位(carry)。
 */
void half_adder::prc_half_adder() {
    // 计算a和b的异或结果，得到无进位相加的和
    sum=a^b;
    // 计算a和b的与结果，得到产生的进位
    carry=a&b;
}

全加器

c++
//文件：full_adder.h

#pragma once
#include "half_adder.h"
using namespace sc_core;

/*
 * 全加器模块
 * 该模块实现了一个基本的全加器功能，可以对两个输入位a、b以及一个进位输入carry_in进行加法操作，
 * 并产生一个和输出sum以及一个进位输出carry_out。
 */
SC_MODULE(full_adder){
    sc_in<bool>a, b, carry_in; // 输入端口：a、b为两个待加位，carry_in为进位输入
    sc_out<bool>sum, carry_out; // 输出端口：sum为加法结果的和，carry_out为产生的进位输出

    sc_signal<bool>c1, c2, s1; // 中间信号量，用于内部计算过程
    void prc_or(); // 处理或逻辑的过程函数
    half_adder *ha1_ptr, *ha2_ptr; // 指向half_adder实例的指针

    /**
     * 全加器构造函数
     * 用于初始化全加器模块，创建两个half_adder实例并连接它们以实现全加器功能。
     */
    SC_CTOR(full_adder){
        ha1_ptr = new half_adder("ha1"); // 创建第一个half_adder实例
        // 命名关联第一个half_adder的输入和输出
        ha1_ptr->a(a);
        ha1_ptr->b(b);
        ha1_ptr->sum(s1);
        ha1_ptr->carry(c1);
        
        ha2_ptr = new half_adder("ha2"); // 创建第二个half_adder实例
        // 位置关联第二个half_adder的输入和输出
        (*ha2_ptr)(s1, carry_in, sum, c2);
        
        SC_METHOD(prc_or); // 注册方法prc_or，用于处理或逻辑
        sensitive << c1 << c2; // 指定prc_or方法对c1和c2信号敏感
        
    }
    // 析构函数
    ~full_adder(){
        delete ha1_ptr; // 删除第一个half_adder实例
        delete ha2_ptr; // 删除第二个half_adder实例
    }
};

//文件：full_adder.cpp

#include "full_adder.h"

/**
 * full_adder::prc_or 函数实现或门逻辑处理
 * 本函数用于处理全加器中的或门逻辑，即计算两个进位输入c1和c2的或运算结果，
 * 并将结果作为carry_out的值。
 * 
 * 参数:
 * c1 -- 第一个进位输入
 * c2 -- 第二个进位输入
 * 
 * 返回值:
 * 无返回值，但会将c1和c2的或运算结果存储在carry_out成员变量中。
 */
void full_adder::prc_or() {
  // 计算c1和c2的或运算结果，并将结果存储在carry_out中
  carry_out=c1|c2;
  }

验证功能

c++
//文件：driver.h

#pragma once
#include<systemc>
using namespace sc_core;
/*
 * @brief driver模块，用于提供驱动逻辑。
 * 
 * 该模块包含三个输出信号：d_a, d_b, d_cin，并通过prc_driver过程来控制这些信号的逻辑行为。
 */
SC_MODULE(driver){
    // 输出信号声明
	sc_out<bool>d_a, d_b, d_cin;

    /**
     * @brief prc_driver过程，模块的主要逻辑过程。
     * 
     * 该过程为线程，用于控制和驱动输出信号d_a, d_b, d_cin的行为。
     */
	void prc_driver();
	
    /**
     * @brief driver模块的构造函数。
     * 
     * 通过构造函数初始化模块，创建并启动prc_driver过程。
     */
	SC_CTOR(driver){
		SC_THREAD(prc_driver); // 创建并启动一个线程过程prc_driver
	}
	
};

//文件：driver.cPP

#include "driver.h"

/**
 * @brief driver类的prc_driver成员函数
 * 
 * 该函数是一个无限循环，主要功能是周期性地更新d_a, d_b, d_cin的值，并等待一定时间。
 * 它没有参数和返回值。
 */
void driver::prc_driver() {
	sc_dt::sc_uint<3> pattern;  // 定义一个3位的整型变量pattern，用于存储当前的模式值
	pattern=0;           // 初始化pattern为0
	while (1)            // 进入一个无限循环
	{
		d_a=pattern[0];   // 将pattern的最低位赋值给d_a
		d_b=pattern[1];   // 将pattern的第二位赋值给d_b
		d_cin=pattern[2]; // 将pattern的最高位赋值给d_cin
		wait(5,SC_NS);    // 等待5纳秒
		pattern++;         // 将pattern的值加1，为下一次循环准备
	}
	
}

//文件：monitor.h

#pragma once
#include <systemc>
using namespace sc_core;

/**
 * @brief 监视器模块，用于监视多个信号的状态变化。
 *
 * 该模块连接了五个信号：m_a, m_b, m_cin, m_sum, m_cout。
 * 当这些信号中的任何一个发生变化时，都会触发prc_monitor方法。
 */
SC_MODULE(monitor){
    sc_in<bool> m_a, m_b, m_cin, m_sum, m_cout; // 输入信号声明

    /**
     * @brief 监视器的处理函数。
     *
     * 当监视的信号发生变化时被调用，用于执行相应的监视逻辑。
     */
    void prc_monitor();

    /**
     * @brief 监视器的构造函数。
     *
     * 初始化监视器模块，设置当哪些信号变化时触发prc_monitor方法。
     */
    SC_CTOR(monitor){
        SC_METHOD(prc_monitor); // 方法声明，当指定的信号变化时执行prc_monitor
        sensitive << m_a << m_b << m_cin << m_sum << m_cout; // 指定敏感信号
    }
    
};

//文件：monitor.cpp

#include "monitor.h"

/**
 * @brief 实现监控器的处理函数
 * 该函数用于监控并打印当前时间以及变量a、b、carry_in、sum、carry_out的值。
 * 
 */
void monitor::prc_monitor() {
    // 打印当前时间及传入参数和内部状态的值
    std::cout<<"At time"<<sc_time_stamp()<<"::";
	std::cout<<"(a,b,carry_in):";
	std::cout<<m_a<<m_b<<m_cin;
	std::cout<<"(sum,carry_out):"<<m_sum<<m_cout<<std::endl;

}

//文件：full_adder_main.cpp

#include"driver.h"
#include"monitor.h"
#include"full_adder.h"

/**
 * @brief 主函数，用于演示如何使用SCampilkan库实现一个全加器，并通过波形驱动和监控进行验证。
 * 
 * @param argc 参数个数。
 * @param argv 参数值数组。
 * @return int 总是返回0，表示成功执行。
 */
int sc_main(int argc, char* argv[]) {
    // 定义全加器的输入和输出信号
	sc_signal<bool> t_a,t_b,t_cin,t_sum,t_cout;

    // 实例化一个全加器模块和一个波形驱动模块
	full_adder f1("FullAdderWithHalfAdder");
	driver d1("GenerateWaveforms");

    // 使用位置关联方式连接全加器模块
	f1<<t_a<<t_b<<t_cin<<t_sum<<t_cout;

    // 使用命名关联方式连接波形驱动模块
	d1.d_a(t_a);
	d1.d_b(t_b);
	d1.d_cin(t_cin);

    // 实例化一个波形监控模块并使用位置关联方式连接
	monitor mo1("MonitorWaveforms");
	mo1<<t_a<<t_b<<t_cin<<t_sum<<t_cout;

    // 启动SCimulation，设置模拟时间为100ns
	sc_start(100,SC_NS);
	
    // 程序执行结束，返回0
	return(0);

}

结果

        SystemC 2.3.3-Accellera --- Oct  4 2020 22:59:38
        Copyright (c) 1996-2018 by all Contributors,
        ALL RIGHTS RESERVED

Info: (I804) /IEEE_Std_1666/deprecated: positional binding using << or , is deprecated, use () instead.
At time0 s::(a,b,carry_in):000(sum,carry_out):00
At time5 ns::(a,b,carry_in):100(sum,carry_out):00
At time5 ns::(a,b,carry_in):100(sum,carry_out):10
At time10 ns::(a,b,carry_in):010(sum,carry_out):10
At time15 ns::(a,b,carry_in):110(sum,carry_out):10
At time15 ns::(a,b,carry_in):110(sum,carry_out):01
At time20 ns::(a,b,carry_in):001(sum,carry_out):01
At time20 ns::(a,b,carry_in):001(sum,carry_out):11
At time20 ns::(a,b,carry_in):001(sum,carry_out):10
At time25 ns::(a,b,carry_in):101(sum,carry_out):10
At time25 ns::(a,b,carry_in):101(sum,carry_out):00
At time25 ns::(a,b,carry_in):101(sum,carry_out):01
At time30 ns::(a,b,carry_in):011(sum,carry_out):01
At time35 ns::(a,b,carry_in):111(sum,carry_out):01
At time35 ns::(a,b,carry_in):111(sum,carry_out):11
At time40 ns::(a,b,carry_in):000(sum,carry_out):11
At time40 ns::(a,b,carry_in):000(sum,carry_out):01
At time40 ns::(a,b,carry_in):000(sum,carry_out):00
At time45 ns::(a,b,carry_in):100(sum,carry_out):00
At time45 ns::(a,b,carry_in):100(sum,carry_out):10
At time50 ns::(a,b,carry_in):010(sum,carry_out):10
At time55 ns::(a,b,carry_in):110(sum,carry_out):10
At time55 ns::(a,b,carry_in):110(sum,carry_out):01
At time60 ns::(a,b,carry_in):001(sum,carry_out):01
At time60 ns::(a,b,carry_in):001(sum,carry_out):11
At time60 ns::(a,b,carry_in):001(sum,carry_out):10
At time65 ns::(a,b,carry_in):101(sum,carry_out):10
At time65 ns::(a,b,carry_in):101(sum,carry_out):00
At time65 ns::(a,b,carry_in):101(sum,carry_out):01
At time70 ns::(a,b,carry_in):011(sum,carry_out):01
At time75 ns::(a,b,carry_in):111(sum,carry_out):01
At time75 ns::(a,b,carry_in):111(sum,carry_out):11
At time80 ns::(a,b,carry_in):000(sum,carry_out):11
At time80 ns::(a,b,carry_in):000(sum,carry_out):01
At time80 ns::(a,b,carry_in):000(sum,carry_out):00
At time85 ns::(a,b,carry_in):100(sum,carry_out):00
At time85 ns::(a,b,carry_in):100(sum,carry_out):10
At time90 ns::(a,b,carry_in):010(sum,carry_out):10
At time95 ns::(a,b,carry_in):110(sum,carry_out):10
At time95 ns::(a,b,carry_in):110(sum,carry_out):01