dev commit

README.md

@@ -0,0 +1,5 @@
+# Gobaudot
+
+Derived from the Open Baudot C library created David Rowe:
+
+// sourceforge link

code.go

@@ -9,7 +9,7 @@
 // the Free Software Foundation; either version 2.1 of the License, or (at
 // your option) any later version.
 
-package openbaudot
+package gobaudot
 
 import "unicode"
 

common.go

@@ -9,9 +9,9 @@
 // the Free Software Foundation; either version 2.1 of the License, or (at
 // your option) any later version.
 
-// Package openbaudot provides a set of tools to encode, modulate, demodulate and
+// Package gobaudot provides a set of tools to encode, modulate, demodulate and
 // baudot/TTY/RTTY data streams
-package openbaudot
+package gobaudot
 
 import "math"
 
@@ -26,6 +26,8 @@ const (
 	EventTransmitState
 	// EventIdle is fun
 	EventIdle
+	// EventEncodeStringComplete is fun
+	EventEncodeStringComplete
 )
 
 // Callback is func

decoder.go

@@ -9,7 +9,7 @@
 // the Free Software Foundation; either version 2.1 of the License, or (at
 // your option) any later version.
 
-package openbaudot
+package gobaudot
 
 // Decoder converts a stream of bytes representing baudot codes into a stream
 // of unicode runes.

demodulator.go

@@ -9,7 +9,7 @@
 // the Free Software Foundation; either version 2.1 of the License, or (at
 // your option) any later version.
 
-package openbaudot
+package gobaudot
 
 import (
 	"fmt"
@@ -150,7 +150,7 @@ func (d *Demodulator) run() {
 				// above a minimum threshold it transitions
 				// out of this state.
 
-				if d.dsp.zeroPresent() {
+				if d.dsp.space() {
 					sample = int(float64(d.samplerate) / d.settings.Baud * 1.5)
 					baudot = 0
 					bit = 0
@@ -163,7 +163,7 @@ func (d *Demodulator) run() {
 
 				sample--
 				if sample == 0 {
-					if d.dsp.onePresent() {
+					if d.dsp.mark() {
 						baudot |= (1 << uint(bit))
 					}
 					bit++

dsp.go

@@ -9,7 +9,7 @@
 // the Free Software Foundation; either version 2.1 of the License, or (at
 // your option) any later version.
 
-package openbaudot
+package gobaudot
 
 import "math"
 
@@ -18,58 +18,70 @@ type dsp struct {
 	demTotal  float64 // current energy output value
 	lpfOrder  int     // LPFOrder Low pass filter order
 	minThresh float64 // MinThresh ratio for vaild signal
-	f1        *bandPass
-	f0        *bandPass
-	beta      float64
-	meter0    float64
-	meter1    float64
-	meter2    float64
-
-	carrierDetect bool
-	oneTone       bool
-	zeroTone      bool
-
-	lpfc     *lpf
+
+	meter0 float64
+	meter1 float64
+	meter2 float64
+
+	bpfMark  *bpf // mark bandpass filter
+	bpfSpace *bpf // space bandpass filter
+	lpfDem   *lpf //
 	lpfTotal *lpf
 
 	r float64
 }
 
-func newDsp(oneF, zeroF, sampleRate int) *dsp {
+func newDsp(markF, spaceF, sampleRate int) *dsp {
 
-	lfpOrder := 20
-
-	beta := .95
+	const (
+		lfpOrder  = 20
+		beta      = .95
+		minThresh = 3
+	)
 
 	return &dsp{
-		// demLpfIn:   make([]float64, lfpOrder),
-		// demTotalIn: make([]float64, lfpOrder),
 		lpfOrder:  lfpOrder,
-		minThresh: 3,
-		f1:        newBandPass(oneF, sampleRate, beta),
-		f0:        newBandPass(zeroF, sampleRate, beta),
-		lpfc:      newLpf(lfpOrder),
+		minThresh: minThresh,
+		bpfMark:   newBandPass(markF, sampleRate, beta),
+		bpfSpace:  newBandPass(spaceF, sampleRate, beta),
+		lpfDem:    newLpf(lfpOrder),
 		lpfTotal:  newLpf(lfpOrder),
 	}
 }
+
+func (d *dsp) demod(sam float64) {
+
+	// The demodulator is structured as a pair of band pass filters tuned to
+	// the mark and space frequencies. The output of each is 'rectified' and
+	// combined, and low pass filtered to produce a signal that goes positive
+	// for mark and negative for space.
+	mark := d.bpfMark.update(sam)
+	space := d.bpfSpace.update(sam)
+
+	d.demLpf = d.lpfDem.update(math.Abs(mark) - math.Abs(space))
+
+	d.demTotal = d.lpfTotal.update(math.Abs(sam))
+
+}
+
 func (d *dsp) edgeDetected() bool {
-	return d.demLpf > d.minThresh*d.demTotal
+	return math.Abs(d.demLpf) > d.demTotal*d.minThresh
 }
 
 func (d *dsp) carrier() bool {
-	return d.carrierDetect
+	return math.Abs(d.demLpf) > d.demTotal*d.minThresh
 }
 
 func (d *dsp) level() (float64, float64, float64) {
 	return d.meter0, d.meter1, d.meter2
 }
 
-func (d *dsp) onePresent() bool {
-	return d.oneTone
+func (d *dsp) mark() bool {
+	return d.demLpf > d.minThresh*d.demTotal && math.Abs(d.demLpf) > d.demTotal*d.minThresh
 }
 
-func (d *dsp) zeroPresent() bool {
-	return d.zeroTone
+func (d *dsp) space() bool {
+	return -1*d.demLpf > d.minThresh*d.demTotal && math.Abs(d.demLpf) > d.demTotal*d.minThresh
 }
 
 type lpf struct {
@@ -84,55 +96,32 @@ func newLpf(size int) *lpf {
 }
 
 func (l *lpf) update(v float64) float64 {
-
-	o := l.x[0]
+	l.t -= l.x[0]
+	l.t += v
 	l.x = append(l.x, v)
 	l.x = l.x[1:]
 
-	l.t -= o
-	l.t += v
-
 	return l.t
 }
 
-type bandPass struct {
+type bpf struct {
 	dem0 float64
 	dem1 float64
 	w    float64
 	beta float64
 }
 
-func newBandPass(fc int, fs int, beta float64) *bandPass {
-	f := new(bandPass)
+func newBandPass(fc int, fs int, beta float64) *bpf {
+	f := new(bpf)
 	f.beta = beta
 	f.w = (2 * math.Pi * float64(fc) / float64(fs))
 
-	//	fmt.Println("fc", fc, "fs", fs, f.beta, f.w)
 	return f
 }
 
-func (f *bandPass) update(v float64) float64 {
+func (f *bpf) update(v float64) float64 {
 	n := v + 2.0*math.Cos(f.w)*f.beta*f.dem0 - f.beta*f.beta*f.dem1
 	f.dem1 = f.dem0
 	f.dem0 = n
 	return n
 }
-
-func (d *dsp) demod(sam float64) {
-
-	var one float64
-	one = d.f1.update(sam)
-
-	var zero float64
-	zero = d.f0.update(sam)
-
-	d.demLpf = d.lpfc.update(math.Abs(one) - math.Abs(zero))
-
-	d.demTotal = d.lpfTotal.update(math.Abs(sam))
-
-	d.carrierDetect = math.Abs(d.demLpf) > d.demTotal*d.minThresh
-
-	d.oneTone = d.demLpf > d.minThresh*d.demTotal && d.carrierDetect
-	d.zeroTone = -1*d.demLpf > d.minThresh*d.demTotal && d.carrierDetect
-
-}

encoder.go

@@ -9,7 +9,9 @@
 // the Free Software Foundation; either version 2.1 of the License, or (at
 // your option) any later version.
 
-package openbaudot
+package gobaudot
+
+import "fmt"
 
 // Encoder is fun
 type Encoder struct {
@@ -20,6 +22,8 @@ type Encoder struct {
 	charset         *CodeSet
 	crlfThresh      int // start looking for a space to replace with a crlf at this threshold
 	crlfForceThresh int // force a crlf if it hasn't happend by this threshold
+	shiftThresh     int
+	callback        Callback
 }
 
 // NewEncoder is fun
@@ -30,17 +34,27 @@ func NewEncoder(input chan rune, output chan byte, charset *CodeSet) *Encoder {
 	e.charset = charset
 	e.crlfThresh = 60
 	e.crlfForceThresh = 72
+	e.shiftThresh = 70
 	go e.run()
 	return e
 }
 
 // EncodeString is fun
 func (e *Encoder) EncodeString(s string) {
-	go func() {
-		for _, c := range s {
-			e.input <- c
-		}
-	}()
+	for _, c := range s {
+		e.input <- c
+	}
+
+}
+
+// SetAutoCRLF is fun
+func (e *Encoder) SetAutoCRLF(autoCRLF bool) {
+	e.autoCRLF = autoCRLF
+}
+
+// SetCallback is fun
+func (e *Encoder) SetCallback(callback Callback) {
+	e.callback = callback
 }
 
 func (e *Encoder) run() {
@@ -86,6 +100,7 @@ func (e *Encoder) run() {
 			modCase = c.shift
 
 			/*and update our counter*/
+			fmt.Println("charsWithoutShift", charsWithoutShift)
 			charsWithoutShift = 0
 		}
 
@@ -93,7 +108,7 @@ func (e *Encoder) run() {
 		 * boundry conditions in the protocol*/
 		/* We need to ensure that we re-send the current case character
 		   at least every 72 characters. */
-		if charsWithoutShift > 70 {
+		if charsWithoutShift > e.shiftThresh {
 			if modCase == shiftWhitespace {
 				e.output <- e.charset.unshift() /*doesn't matter which, so how 'bout LETR*/
 			} else if modCase == shiftLetter {
@@ -101,6 +116,8 @@ func (e *Encoder) run() {
 			} else {
 				e.output <- e.charset.shift()
 			}
+			fmt.Println("charsWithoutShift", charsWithoutShift)
+
 			charsWithoutShift = 0
 		}
 

examples/demtest.go

@@ -14,7 +14,7 @@ import (
 // 22050 = 3
 // 11025 = 1
 // 8000 = 1
-func maisn() {
+func main() {
 	// lpf := 100
 	// l := newLpf(lpf)
 	//	for i := 5000; i <= 44100; i += 1000 {

gobaudot_test.go

@@ -0,0 +1,36 @@
+package gobaudot_test
+
+import (
+	"testing"
+
+	"github.com/naleek/openbaudot"
+)
+
+func TestEncoder(t *testing.T) {
+	input := make(chan rune)
+	output := make(chan byte)
+
+	charset := gobaudot.LoadCharset(&gobaudot.USTTY)
+
+	encoder := gobaudot.NewEncoder(input, output, charset)
+
+	go func() {
+		for range output {
+		}
+	}()
+
+	encoder.SetAutoCRLF(false)
+
+	encoder.EncodeString("hello\nworld!")
+	encoder.EncodeString("hello                                                                                                                 ")
+	encoder.EncodeString("hello!oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo")
+	encoder.EncodeString("11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111")
+
+	encoder.SetAutoCRLF(true)
+
+	encoder.EncodeString("hello\rworld!")
+	encoder.EncodeString("hello                                                                                                                 ")
+	encoder.EncodeString("hello!oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo")
+	encoder.EncodeString("11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111")
+
+}

modulator.go

@@ -9,7 +9,7 @@
 // the Free Software Foundation; either version 2.1 of the License, or (at
 // your option) any later version.
 
-package openbaudot
+package gobaudot
 
 import "math"