类似与VHDL中得generic（）portmap（）；  verilog中各个模块之间也可以进行了参数得传递，通过修改顶层模块的参数，底层的模块参数被修改。

方法1： defparam定义法

方法2： #方法

例如

 底层模块，设置参数初始值

1. module parameter_tst(clk,a,b,c);
2.       parameter parameter1 = 10,
3.                   parameter2 = 0 ;
4.       input clk;
5.       input [2:0]a;
6.       input [2:0]b;
7.       
8.       output reg [4:0]c;
9. always@(posedge clk)
10.     c = a + parameter1 +  b +  parameter2; 
11. endmodule

顶层模块，修改参数

1. module parameter_top(clk,a,b,c);      
2.     input clk;
3.     input [2:0]a;
4.     input [2:0]b;
5.     
6.     output reg  [5:0]c;
7.     
8.     wire [4:0]c1;
9.     wire [4:0]c2;    
10.     parameter_tst #(
11.                     .parameter1(5),
12.                     .parameter2(6)
13.                     )
14.                add1(.clk(clk),
15.                     .a(a),
16.                     .b(b),
17.                     .c(c1)
18.                     );   
19.     parameter_tst #(
20.                     .parameter1(3),
21.                     .parameter2(4)
22.                     ) 
23.                  add2(
24.                     .clk(clk),
25.                     .a(a),
26.                     .b(b),
27.                     .c(c2)
28.                     ); 
29.     
30. always@(posedge clk )
31.      c = c1 + c2; 
32. endmodule

Go语言RESTful参数传递

参考文章：https://blog.csdn.net/xingwangc2014/article/details/51623157

Go语言可以通过RESTful的方法实现守护，简单总结下RESTful的参数传递方法

一、使用URL的方式将参数传递到处理函数中
形如：/todos/{todoId}这种类型的url中的todoId参数是可以被RESTful解析，通过todoId传递参数

简单编写例子，说明通过URL进行参数传递

import (
   "fmt"
    "log"
    "net/http"
    "github.com/gorilla/mux"
)

func main() {
    // 第三方组件（Gorilla Mux package）： “github.com/gorilla/mux” 
    router := mux.NewRouter().StrictSlash(true)
    // {todoId}代表需要传入的值
    router.HandleFunc("/todos/{todoId}", TodoShow).Methods("POST")
    log.Fatal(http.ListenAndServe(":8080", router))
}

// 定义回调函数
func TodoShow(w http.ResponseWriter, r *http.Request) {
    vars := mux.Vars(r)
    todoId := vars["todoId"]
    fmt.Fprintln(w, "Todo show:", todoId)
}

输入：curl http://10.12.6.112:8080/todos/AAA
输出：

二、使用crul参数的方式传递参数到处理函数中
1、curl支持加入参数，并且在RESTful中可以进行解析，编写了一个利用RESTful实现文件拷贝的功能，说明这种参数的解析方式，以下为为可以解析crul参数传入的例子：

import (
   "fmt"
    "log"
    "net/http"
    "github.com/gorilla/mux"
)

func main() {
    // 第三方组件（Gorilla Mux package）： “github.com/gorilla/mux” 
    router := mux.NewRouter().StrictSlash(true)
    // {todoId}代表需要传入的值
    router.HandleFunc("/daemon", Daemon).Methods("POST")
    log.Fatal(http.ListenAndServe(":8080", router))
}

// 定义回调函数
func Daemon(w http.ResponseWriter, r *http.Request) {
    // 解析CURL传入的信息
    r.ParseMultipartForm(32 << 20)
    if r.MultipartForm != nil {
        //解析目录参数
        subDir := r.MultipartForm.Value["sub_dir"]
        if len(subDir) > 0 {
            fmt.Fprintln(w, subDir[0])
        }

        // 解析文件参数
        file := r.MultipartForm.File["upload_files"]
        if len(file) > 0 {
            for _, j := range file {
                str := j.Filename
                if strings.Contains(str, "\\") { // 中文路径处理
                    str = strings.Replace(str, "\\", "/", -1)
                }
                fmt.Fprintln(w, str)
                fmt.Fprintln(w, j.Size)

                // 实现一个简单的拷贝
                // 拼接存放文件路径
                fileName := fmt.Sprintf("%v/%v", subDir[0], path.Base(str))

                // 打开待拷贝文件
                uf, _ := j.Open()

                // 打开拷贝文件
                lf, _ := os.OpenFile(fileName, os.O_CREATE|os.O_WRONLY, 0660)
                // 进行拷贝
                io.Copy(lf, uf)

                // 关闭文件描述符
                lf.close()
                uf.close()
            }

        } else {
            fmt.Fprintln(w, "Empty")
        }
    }
}

编译通过后，运行程序
新开启终端执行命令：
curl -X POST “sub_dir=/test-upload” -F “upload_files=@/mnt/hgfs/mc_share_1/etcd-v3.2.9-linux-amd64.tar.gz” -F “upload_files=@/mnt/hgfs/mc_share_1/go1.10.3.linux-amd64.tar.gz” http://10.12.6.112:8080/daemon
执行成功后，文件会拷贝到路径/test-upload下，前提是/test-upload路径存在

获取说名：
其中*http.Request的成员变量MultipartForm 是用来存放获取到信息的结构体，定义如下：
type Form

type Form struct {
    Value map[string][]string           // key-value类型变量均放入这个map，map的每个key可以带一个字符串slice结构（也表示可以声明多个同名key）
    File  map[string][]*FileHeader      // 文件key 和value ，其value是一个FileHeader的slice
}

type FileHeader

type FileHeader struct {
    Filename string                       // 文件名
    Header   textproto.MIMEHeader         // 文件头
    // 内含隐藏或非导出字段
}

具体详细信息可以参考：https://studygolang.com/pkgdoc 对于模块mime/multipart的说明

区别普通的key-value的方法是，文件名类型的key-value会多一个@