rttymodem mostly

chopper.go

@@ -0,0 +1,89 @@
+// Copyright (C) 2017 Keelan Lightfoot
+// Copyright (C) 2007-2008 Board of Regents of the University of Wisconsin
+//             System (Univ. of Wisconsin-Madison, Trace R&D Center)
+// Copyright (C) 2007-2008 Omnitor AB
+// Copyright (C) 2007-2008 Voiceriver Inc
+//
+// This library is free software; you can redistribute it and/or modify it
+// under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation; either version 2.1 of the License, or (at
+// your option) any later version.
+
+package gobaudot
+
+import (
+	"math"
+)
+
+
+
+type TimeSlice struct {
+	Marking		bool
+	Carrier		bool
+	LpfVal		float64
+	ThreshVal		float64
+}
+
+// Chopper is fun
+type Chopper struct {
+	input         chan int16
+	output        chan TimeSlice  
+	dsp           *dsp
+	settings      *ModemSettings
+	sigOut        bool
+	samplerate    int
+	div           int
+}
+
+// NewChopper is fun
+func NewChopper(s *ModemSettings, input chan int16, output chan TimeSlice) *Chopper {
+
+	d := new(Chopper)
+	d.input = input
+	d.output = output
+	
+	d.settings = s
+
+	// the bandpass filter is picky about the sample rate, and the output is perfectly
+	// balanced when the sample rate is 3x the center frequency, so lets divide the sample
+	// rate down to as close to that as we can get.
+
+	centerFrequency := math.Abs(float64(d.settings.OneFreq)+float64(d.settings.ZeroFreq)) / 2 * 3
+
+	d.div = int(math.Floor(float64(d.settings.SampleRate) / float64(centerFrequency)))
+	if d.div == 0 {
+		d.div = 1
+	}
+
+	d.samplerate = d.settings.SampleRate / d.div
+	
+	d.dsp = newDsp(d.settings.OneFreq, d.settings.ZeroFreq, d.samplerate)
+
+	go d.run()
+	return d
+}
+
+func (d *Chopper) run() {
+
+	count := 0
+	for sam := range d.input {
+	
+		count++
+		// can't remember what this is for
+		if count%d.div > 0 {
+			continue
+		}
+
+		d.dsp.demod(float64(sam))
+
+		d.output <- TimeSlice{
+			Marking: d.dsp.mark(),
+			Carrier: d.dsp.carrier(),
+			LpfVal: d.dsp.lpfVal(),
+			ThreshVal: d.dsp.threshVal(),
+		}
+		
+		
+	}
+
+}

demodulator.go

@@ -12,7 +12,7 @@
 package gobaudot
 
 import (
-	"fmt"
+	//"fmt"
 	"math"
 )
 
@@ -190,7 +190,7 @@ func (d *Demodulator) run() {
 					   assume we have lost d.sampleRateK signal */
 					if d.minSigTimeout > d.samplesPerBit {
 						nextState = demodStateWaitStart
-						fmt.Println("demodStateWaitStart")
+						//fmt.Println("demodStateWaitStart")
 
 					}
 				} else {

dsp.go

@@ -69,7 +69,15 @@ func (d *dsp) edgeDetected() bool {
 }
 
 func (d *dsp) carrier() bool {
-	return math.Abs(d.demLpf) > d.demTotal*d.minThresh
+	return math.Abs(d.demLpf) > d.demTotal*d.minThresh && d.demTotal*d.minThresh != 0
+}
+
+func (d *dsp) lpfVal() float64 {
+	return math.Abs(d.demLpf)
+}
+
+func (d *dsp) threshVal() float64 {
+	return d.demTotal*d.minThresh
 }
 
 func (d *dsp) level() (float64, float64, float64) {

encoder.go

@@ -11,7 +11,6 @@
 
 package gobaudot
 
-import "fmt"
 
 // Encoder is fun
 type Encoder struct {
@@ -100,7 +99,7 @@ func (e *Encoder) run() {
 			modCase = c.shift
 
 			/*and update our counter*/
-			fmt.Println("charsWithoutShift", charsWithoutShift)
+			//fmt.Println("charsWithoutShift", charsWithoutShift)
 			charsWithoutShift = 0
 		}
 
@@ -116,7 +115,7 @@ func (e *Encoder) run() {
 			} else {
 				e.output <- e.charset.shift()
 			}
-			fmt.Println("charsWithoutShift", charsWithoutShift)
+			//fmt.Println("charsWithoutShift", charsWithoutShift)
 
 			charsWithoutShift = 0
 		}

examples/audioin/main.go

@@ -9,7 +9,7 @@ import (
 
 func main() {
 
-	s := &openbaudot.ModemSettings{
+	s := &gobaudot.ModemSettings{
 		Baud:       45,
 		StopBits:   2,
 		DataBits:   5,
@@ -27,7 +27,7 @@ func main() {
 		panic(err)
 	}
 	defer stream.Close()
-	charset := openbaudot.LoadCharset(&openbaudot.USTTY)
+	charset := gobaudot.LoadCharset(&gobaudot.USTTY)
 	//
 	// encoderIn := make(chan rune)
 	// modulatorIn := make(chan byte)
@@ -39,10 +39,10 @@ func main() {
 	//done := make(chan struct{})
 
 	//sig := make(chan [2]float64)
-	// encoder := openbaudot.NewEncoder(encoderIn, modulatorIn, charset)
-	// openbaudot.NewModulator(s, modulatorIn, demodulatorIn)
-	openbaudot.NewDemodulator(s, demodulatorIn, decoderIn)
-	openbaudot.NewDecoder(decoderIn, decoderOut, charset)
+	// encoder := gobaudot.NewEncoder(encoderIn, modulatorIn, charset)
+	// gobaudot.NewModulator(s, modulatorIn, demodulatorIn)
+	gobaudot.NewDemodulator(s, demodulatorIn, decoderIn)
+	gobaudot.NewDecoder(decoderIn, decoderOut, charset)
 
 	go func() {
 		for {

examples/foo/main.go

@@ -0,0 +1,176 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/gordonklaus/portaudio"
+	"github.com/naleek/openbaudot"
+)
+
+// CLoIP
+// Current Loop over IP
+// A Terrible Protocol
+// Based on TCP (because latency really doesn't matter)
+// Full duplex
+
+// client-server protocol
+// server handles pairing
+// client handles encoding/decoding
+
+/*
+
+SERVER
+
+<client connects>
+
+>> greeting message
+<< IAM <client ID>
+>> 200 ok
+
+<< RATE 1000
+>> 200 ok
+
+<< WAIT
+>> 200 ok <connection ID>
+
+
+-- or -- 
+
+<< JOIN <connection ID>
+>> 200 ok
+
+
+
+
+*/
+
+type Frame struct {
+	Seq		uint32
+	Len		uint32
+	Samples []byte
+}
+
+func main() {
+
+	s := &gobaudot.ModemSettings{
+		Baud:       45,
+		StopBits:   2,
+		DataBits:   5,
+		SampleRate: 8000,
+		OneFreq:    2125,
+		ZeroFreq:   2295,
+	}
+
+	portaudio.Initialize()
+	defer portaudio.Terminate()
+
+	in := make([]int16, 64)
+	stream, err := portaudio.OpenDefaultStream(1, 0, float64(s.SampleRate), len(in), in)
+	if err != nil {
+		panic(err)
+	}
+	defer stream.Close()
+	
+	chopperIn := make(chan int16)
+	chopperOut := make(chan gobaudot.TimeSlice)
+	
+	gobaudot.NewChopper(s, chopperIn, chopperOut)
+
+
+	var buff byte
+	var bits int
+	x := 0
+	
+	sampleRate := 500
+	
+	rollover := s.SampleRate/sampleRate
+	
+	fmt.Println("Data Rate: ", sampleRate/8, "bytes per second")
+	fmt.Println(rollover)
+	
+	go func() {
+		for {
+			r := <-chopperOut
+			x++
+			
+			if r.Carrier && x%rollover==0 {
+				buff = buff << 1
+				bits++
+				if r.Marking {
+					buff = buff | 0x01
+				}
+				if bits == 8 {
+					fmt.Printf("%x",buff)
+					bits = 0
+					buff = 0
+				}
+				//fmt.Println(r.LpfVal, r.ThreshVal)
+			}
+		}
+	}()
+
+	stream.Start()
+	for {
+		stream.Read()
+		for i := range in {
+			chopperIn <- in[i]
+		}
+
+	}
+	//stream.Stop()
+
+	// go func() {
+	// 	encoder.EncodeString("hello world")
+	// 	time.Sleep(2000 * time.Millisecond)
+	// 	done <- struct{}{}
+	// }()
+
+}
+
+// // NewOBL is fun
+// func NewOBL(baud float64, callback Callback) *OBL {
+//
+// 	obl := new(OBL)
+//
+// 	obl.charset = USTTY.initialize()
+//
+// 	obl.callback = callback
+//
+// 	obl.mod.sinLutQ15 = make([]int16, 16384)
+// 	for i := 0; i < 16384; i++ {
+// 		obl.mod.sinLutQ15[i] = int16(32767 * math.Sin(2.0*math.Pi*float64(i)/float64(16384)))
+// 	}
+//
+// 	/* regular reset */
+// 	obl.autobaud.enabled = true
+// 	obl.Reset(baud)
+//
+// 	go func() {
+// 		portaudio.Initialize()
+// 		defer portaudio.Terminate()
+//
+// 		x := make(chan int16, 300)
+//
+// 		stream, _ := portaudio.OpenDefaultStream(0, 1, float64(sampleRate), 0, func(out []int16) {
+// 			for i := range out {
+// 				out[i] = <-x
+// 			}
+// 		})
+//
+// 		stream.Start()
+//
+// 		for {
+// 			s := <-obl.mod.output
+// 			//go func() {
+// 			obl.demod.input <- s
+// 			x <- s
+// 			//}()
+// 			//	binary.Write(f, binary.LittleEndian, s)
+// 		}
+// 	}()
+//
+// 	go obl.Modulate()
+// 	go obl.Demodulate()
+//
+// 	return obl
+// }

examples/main.go

@@ -7,9 +7,15 @@ import (
 	"github.com/naleek/openbaudot"
 )
 
+type TTYFrame struct {
+	Seq		uint32
+	Len		uint32
+	Samples []byte
+}
+
 func main() {
 
-	s := &openbaudot.ModemSettings{
+	s := &gobaudot.ModemSettings{
 		Baud:       45,
 		StopBits:   2,
 		DataBits:   5,
@@ -18,22 +24,28 @@ func main() {
 		ZeroFreq:   2295,
 	}
 
-	charset := openbaudot.LoadCharset(&openbaudot.USTTY)
+	charset := gobaudot.LoadCharset(&gobaudot.USTTY)
 
 	encoderIn := make(chan rune)
 	modulatorIn := make(chan byte)
 
-	demodulatorIn := make(chan int16)
-	decoderIn := make(chan byte)
-	decoderOut := make(chan rune)
+	//demodulatorIn := make(chan int16)
+//	decoderIn := make(chan byte)
+//	decoderOut := make(chan rune)
 
+	chopperIn := make(chan int16)
+	chopperOut := make(chan gobaudot.TimeSlice)
+	
 	done := make(chan struct{})
 
 	//sig := make(chan [2]float64)
-	encoder := openbaudot.NewEncoder(encoderIn, modulatorIn, charset)
-	openbaudot.NewModulator(s, modulatorIn, demodulatorIn)
-	openbaudot.NewDemodulator(s, demodulatorIn, decoderIn)
-	openbaudot.NewDecoder(decoderIn, decoderOut, charset)
+	encoder := gobaudot.NewEncoder(encoderIn, modulatorIn, charset)
+	gobaudot.NewModulator(s, modulatorIn, chopperIn)
+//	gobaudot.NewModulator(s, modulatorIn, demodulatorIn)
+	//gobaudot.NewDemodulator(s, demodulatorIn, decoderIn)
+//	gobaudot.NewDecoder(decoderIn, decoderOut, charset)
+
+	gobaudot.NewChopper(s, chopperIn, chopperOut)
 
 	go func() {
 		encoder.EncodeString("hello world")
@@ -42,10 +54,28 @@ func main() {
 	}()
 
 	running := true
+	x := 0
+	
+	var buff byte
+	var bits int
+	
 	for running {
 		select {
-		case r := <-decoderOut:
-			fmt.Printf("%c", r)
+		case r := <-chopperOut:
+			x++
+			
+			if r.Carrier && x%10==0 {
+				buff = buff << 1
+				bits++
+				if r.Marking {
+					buff = buff | 0x01
+				}
+				if bits == 8 {
+					fmt.Printf("%x",buff)
+					bits = 0
+					buff = 0
+				}
+			}
 		case <-done:
 			running = false
 		}

examples/rttymodem/main.go

@@ -0,0 +1,480 @@
+package main
+
+import (
+	"fmt"
+
+	"bufio"
+	"bytes"
+	"github.com/gordonklaus/portaudio"
+	"github.com/naleek/openbaudot"
+	"io"
+	"net"
+	"os"
+	"regexp"
+	"strings"
+	"unicode/utf8"
+	"time"
+)
+
+func msain() {
+
+	CLI(os.Stdin, os.Stdout, nil)
+
+}
+
+func main() {
+	fmt.Println("hi")
+	s := &gobaudot.ModemSettings{
+		Baud:       45,
+		StopBits:   2,
+		DataBits:   5,
+		SampleRate: 8000,
+		OneFreq:    2125,
+		ZeroFreq:   2295,
+	}
+
+	portaudio.Initialize()
+	defer portaudio.Terminate()
+
+	in := make([]int16, 64)
+	out := make([]int16, 64)
+	stream, err := portaudio.OpenDefaultStream(1, 1, float64(s.SampleRate), len(in), in, out)
+	if err != nil {
+		panic(err)
+	}
+	defer stream.Close()
+	charset := gobaudot.LoadCharset(&gobaudot.USTTY)
+
+	encoderIn := make(chan rune, 100)
+	modulatorIn := make(chan byte)
+
+	demodulatorIn := make(chan int16)
+	modulatorOut := make(chan int16)
+
+	decoderIn := make(chan byte)
+	decoderOut := make(chan rune)
+
+	modemReader := NewModemReader(decoderOut)
+	modemWriter := NewModemWriter(encoderIn)
+
+	
+	gobaudot.NewEncoder(encoderIn, modulatorIn, charset)
+	modulator := gobaudot.NewModulator(s, modulatorIn, modulatorOut)
+
+	gobaudot.NewDemodulator(s, demodulatorIn, decoderIn)
+	gobaudot.NewDecoder(decoderIn, decoderOut, charset)
+
+	//go CLI(modemReader, modemWriter)
+	modulator.SetAmplitude(0)
+	
+	go CLI(modemReader, modemWriter, modulator) // os.Stdin
+
+	stream.Start()
+	go func() {
+		l := 0
+		for v := range modulatorOut {
+			out[l] = v
+			l++
+			if l == 64 {
+				l = 0
+				stream.Write()
+			}
+		}
+	}()
+	for {
+		stream.Read()
+		for i := range in {
+			demodulatorIn <- in[i]
+		}
+	}
+	//stream.Stop()
+
+	// go func() {
+	// 	encoder.EncodeString("hello world")
+	// 	time.Sleep(2000 * time.Millisecond)
+	// 	done <- struct{}{}
+	// }()
+
+}
+
+type ModemReader struct {
+	input chan rune
+}
+
+func NewModemReader(c chan rune) *ModemReader {
+	m := &ModemReader{}
+	m.input = c
+	return m
+}
+
+func (m *ModemReader) Read(p []byte) (n int, err error) {
+	r := <-m.input
+
+	fmt.Print(string(r))
+
+	l := utf8.EncodeRune(p, r)
+	return l, nil
+}
+
+func (m *ModemReader) Add(b rune) {
+	m.input <- b
+}
+
+type ModemWriter struct {
+	output chan rune
+}
+
+func NewModemWriter(c chan rune) *ModemWriter {
+	m := &ModemWriter{}
+	m.output = c
+	return m
+}
+
+func (m *ModemWriter) Write(p []byte) (n int, err error) {
+
+	runes := bytes.Runes(p)
+
+	fmt.Print(string(runes))
+	
+	for _, r := range runes {
+		m.output <- r
+	}
+	return len(p), nil
+}
+
+func (m *ModemWriter) Get() rune {
+	return <-m.output
+}
+
+func CLI(ttyReader io.Reader, ttyWriter io.Writer, modulator *gobaudot.Modulator) {
+
+	fmt.Fprintln(ttyWriter, "RTTY TCP Modem 1.0")
+
+	localEcho := false
+	autoAnswer := false
+	escapeRune := '?'	
+	modulatorOn := true
+	ttyBufferedReader := bufio.NewReader(ttyReader)
+	
+	var netConn *NetConn
+	
+	for { 
+
+		s, _ := ttyBufferedReader.ReadString('\n')
+
+		//fmt.Println(s) 
+		s = strings.ToUpper(s)
+		regex, _ := regexp.Compile(`^AT([SHOED])([0-9])?(\?)?(?:=([\S]*))?(?: (.*))?`)
+
+		params := regex.FindStringSubmatch(s)
+
+		if params == nil {
+			continue
+		}
+
+		command := params[1]
+
+		var register string
+		if len(params) > 2 {
+			register = params[2]
+		}
+
+		var registerQuery string
+		if len(params) > 3 {
+			registerQuery = params[3]
+		}
+
+		var value string
+		if len(params) > 4 {
+			value = params[4]
+		}
+
+		var parameter string
+		if len(params) > 5 {
+			parameter = params[5]
+		}
+
+		//fmt.Fprintf(ttyWriter, "command: '%s' register: '%s' query: '%s' value: '%s' parameter: '%s'\n", command, register, registerQuery, value, parameter)
+		switch command {
+		case "O": // online
+			if !netConn.Connected() {
+				fmt.Fprintln(ttyWriter, "ERROR No active session")
+				break
+			}
+			fmt.Fprintln(ttyWriter, "OK")
+			dataMode(netConn, ttyBufferedReader, ttyWriter, escapeRune)
+		case "D": // dial
+			if netConn.Connected() {
+				fmt.Fprintln(ttyWriter, "ERROR Session in progress")
+				break
+			}
+			addr := strings.TrimSpace(parameter)
+			
+			var err error
+			netConn, err = NewNetConn(addr)
+			if err != nil {
+				fmt.Fprintln(ttyWriter, "ERROR", err)
+				break
+			} else {
+				fmt.Fprintln(ttyWriter, "CONNECTED")
+				dataMode(netConn, ttyBufferedReader, ttyWriter, escapeRune)
+			}
+		case "H": // hangup
+			if !netConn.Connected() {
+				fmt.Fprintln(ttyWriter, "ERROR No active session")
+				break
+			}
+			netConn.Hangup()
+			fmt.Fprintln(ttyWriter, "OK")
+		case "E": // local echo
+			localEcho = (register == "1")
+			fmt.Fprintln(ttyWriter, "local echo", localEcho)
+		case "S": // local echo
+			switch register {
+			case "0":
+				if registerQuery == "?" {
+					if autoAnswer {
+						fmt.Fprintln(ttyWriter, "1")
+					} else {
+						fmt.Fprintln(ttyWriter, "0")
+					}
+				} else if value != "" {
+					autoAnswer = (value == "1")
+					fmt.Fprintln(ttyWriter, "OK")
+				}
+			case "2":
+				if registerQuery == "?" {
+					fmt.Fprintln(ttyWriter, string(escapeRune))
+				} else if value != "" {
+					runes := []rune(value)
+					escapeRune = runes[0]
+					fmt.Fprintln(ttyWriter, "OK")
+				}
+			case "3":
+				if registerQuery == "?" {
+					if modulatorOn {
+						fmt.Fprintln(ttyWriter, "1")
+					} else {
+						fmt.Fprintln(ttyWriter, "0")
+					}
+				} else if value != "" {
+					modulatorOn = (value == "1")
+					fmt.Fprintln(ttyWriter, "OK")
+					if modulatorOn {
+						modulator.SetAmplitude(16384)
+					} else {	
+						modulator.SetAmplitude(0)
+					}
+				}
+			}
+
+		
+		}
+		
+		
+	}
+
+}
+
+
+
+func dataMode(netConn *NetConn, ttyBufferedReader *bufio.Reader, ttyWriter io.Writer, escapeRune rune) {
+	
+	ttyCancelReader := make(chan struct{})
+	ttyReadChan := make(chan rune)
+	ttyReadPending := make(chan struct{})
+	
+	var t *time.Timer
+	escapeRunes := 0
+
+
+	go func() {
+		for {
+			r, l, err := ttyBufferedReader.ReadRune()
+			if err != nil && err != io.EOF {
+				return
+			}
+			if l > 0 {
+				select {
+				case <-ttyCancelReader:
+					ttyBufferedReader.UnreadRune() // oops this wasn't ours. let's put it back.
+					close(ttyReadPending)
+					return
+				default:
+					ttyReadChan <- r
+				}
+			}
+		}
+	}()
+	
+	netReadChan := netConn.OutputChannel()
+	netConn.Resume()
+pipeLoop:	
+	for {
+		var r rune	
+		if t == nil {
+			select {
+				case r = <-ttyReadChan:
+				case q := <-netReadChan:
+					ttyWriter.Write([]byte(string(q)))
+					continue pipeLoop
+			}
+		} else {
+			select {
+				case r = <-ttyReadChan:
+				case q := <-netReadChan:
+					ttyWriter.Write([]byte(string(q)))
+					continue pipeLoop
+				case <-t.C:
+					fmt.Fprintln(ttyWriter, "\nOK")
+					close(ttyCancelReader)
+					netConn.Pause()
+					break pipeLoop
+
+			}
+		}
+		if r == escapeRune && escapeRunes < 3 {
+			escapeRunes++
+		} else {
+			if t != nil {
+				t.Stop()
+			}
+			escapeRunes = 0
+		}
+		if escapeRunes == 3 {
+			t = time.NewTimer(1*time.Second)
+		}
+		err := netConn.Write(r)
+		if err != nil {
+			fmt.Fprintln(ttyWriter, "NO CARRIER")
+			close(ttyCancelReader)
+			break pipeLoop
+		}
+	}
+	<- ttyReadPending
+	
+}
+
+
+
+
+
+
+
+
+type NetConn struct {
+	netReader *bufio.Reader
+	conn net.Conn
+	netReadChan chan rune
+	hangup chan struct{}
+	paused  bool
+	connected bool
+}
+
+func NewNetConn(addr string) (*NetConn, error) {
+	c := &NetConn{}
+	var err error
+	c.conn, err = net.Dial("tcp", addr)
+	if err != nil {
+		return nil, err
+	}
+	c.connected = true
+
+	c.netReader = bufio.NewReader(c.conn)
+	
+	c.netReadChan = make(chan rune)
+	c.hangup = make(chan struct{})
+	c.paused = false
+	
+	go func() {
+		for {
+			r, l, err := c.netReader.ReadRune()
+			if err != nil && err != io.EOF {
+				c.cleanup()
+				return
+			}
+			if c.paused || l == 0 {
+				select {
+				case <- c.hangup:
+					c.cleanup()
+					return
+				default: // discard
+				}
+			} else {
+				select {
+				case c.netReadChan <- r:
+				case <- c.hangup:
+					c.cleanup()
+					return
+				}
+			}
+		}
+		
+	}()
+	
+	
+	return c, nil
+}
+
+func (c *NetConn) Write(r rune) error {
+	if c == nil {
+		return fmt.Errorf("NetConn not initialized")
+	}
+	_, err := c.conn.Write([]byte(string(r)))
+	if err != nil {	
+		close(c.hangup)
+	}
+	return err
+}
+
+func (c *NetConn) Hangup() {
+	if c == nil {
+		return
+	}
+	c.conn.Close()
+	close(c.hangup)
+}
+
+func (c *NetConn) cleanup() {
+	close(c.netReadChan)
+	c.connected = false 
+}
+
+func (c *NetConn) Pause() {
+	if c == nil {
+		return
+	}
+	c.paused = true
+}
+
+func (c *NetConn) Resume() {
+	if c == nil {
+		return
+	}
+	c.paused = false
+}
+
+func (c *NetConn) OutputChannel() chan rune {
+	if c == nil {
+		return nil
+	}
+	return c.netReadChan
+}
+
+func (c *NetConn) Connected() bool {
+	if c == nil {
+		return false
+	}
+	return c.connected
+}
+
+
+
+
+
+
+
+
+
+
+

modulator.go

@@ -92,6 +92,10 @@ func (m *Modulator) modulate(bit int) { //short *buffer, int samples)
 	}
 }
 
+func (m *Modulator) SetAmplitude(amplitude int16) {
+	m.amplitude = amplitude
+}
+
 func (m *Modulator) run() {
 
 	var modState int  // modulator state machine