go语言计算推算心率算法 http服务

这篇具有很好参考价值的文章主要介绍了go语言计算推算心率算法 http服务。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

目的

为了计算心率和并且将心率计算作为http服务来运行

几种计算方法

1 基本数据
a) hrv heart rate variability
b) 呼吸
2 傅里叶变换 计算频率 高频和低频
3 隐形马尔科夫 模型 hmm 重在于推测概率
根据最近的心率计算
4 神经网络计算

基本计算

hrv 5 min RR 间期 平均值标准差 sdann
24h 正常的RR间期总体标准差 sdnn
24h 每5分钟时段 标准差的平均值 sdnn index
两个相邻RR间期 差值的均方根RMSSD
24h 相邻两个正常RR 间期差值 大于50ms 的个数百分比pnn50
go语言计算推算心率算法 http服务,go,http协议,http,golang,算法,http

go语言计算推算心率算法 http服务,go,http协议,http,golang,算法,http

go语言计算推算心率算法 http服务,go,http协议,http,golang,算法,http

定义数据结构

type Data struct {
	Heart int
	Time  int64
	//Name  string
}

type Cmd struct {
	// 1 立刻返回,求数据结果立即返回,不用存储
	// 2 单人所有数据24 小时内所有数据
	// 3 其他
	Type int
	//设备号码,唯一标识
	Device string
	Data   []Data
}
type Repay struct {
	Code   int     `json:"code"`
	Device string  `json:"device"`
	Ret    string  `json:"ret"`
	Sdnn   int     `json:"sdnn"`
	Rmssd  int     `json:"rmssd"`
	Pnn50  float32 `json:"pnn50"`
}

声明http 服务

使用http 服务进行数据返回,使用gin 来制作一个server


// 创建一个错误处理函数,避免过多的 if err != nil{} 出现
func dropErr(e error) {
	if e != nil {
		panic(e)
	}
}

/*
 计算一个段落,比如5分钟,或者10分钟,等
*/
func calculate_parag(cmd *Cmd, f int, t int) *Repay {
	size := t - f + 1
	var in []float32 = make([]float32, size)
	var n int = 0
	for i := f; i <= t; i++ {
		in[n] = (float32)(cmd.Data[i].Heart)
		n++
	}

	vsdnn := sdnn.Get_Stddev(in)
	vrmssd := sdnn.Get_Rmssd(in)
	vpnn50 := sdnn.Get_Pnn50(in)

	Repays := &Repay{
		Code:   0,
		Device: cmd.Device,
		Ret:    "正常",
		Sdnn:   int(vsdnn),
		Rmssd:  int(vrmssd),
		Pnn50:  vpnn50,
	}
	return Repays
}

func calculate1(cmd *Cmd, c chan Repay, db *sql.DB) {
	//in1 := []float32{71, 72, 69, 70, 65, 74}
	size := len(cmd.Data)
	fmt.Println("device is ", cmd.Device, " len is ", size)

	if size == 0 {
		return
	}
	var in []float32 = make([]float32, size)

	for i, v := range cmd.Data {
		in[i] = (float32)(v.Heart)
	}

	//ret 为mean均值

	if cmd.Type == 1 {
		fmt.Println("type is 1")
		vsdnn := sdnn.Get_Stddev(in)
		//fmt.Fprintf(w, "%f", vsdnn)
		result := &Repay{
			Code:   0,
			Device: cmd.Device,
			Ret:    "正常",
			Sdnn:   int(vsdnn),
			Rmssd:  0,
			Pnn50:  0.0,
		}
		if vsdnn < 100 {

			if vsdnn < 50 {
				result.Ret = "良好"
			}
		} else {
			result.Ret = "疲劳"
		}
		c <- *result
		//fmt.Println("prepare send")
		//fmt.Fprintf(w, "%f", vsdnn)
		//io.WriteString(w, "hello, world!\n")
		// msg, err := json.Marshal(Repays)
		// if err != nil {
		// 	fmt.Println(err)
		// } else {
		// 	w.Header().Set("content-type", "text/json")
		// 	w.Write(msg)
		// 	fmt.Println(string(msg))
		// }

	} else if cmd.Type == 2 {
		//每5分钟或者10分钟求取一个值,存储,报表所用
		fmt.Println("start to calc")
		var nt int = 0
		var nf int = 0
		tf := cmd.Data[0].Time
		var result *Repay
		for {
			nt++
			if nt == size {
				c <- *result
				break
			}
			if cmd.Data[nt].Time-tf >= 300 { // 大于5分钟 5*60
				result = calculate_parag(cmd, nf, nt)
				fmt.Println(result)
				//记录到数据库
				//计算字符串时间
				time := time.Unix(cmd.Data[nf].Time, 0)
				timestr := calc_time_str(time)
				db_insert(cmd.Device, result.Sdnn, 0, result.Rmssd, result.Pnn50, timestr)
				nf = nt
				tf = cmd.Data[nf].Time

			}

		}

	} else if cmd.Type == 3 {
		fmt.Println("type is 3")
		vsdnn := sdnn.Get_Stddev(in)
		vrmssd := sdnn.Get_Rmssd(in)
		vpnn50 := sdnn.Get_Pnn50(in)
		//记录到数据库
		result := &Repay{
			Code:   0,
			Device: cmd.Device,
			Ret:    "",
			Sdnn:   int(vsdnn),
			Rmssd:  int(vrmssd),
			Pnn50:  vpnn50,
		}
		c <- *result
		//s := fmt.Sprintf(`{"sdnn":%f,"rmssd":%f,"pnn50":%f}`, vsdnn, vrmssd, vpnn50)

		//msg, _ := json.Marshal(Repays)
		//fmt.Println(string(msg))
		//w.Header().Set("content-type", "application/json;charset=UTF-8")
		//w.Write(msg)
	}

	//
}
func init() {
	//s := fmt.Sprintf(`{"sdnn":%f,"rmssd":%f,"pnn50":%f}`, 1.0, 2.0, 3.0)
	//fmt.Println(s)
}

func gin_server() {
	r := gin.Default()

	r.GET("/api/device/:name", func(c *gin.Context) {
		dname := c.Param("name")
		c.JSON(200, gin.H{
			"message": dname,
		})
	})

	r.POST("/book", func(c *gin.Context) {
		c.JSON(200, gin.H{
			"message": "POST",
		})
	})
	r.Run(":9000")
}

func main() {
	defer dbclose()
	config := config_init()

	storage_init()
	go gin_server()
	http.HandleFunc("/hrv", func(w http.ResponseWriter, r *http.Request) {

		fmt.Println(html.EscapeString(r.URL.Path))

		if r.Method == "POST" {
			b, err := ioutil.ReadAll(r.Body)
			if err != nil {
				log.Println("Read failed:", err)
			}
			//defer r.Body.Close()

			cmd := &Cmd{}
			err = json.Unmarshal(b, cmd)
			if err != nil {
				log.Println("json format error:", err)
			} else {
				//c := make(chan interface{}, 1)
				c := make(chan Repay, 1)
				go calculate1(cmd, c, db)

				select {
				//case <-ctx.Done():
				//	log.Printf("Context interrupt or timeout: %v\n", ctx.Err())

				case result := <-c:
					msg, _ := json.Marshal(result)
					fmt.Println(string(msg))
					w.Header().Set("content-type", "application/json;charset=UTF-8")
					w.Write(msg)
				}
				// log.Println("cmd:", string(b))
				// log.Println("cmd:", cmd.Data[0])
				//io.WriteString(w, "hello, world!\n")
				//w.ResponseWriter("1")
				//time.Sleep(1 * time.Second)
				//fmt.Fprintf(w, "%f", 100.0)
			}

		} else {

			log.Println("not support")

			w.WriteHeader(405)
			return
		}

	})

	serveraddress := ":" + config.Port
	fmt.Println("server lister at ", serveraddress)
	log.Fatal(http.ListenAndServe(serveraddress, nil))

}

以上的服务比较简单,不做过多解释,以下贴出使用sqlite的代码sqlite.go,go语言使用sqlite是要用mingw来编译sqlite的,这个注意以下,我就直接贴代码了

package main

import (
	"database/sql"
	"encoding/json"
	"fmt"
	"unsafe"
	_ "github.com/mattn/go-sqlite3"
)

var db *sql.DB
var err error
var sql_table = `CREATE TABLE if not exists "data_1" (
    "id" INTEGER PRIMARY KEY AUTOINCREMENT,
    "deviceid" VARCHAR(64) NULL,
    "sdnn" INTEGER,
	"average" INTEGER,
    "rmssd" INTEGER,
	"pnn50" float,
    "timestart" TIMESTAMP default (datetime('now', 'localtime'))
);
CREATE INDEX deviceid_idx ON file_hash_list (deviceid);
`

type Data0 struct {
	id        int
	Deviceid  string
	Sdnn      int
	Average   int
	Rmssd     int
	Pnn50     float32
	Timestart string
}

func checkErr(err error) {
	if err != nil {
		panic(err)
	}
}

func db_insert(did string, ssdn int, average int, rmssd int, pnn50 float32, timestart string) int64 {
	stmt, err := db.Prepare("INSERT INTO data_1(deviceid, sdnn,average,rmssd,pnn50,timestart) values(?,?,?,?,?,?)")
	checkErr(err)

	res, err := stmt.Exec(did, ssdn, average, rmssd, pnn50, timestart)
	checkErr(err)

	id, err := res.LastInsertId()
	checkErr(err)

	return id

}
func db_update_average( /*db *sql.DB,*/ deviceid string, average int) int64 {

	stmt, err := db.Prepare("update data_1 set deviceid=? where deviceid=?")
	checkErr(err)

	res, err := stmt.Exec(average, deviceid)
	checkErr(err)

	affect, err := res.RowsAffected()
	checkErr(err)
	return affect
}

func db_select_all( /*db *sql.DB,*/ data0 *Data0) {
	rows, err := db.Query("SELECT * FROM data_1")

	checkErr(err)

	for rows.Next() {
		err = rows.Scan(&data0.id, &data0.Deviceid, &data0.Sdnn, &data0.Average,
			&data0.Rmssd, &data0.Pnn50, &data0.Timestart)
		checkErr(err)
	}
}
func getJSON(sqlString string) (string, error) {
	stmt, err := db.Prepare(sqlString)
	if err != nil {
		return "", err
	}
	defer stmt.Close()
	rows, err := stmt.Query()
	if err != nil {
		return "", err
	}
	defer rows.Close()
	columns, err := rows.Columns()
	if err != nil {
		return "", err
	}
	count := len(columns)
	tableData := make([]map[string]interface{}, 0)
	values := make([]interface{}, count)
	valuePtrs := make([]interface{}, count)
	for rows.Next() {
		for i := 0; i < count; i++ {
			valuePtrs[i] = &values[i]
		}
		rows.Scan(valuePtrs...)
		entry := make(map[string]interface{})
		for i, col := range columns {
			var v interface{}
			val := values[i]
			b, ok := val.([]byte)
			if ok {
				v = string(b)
			} else {
				v = val
			}
			entry[col] = v
		}
		tableData = append(tableData, entry)
	}
	jsonData, err := json.Marshal(tableData)
	if err != nil {
		return "", err
	}
	s1 := (*string)(unsafe.Pointer(&jsonData))
	return *s1, nil
	//return string(jsonData), nil
}

//size:每页显示条数,index页码
func db_select_by(tablename string, deviceid string, size int, index int) {
	//select * from GuestInfo order by GuestId limit {0} offset {0}*{1}", size, index-1);
	s := fmt.Sprintf("select * from %s where deviceid='%s' order by id desc limit %d offset %d",
		tablename, deviceid, size, size*(index-1))
	fmt.Println("sql is:", s)
	ret, err := getJSON(s)
	if err != nil {

	} else {
		//http 返回数据
		fmt.Println(ret)
	}
}

func db_delete_data(id int) int64 {
	stmt, err := db.Prepare("delete from data_1 where id=?")
	checkErr(err)

	res, err1 := stmt.Exec(id)
	checkErr(err1)

	affect, err2 := res.RowsAffected()
	checkErr(err2)

	return affect

}

func init() {
	fmt.Println("sqlite open")
	db, err = sql.Open("sqlite3", "./data.db")
	checkErr(err)
	db.Exec(sql_table) //执行数据表
	//defer db.Close()
}

func dbclose() {
	db.Close()
}

//just for unit test
func sqlite_test() {

	// db, err = sql.Open("sqlite3", "./data.db")
	// defer db.Close()
	// checkErr(err)
	// db.Exec(sql_table) //执行数据表
	// id := db_insert("qianbo", 15, 70, 20, 0.2, "2021-01-09 07:05:22")
	// fmt.Println("insert:", id)
	// id = db_insert("guanzhi", 16, 71, 25, 0.3, "2021-12-09 07:05:22")
	// fmt.Println("insert:", id)
	// affected := db_update_average("qianbo", 67)
	// fmt.Println("update:", affected)

	// var data0 Data0
	// db_select_all(&data0)
	// fmt.Println(id, data0.Deviceid)
	//'select * from data_1 where deviceid='qianbo' order by id desc limit 5 offset 0

	db_select_by("data_1", "qianbo", 5, 1)
	db_select_by("data_1", "qianbo", 5, 2)
}

配置文件

配置文件主要是用来配置端口和配置提交数据地址
config.yaml

port: 8080
postaddress: "http://127.0.0.1/qianbo"


package main

import (
	"fmt"

	"github.com/spf13/viper"
)

type Config struct {
	Port        string
	PostAddress string
}

func config_init() *Config {
	//监听事件

	viper.SetConfigName("config")
	viper.SetConfigType("yaml")
	viper.AddConfigPath(".")
	err := viper.ReadInConfig()
	if err != nil {
		panic(fmt.Errorf("Fatal error config file: %s \n", err))
	}

	config := &Config{}

	config.Port = viper.GetString("port")
	config.PostAddress = viper.GetString("postaddress")
	fmt.Println(config.Port, config.PostAddress)
	viper.WatchConfig()
	return config
	// gin.SetMode(gin.ReleaseMode)
	// //r := gin.Default()
	// if err := r.Run(fmt.Sprintf(":%d", viper.Get("port"))); err != nil {
	// 	panic(err)
	// }
}

算法

最后给出几个算法的计算方法,确实比较简单,直接看代码就行了

package sdnn

import (
	"fmt"
	"math"
)

func Print(arr []int) {
	for i, v := range arr {
		fmt.Printf("arr[%d]=%d\n", i, v)
	}
}
func Get_Average(arr []float32) float32 {
	var x float32 = 0.
	for _, v := range arr {
		//fmt.Printf("arr[%d]=%f\n", i, v)
		a := (60 * 1000) / v
		x += a
	}
	var ret float32 = 0.
	ret = x / (float32)(len(arr))
	return ret
}

//五分钟就是sdann
//24销售是sdnn
func Get_Stddev(arr []float32) float64 {
	var mean float32 = Get_Average(arr)
	var x float32 = 0.0
	for _, v := range arr {
		a := 60000 / v
		x += (a - mean) * (a - mean)
	}
	var size float64 = (float64)(len(arr))
	var ret float64 = math.Sqrt((float64)(x) / size)
	return ret
}
func Get_Rmssd(arr []float32) float64 {
	var x float32 = 0.0
	for i := 1; i < len(arr); i++ {
		a := 60000 / arr[i-1]
		b := 60000 / arr[i]
		x += (b - a) * (b - a)
	}
	var size float64 = (float64)(len(arr) - 1)
	var ret float64 = math.Sqrt((float64)(x) / size)
	return ret
}

//24h 相邻两个正常RR 间期差值 大于50ms 的个数百分比pnn50
//迷走神经
func Get_Pnn50(arr []float32) float32 {
	var pnn int = 0
	for i := 1; i < len(arr); i++ {
		a := 60000 / arr[i-1]
		b := 60000 / arr[i]
		if a > b {
			if (a - b) > 50 {
				pnn++
			}
		} else {
			if (b - a) > 50 {
				pnn++
			}
		}

	}
	var size float32 = (float32)(len(arr) - 1)
	return (float32)((float32)(pnn) / size)
}

post 测试数据

为了编写测试程序而写,当然最好使用python来做,不过go也可以了

package main

import (
	"bytes"
	"fmt"
	"io/ioutil"
	"net"
	"net/http"
	"time"
)

type Data struct {
	Heart int
	Time  int
	Name  string
}
type Cmd struct {
	Type int
	Data []Data
}

var g_str = `{"Type":2,"Device":"qianbo","Data":[{"Heart":78,"Time":678},
{"Heart":75,"Time":700},
{"Heart":69,"Time":800},
{"Heart":72,"Time":900},
{"Heart":73,"Time":1000},
{"Heart":70,"Time":1100},
{"Heart":73,"Time":1200},
{"Heart":73,"Time":1300},
{"Heart":67,"Time":1400},
{"Heart":68,"Time":1500},
{"Heart":70,"Time":1600},
{"Heart":70,"Time":1700},
{"Heart":71,"Time":1750},
{"Heart":68,"Time":1850},
{"Heart":67,"Time":1900},
{"Heart":65,"Time":1950},
{"Heart":73,"Time":2000},
{"Heart":70,"Time":2050},
{"Heart":69,"Time":2100}
]}`

var g_url = "http://127.0.0.1:8080/hrv"
var g_jsonStr = []byte(g_str)

func GetPostResponse(url, bodyType string, body *[]byte) (rdata []byte, err error) {
	b := bytes.NewBuffer(*body)
	var r *http.Response
	r, err = http.Post(url, bodyType, b)

	if err == nil {
		rbody := (*r).Body
		defer rbody.Close()

		var nRead int
		nRead, err = rbody.Read(rdata)
		if err != nil {
			fmt.Printf("GetPostResponse from (%s), read data error.", url)
			fmt.Println(err.Error())
		}
		if nRead <= 0 {
			err = fmt.Errorf("GetPostResponse from (%s), read data error (%d)", url, nRead)
			fmt.Println(err.Error())
		}
	} else {
		fmt.Printf("GetPostResponse from (%s), get error.", url)
		fmt.Println(err.Error())
	}

	return rdata, err
}

func SamplePost() {
	reader := bytes.NewReader(g_jsonStr)

	request, err := http.NewRequest("POST", g_url, reader)
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	request.Header.Set("Content-Type", "application/json;charset=UTF-8")
	client := http.Client{}
	resp, err := client.Do(request)
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	respBytes, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	//byte数组直接转成string,优化内存
	fmt.Println(string(respBytes))
	// str := (*string)(unsafe.Pointer(&respBytes))
	// fmt.Println(*str)
}

func main() {
	SamplePost()
}

func main2() {
	rdata, err := GetPostResponse(g_url, "application/json", &g_jsonStr)
	if err != nil {
		fmt.Println(err)
	} else {
		fmt.Println(len(rdata))
		fmt.Println(string(rdata))
	}
}

func main_() {
	//var arr [2]Data
	//json.Unmarshal([]byte(str), &s)

	// data := make(map[string]interface{})
	// data["Name"] = "qianbo"
	// data["Heart"] = 67
	// data["Time"] = 778

	// D := make(map[string]interface{})
	// D["Type"] = 1
	// D["Data"] = data
	// bytesData, err := json.Marshal(D)

	// if err != nil {
	// 	fmt.Println(err.Error())
	// 	return
	// }
	// reader := bytes.NewReader(bytesData)
	//request, err := http.NewRequest("POST", url, reader)

	client := http.Client{
		Transport: &http.Transport{
			Dial: func(netw, addr string) (net.Conn, error) {
				conn, err := net.DialTimeout(netw, addr, time.Second*5) //设置建立连接超时
				if err != nil {
					return nil, err
				}
				conn.SetDeadline(time.Now().Add(time.Second * 5)) //设置发送接受数据超时
				return conn, nil
			},
			ResponseHeaderTimeout: time.Second * 5,
		},
	}

	request, err := http.NewRequest("POST", g_url, bytes.NewBuffer(g_jsonStr))
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	request.Header.Set("Content-Type", "application/json;charset=UTF-8")
	request.Header.Set("Connection", "Keep-Alive")
	//request.Header.Set("Cookie", "name=anny")

	fmt.Println("send")
	resp, err := client.Do(request)
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	defer resp.Body.Close()
	fmt.Println("recv")
	body, err := ioutil.ReadAll(resp.Body)

	if err != nil {
		fmt.Println(err.Error())
		return
	}
	//byte数组直接转成string
	//strret := (*string)(unsafe.Pointer(&resp.Body))
	fmt.Println(len(body))
	fmt.Println(string(body))

}

缓存数据如何存储

下面是为了缓存数据而编写的入到redis里面而写,不一定要用

package main

import (
	"context"
	"fmt"
	"log"

	//"github.com/go-redis/redis"
	"github.com/go-redis/redis/v8"
)

var rdb *redis.Client
var ctx = context.Background()

// // 初始化连接
func storage_init() (err error) {

	rdb = redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "", // no password set
		DB:       0,  // use default DB
	})

	_, err = rdb.Ping(ctx).Result()
	if err != nil {
		fmt.Println("error connect redis")
		return err
	}
	return nil
}
func get(key string) string {
	val, err := rdb.Get(ctx, key).Result()
	if err == redis.Nil {
		fmt.Println("key of ", key, "does not exists")
		return ""
	} else if err != nil {
		return ""
		//panic(err)
	} else {
		fmt.Println(key, val)
		return val
	}
}
func set(key string, value float32) {

	err := rdb.Set(ctx, key, value, 0).Err()
	if err != nil {
		panic(err)
	}
}
func hset(hashTable, key, val string) {
	isSetSuccessful, err := rdb.HSet(ctx, hashTable, key, val).Result()

	if err != nil {
		log.Fatal(err)
	}
	//如果键存在这返回false,如果键不存在则返回true
	fmt.Println(isSetSuccessful)
}

//redis命令:hget hashTable key
func hget(hashTable, key string) {
	val, err := rdb.HGet(ctx, hashTable, key).Result()

	if err != nil {
		log.Fatal(err)
	} else {
		fmt.Println(val)
	}
	// for k, v := range val {
	// 	fmt.Printf("k = %v v = %s\n", k, v)
	// }
}
func hgetall(hashTable string) {
	val, err := rdb.HGetAll(ctx, hashTable).Result()

	if err != nil {
		log.Fatal(err)
	} else {
		fmt.Println(val)
	}
	// for k, v := range val {
	// 	fmt.Printf("k = %v v = %s\n", k, v)
	// }
}

func main__() {
	storage_init()
	set("qianbo", 1000)
	get("qianbo")
	hset("device001", "1001", "{abc:100,d:23}")
	hset("device001", "1002", "{abc:101,d:123}")
	hset("device001", "1003", "{abc:102,d:223}")
	hget("device001", "1001")
	hget("device001", "1002")
	hget("device001", "1003")
	hgetall("device001")
}

时间测试

其中为了测试时间差也写了一些测试,一并贴出

package main

import (
	"fmt"
	"time"
)

func calc_seconds(t1 string, t2 string) int {

	f1, err := time.Parse("2006-01-02 15:04:05", t1)
	if err != nil {
		return -1
	}

	f2, err2 := time.Parse("2006-01-02 15:04:05", t2)
	if err2 != nil {
		return -1
	}
	d := (int)(f2.Sub(f1).Seconds())
	if d < 0 {
		x := 0 - d
		return x
	}
	return d
}
func calc_timenow() string {

	timeStr := time.Now().Format("2006-01-02 15:04:05")
	//fmt.Println(timeStr)
	return timeStr
}
func calc_time_str(t time.Time) string {
	return t.Format("2006-01-02 15:04:05")
}
func test_time() {
	timestamp := time.Now().Unix()
	fmt.Println(timestamp)
	x := time.Unix(timestamp, 0)
	fmt.Println(x)
	//获取时间戳
	fmt.Println(calc_timenow())
	f1 := "2021-04-11 13:34:37"
	f2 := "2021-04-11 13:34:30"
	fmt.Println(calc_seconds(f1, f2))

}

最后贴出go.mod 文件

module hrv

go 1.15

require (
	github.com/garyburd/redigo v1.6.3
	github.com/gin-gonic/gin v1.7.7
	github.com/go-redis/redis v6.15.9+incompatible
	github.com/go-redis/redis/v8 v8.11.4
	github.com/mattn/go-sqlite3 v1.14.10
	github.com/spf13/viper v1.10.1
)

以上是为了计算心率数据而做的非产品代码,读者可做参考文章来源地址https://www.toymoban.com/news/detail-578229.html

到了这里,关于go语言计算推算心率算法 http服务的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Go语言的TCP和HTTP网络服务基础

    目录 【TCP Socket 编程模型】 Socket读操作 【HTTP网络服务】 HTTP客户端 HTTP服务端 TCP/IP 网络模型实现了两种传输层协议:TCP 和 UDP,其中TCP 是面向连接的流协议,为通信的两端提供稳定可靠的数据传输服务;UDP 提供了一种无需建立连接就可以发送数据包的方法。实现网络编程,

    2024年02月12日
    浏览(49)
  • Go语言的服务器编程与HTTP_2

    Go语言是一种现代编程语言,由Google的Robert Griesemer、Rob Pike和Ken Thompson于2009年开发。Go语言的设计目标是简单、高效、可靠和易于扩展。它具有垃圾回收、类型安全、并发简单等特点。Go语言的标准库提供了丰富的功能,包括网络、并发、数据结构等。 HTTP/2是一种更新版本的

    2024年02月20日
    浏览(42)
  • 使用Go语言的HTTP客户端和服务器

    使用Go语言进行HTTP客户端和服务器开发是一种高效且强大的方式。Go语言的标准库提供了对HTTP协议的全面支持,使得创建HTTP客户端和服务器变得简单。 首先,让我们来看一下如何创建一个简单的HTTP服务器。在Go中,可以使用 net/http 包来创建HTTP服务器。以下是一个简单的示例

    2024年01月16日
    浏览(50)
  • 【计算机网络】HTTP协议以及简单的HTTP服务器实现

    虽然我们说, 应用层协议是我们程序猿自己定的. 但实际上, 已经有大佬们定义了一些现成的, 又非常好用的应用层协议, 供我们直接参考使用. HTTP(超文本传输议)就是其中之一。 平时我们俗称的 “网址” 其实就是说的 URL 像 / ? : 等这样的字符, 已经被url当做特殊意义理解了.

    2024年01月20日
    浏览(63)
  • c++ 计算心率数据的几个算法

    其他可参考我写的go语言的算法计算,包含了http服务 go语言计算心率算法 //hrv 5 min RR 间期 平均值标准差 sdann // 24h 正常的RR间期总体标准差 sdnn // 24h 每5分钟时段 标准差的平均值 sdnn index // 两个相邻RR间期 差值的均方根RMSSD // 24h 相邻两个正常RR 间期差值 大于50ms 的个数百分比

    2024年02月16日
    浏览(40)
  • Go语言网络编程:HTTP服务端之底层原理与源码分析——http.HandleFunc()、http.ListenAndServe()

    在 Golang只需要几行代码便能启动一个 http 服务,在上述代码中,完成了两件事: 调用 http.HandleFunc 方法,注册了对应于请求路径 /ping 的 handler 函数 调用 http.ListenAndServe,启动了一个端口为 8999 的 http 服务 2.1 server 结构 Addr :表示服务器监听的地址。如\\\":8080\\\"表示服务器在本地

    2024年02月08日
    浏览(62)
  • 用Go语言编写微服务:Go语言作为一门新兴的语言,在微服务架构风潮下最近几年在云计算领域蓬勃发展

    作者:禅与计算机程序设计艺术 2010 年底,Go 语言问世,吸引了整个编程界的目光,短短几个月后,已经成为事实上的主流语言,其受到大家的追捧,主要体现在以下三个方面: 内存效率高 并发编程简单 支持动态链接库,方便集成各种各样的第三方组件 在过去的几年里,随

    2024年02月09日
    浏览(38)
  • Go语言的云计算与服务器管理实战

    云计算是一种基于互联网的计算资源共享模式,通过虚拟化技术将计算资源(如服务器、存储、网络等)分配给客户,实现资源的共享和优化。云计算的主要优势包括灵活性、可扩展性、低成本、高可用性等。 Go语言是一种现代的编程语言,由Google开发,具有高性能、简洁、可

    2024年02月20日
    浏览(49)
  • 基础算法-递推算法-学习

    现象: 基础算法-递推算法-学习 方法: 这就是一种递推的算法思想。递推思想的核心就是从已知条件出发,逐步推算出问题的解 最常见案例: 一:正向递推案例: 弹力球回弹问题: * 弹力球从100米高度自由落下, * 每次落地后反跳回原高度的一半,并再落下 * 求它在第1

    2024年02月10日
    浏览(35)
  • 算法中的递推算法

    给定一个数的序列H0,H1,…,Hn,…若存在整数n0,使当nn0时,可以用等号(或大于号、小于号)将Hn与其前面的某些项Hi(0in)联系起来,这样的式子就叫做递推关系。 递推算法是一种简单的算法,即通过已知条件,利用特定关系得出中间推论,直至得到结果的算法。 递推算法分为顺推

    2024年02月12日
    浏览(34)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包