func (g *Gbus) SendThenRecv(sendMsg []byte, timo int) (frame []byte, err error) {
	var (
		fd      int
		nfds    int
		readSet unix.FdSet
		tv      unix.Timeval
		buf     []byte // read buffer
		nbytes  int    // how many bytes read
	)

	// func (s *S) Write(buf []byte)(n int, err error) {
	//	n, err = unix.Write(s.fd, buf)
	//  	return
	// }
	if _, err = g.ser.Write(sendMsg); err != nil {
		return
	}

	// func (s *S) Tcdrain() (err error) {
	// 	_, _, eno := unix.Syscall(unix.SYS_IOCTL, uintptr(s.fd), uintptr(unix.TCSBRK), uintptr(1))
	//	if eno != 0 {
	//		err = errors.New(eno.Error())
	//	}
	//	return
	// }	
	g.ser.Tcdrain()

	fd = g.ser.Fd() // get serial fd
	frame = make([]byte, 0)

	readSet.Zero()
	readSet.Set(fd)
	tv.Sec = 0
	tv.Usec = timo * 1000

	mlog.Debug.Println("starting select")
	if nfds, err = unix.Select(fd+1, &readSet, nil, nil, &tv); err != nil {
		mlog.Error.Println(err)
		return
	}
	if nfds > 0 {
		if readSet.IsSet(fd) {
			buf = make([]byte, 1024)

			// func (s *S) Read(buf []byte) (n int, err error) {
			// 	n, err = unix.Read(s.fd, buf)
			// 	return
			// }
			if nbytes, err = g.ser.Read(buf); err != nil { // read data of serial
				mlog.Error.Println(err)
				return
			}
			if nbytes > 0 {
				frame = append(frame, buf[:nbytes]...) // package as a frame
			}
		}
	} else if nfds == 0 {
		mlog.Debug.Println("timeout")
		err = eAckTimeOut
		return
	} else {
		err = eUnknow
		return
	}

	return
}

func main() {
	var (
		frame []byte
		err   error
	)
	// ...

	sendMsg := []byte{0x01, 0x02, 0x03} // some serialized data

	for {
		if frame, err = g.SendThenRecv(sendMsg, 100); err != nil {
			// handle error
			// ...
			time.Sleep(20 * time.Millisecond)
			continue
		}
		// handle received data
		// ...
		time.Sleep(20 * time.Millisecond)
	}

	// ..
}