YHGW/tcpserver.go

package main

import (
	"log"
	"net"
	//"os"
	// "strconv"
	// "log"
	//"strings"
	"time"
	// "go-study/socket/config"
	"bytes"
	"strconv"

)

func handleConn(conn net.Conn) {

	log.Println("yunhorndeug.push.data.tcp.begin handleConn,cliendAddr:", conn.RemoteAddr())

	defer conn.Close()

	readChan := make(chan []byte)
	//writeChan := make(chan string)
	stopChan := make(chan bool)

	go readConn(conn, readChan, stopChan)
	// go writeConn(conn, writeChan, stopChan)

	var heartbeat []byte = []byte{0x01}

	for {
		select {
		case readStr := <-readChan:
			//log.Println("readStr:",readStr)
			//upper := strings.ToUpper(readStr)
			//writeChan <- upper

			// go yunhorn_ys_l_v1(readStr)
			go yunhorn_wireless(readStr)
		case stop := <-stopChan:
			if stop {
				log.Println("stop channel")
				break
			}
		case <-time.After(5000 * time.Millisecond):
			_, err := conn.Write(heartbeat)
			if err != nil {
				log.Println("write msg error!", err)
				stopChan <- true
			} else {
				//log.Println("write msg success!", conn.RemoteAddr())

				//暂时写死，演示用  lora心跳包给云端
				var device Device
				device.Lock()
				device.ID = "6F3A8B2D-B0DF-404A-AA7E-4A4086BD0B56"
				device.VERSION = "yunhorn_lora_l_v1"
				device.ONLINE = true
				device.DATA = make(map[string]interface{})
				device.DATA["data"] = 1
				//go send_data(1005, device)
			}
		}
	}
}

func readConn(conn net.Conn, readChan chan<- []byte, stopChan chan<- bool) {

	// data_buf := make(chan []byte)

	// Rdata := make([]byte, 0)
	data := make([]byte, 256)
	Rdata2 := make([]byte, 0)

	// go func() {
	// 	for {
	// 		select {
	// 		case kkdata := <-data_buf: //如果有数据，下面打印。但是有可能ch一直没数据
	// 		 // log.Println("yunhorndeug.push.data.tcp|",kkdata)
	//
	// 		 log.Println("###########################yunhorndeug.push.data.tcp.kkdata:",kkdata)
	// 			Rdata = append(Rdata, kkdata...)
	// 			Rdata2 = append(Rdata2,Rdata...)
	// 			count := 0
	// 			for _,v := range  Rdata{
	// 				if v==0{
	// 					break;
	// 				}
	// 				count++
	// 			}
	//
	// 			Rdata2 = make([]byte, count)
	// 			for i,v := range  Rdata{
	// 				if v==0{
	// 					break;
	// 				}
	// 				Rdata2[i]=v
	// 			}
	//
	//
	// 			log.Println("---------------------------yunhorndeug.push.data.tcp.Rdata:",Rdata2)
	// 			Rdata2 = make([]byte, 0)
	// 			//log.Println("kkdata:",kkdata)
	// 		case <-time.After(50 * time.Millisecond): //上面的ch如果一直没数据会阻塞，那么select也会检测其他case条件，检测到后3秒超时
	// 			// log.Println("超时")
	// 			if len(Rdata) > 4 {
	// 				readChan <- Rdata
	// 				Rdata = make([]byte, 0)
	// 			}
	// 			//strData := string(Rdata)
	// 			//Rdata = make([]byte,0)
	// 			//log.Println("Received:", strData)
	//
	// 			//readChan <- Rdata
	// 			//Rdata = make([]byte,0)
	// 		}
	// 	}
	// }()

	for {
		// data := make([]byte, config.SERVER_RECV_LEN)
		//data2 := make([]byte,256)
		reqLen, err := conn.Read(data)
		if err != nil {
			log.Println(err)
			break
		}

		buffer := new(bytes.Buffer)
		continueCount := 0
		log.Println("yunhorndeug.push.data.tcp.reqLen",reqLen)
    for i, b := range data[:reqLen] {

			  if continueCount>0{
					continueCount--
					continue;
				}

        s := strconv.FormatInt(int64(b&0xff), 16)
        if len(s) == 1 {
            buffer.WriteString("0")
        }
        buffer.WriteString(s)

				// log.Println(b)
				//分隔符
				end :=0
				if b==254 && i>3{
					addrs := data[i-4:i]
					//尿布台数据，地址1位 数据2位
					dataType := data[i+1]
					values := make([]byte,0)
					if data[i+1] == 1 {
						continueCount = 3
						end = 4
						//类型为1 数据量为2
						values = data[i+2:i+4]
					}else if dataType == 2{
						//类型为2 数据量位1
						values = data[i+2:i+3]
						continueCount = 2
						end = 3
					}
					log.Println("yunhorndeug.push.data.tcp.addr",addrs)
					log.Println("yunhorndeug.push.data.tcp.type",dataType)
					log.Println("yunhorndeug.push.data.tcp.values",values)
					// var buffer bytes.Buffer
					// buffer.Write(addrs)
					// buffer.Write(dataType)
					// buffer.Write(values)

					// go dealDatav3(data[i-4:i+end])
					
				}
    }



    // 转化为字符串
    log.Println("yunhorndeug.push.data.tcp.16data:",buffer.String())

		Rdata2 = make([]byte, reqLen)
		for i,v := range  data[:reqLen]{
			Rdata2[i]=v
		}

		log.Println("===========================yunhorndeug.push.data.tcp.origin.Rdata:",Rdata2)

		// Rdata2 = make([]byte, count)

		// log.Println("read.data:%d,%s", Bytes2Bits(data[3:4])[0],conn.RemoteAddr())

		// data_buf <- data

		data = make([]byte, 256)
	}

	stopChan <- true
}

//BytesCombine 多个[]byte数组合并成一个[]byte
func BytesCombine(pBytes ...[]byte) []byte {
    return bytes.Join(pBytes, []byte(""))
}

func writeConn(conn net.Conn, writeChan <-chan string, stopChan chan<- bool) {
	for {
		strData := <-writeChan
		_, err := conn.Write([]byte(strData))
		if err != nil {
			log.Println(err)
			break
		}

		log.Println("Send:", strData)
	}

	stopChan <- true
}