more ugly dev committing

common.go

@@ -37,6 +37,8 @@ type ModemSettings struct {
 	StopBits   float64
 	DataBits   int
 	SampleRate int
+	OneFreq    int
+	ZeroFreq   int
 }
 
 func multq15(x, y int16) int16 {

demodulator.go

@@ -11,7 +11,10 @@
 
 package openbaudot
 
-import "math"
+import (
+	"fmt"
+	"math"
+)
 
 const (
 	demodStateWaitStart = iota
@@ -28,282 +31,246 @@ const (
 type Demodulator struct {
 	input         chan int16
 	output        chan byte
-	state         int     // current demod state machine state
-	minSigTimeout int     // minimum signal time out counter
-	baud          float64 // demod baud rate
-	bit           int     // current bit being received
-	sample        int     // down counter for sampling instant
-	//	lettersFigures int     // current Letters/Figures mode
-	baudot        byte // demodulator baud rate
+	sigOutput     chan [3]float64
+	minSigTimeout int // minimum signal time out counter
 	samplesPerBit int
 	dsp           *dsp
-	dataBits      int
-	sampleRate    int
+	settings      *ModemSettings
+	sigOut        bool
+	samplerate    int
+	div           int
 	autobaud      struct {
 		enabled  bool    // audio baud detection enable/disable flag
-		state    int     // auto buad detection state mach state
-		zeroX    int     // samples to zero crossing
 		estimate float64 // autobaud estimate
 	}
 }
 
-// NewDemodulator is fun
-func NewDemodulator(s ModemSettings, input chan int16, output chan byte) *Demodulator {
+// NewDumbDemodulator is fun
+func NewDumbDemodulator(s *ModemSettings, input chan int16, sigOutput chan [3]float64) *Demodulator {
 
 	d := new(Demodulator)
 	d.input = input
-	d.output = output
-	d.state = demodStateWaitStart
-	//d.lettersFigures = Letters
-	d.baud = s.Baud
-	d.dataBits = s.DataBits
-	d.sampleRate = s.SampleRate
-	d.samplesPerBit = int(float64(d.sampleRate) / d.baud)
-
-	wOne, wZero := calculateW(2125, 2295, d.sampleRate)
-
-	lfpOrder := 20
-	beta := 0.95 //.95
-
-	d.dsp = &dsp{
-		c1:         int16((2.0 * math.Cos(wOne) * beta) * 32768),
-		c2:         int16(beta * beta * 32768),
-		c3:         int16((2.0 * math.Cos(wZero) * beta) * 32768),
-		demLpfIn:   make([]int16, lfpOrder),
-		demTotalIn: make([]int16, lfpOrder),
-		lpfOrder:   lfpOrder,
-	}
+	d.sigOutput = sigOutput
 
-	d.autobaud.estimate = d.baud
-	if d.autobaud.enabled {
-		d.autobaud.state = autobaudStateWaitStart
-	} else {
-		d.autobaud.state = autobaudStateDisabled
-	}
-	go d.run()
-	return d
+	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.
 
-func (d *Demodulator) run() {
+	centerFrequency := math.Abs(float64(d.settings.OneFreq)+float64(d.settings.ZeroFreq)) / 2 * 3
 
-	var nextState int
-	var edge, dist int
+	d.div = int(math.Floor(float64(d.settings.SampleRate) / float64(centerFrequency)))
+	if d.div == 0 {
+		d.div = 1
+	}
 
-	var demDist75 [2]int // previous 75 baud distance measures
-	var demDist50 [2]int // previous 50 baud distance measures
-	var demDist47 [2]int // previous 47 baud distance measures
-	var demDist45 [2]int // previous 45 baud distance measures
+	d.samplerate = d.settings.SampleRate / d.div
+	//d.div = div
+	d.samplesPerBit = int(float64(d.samplerate) / d.settings.Baud)
+	d.autobaud.enabled = false
 
-	/* main loop, process sample by sample */
+	d.dsp = newDsp(d.settings.OneFreq, d.settings.ZeroFreq, d.samplerate)
 
-	for sam := range d.input {
-		d.dsp.demod(sam)
-
-		nextState = d.state
-
-		switch d.state {
-		case demodStateWaitStart:
-			/*
-			   The demodulator sits in this state when it
-			   is waiting for a start bit.  When a d.sampleRateK
-			   "0" (1800 Hz) start-bit is detected that is
-			   above a minimum threshold it transitions
-			   out of this state.
-			*/
-			if d.dsp.signalPresent() {
-				d.sample = int(float64(d.sampleRate)/d.baud + float64(d.sampleRate)/(2*d.baud))
-				d.baudot = 0
-				d.bit = 0
-				nextState = demodStateSample
-			}
-		case demodStateSample:
+	d.autobaud.estimate = d.settings.Baud
+	d.sigOut = true
 
-			d.sample--
-			if d.sample == 0 {
-				if d.dsp.onePresent() {
-					d.baudot |= (1 << uint(d.bit))
-				}
-				d.bit++
+	go d.run()
+	return d
+}
 
-				if d.bit == d.dataBits {
+// NewDemodulator is fun
+func NewDemodulator(s *ModemSettings, input chan int16, output chan byte) *Demodulator {
 
-					/* complete baudot char has been received */
-					d.output <- d.baudot
-					//fmt.Printf("Demodulator done %d\n", d.baudot)
+	d := new(Demodulator)
+	d.input = input
+	d.output = output
 
-					d.sample = int(float64(d.sampleRate) / d.baud)
-					nextState = demodStateWaitStop
-				} else {
-					/* sample next bit 1 bit-period later */
-					d.sample = int(float64(d.sampleRate) / d.baud)
-				}
-			}
+	d.settings = s
 
-			/* check for d.sampleRateK signal drop out */
+	centerFrequency := math.Abs(float64(d.settings.OneFreq)+float64(d.settings.ZeroFreq)) / 2 * 3
 
-			//return d.demTotal != 0 && d.demLpf < -1*MinThresh*d.demTotal
+	d.div = int(math.Floor(float64(d.settings.SampleRate) / float64(centerFrequency)))
+	if d.div == 0 {
+		d.div = 1
+	}
 
-			if d.dsp.dropout() {
-				d.minSigTimeout++
+	d.samplerate = d.settings.SampleRate / d.div
 
-				/* If signal drops out for approx one bit period
-				   assume we have lost d.sampleRateK signal */
-				if d.minSigTimeout > d.samplesPerBit {
-					nextState = demodStateWaitStart
-				}
-			} else {
-				d.minSigTimeout = 0
-			}
+	d.samplesPerBit = int(float64(d.samplerate) / d.settings.Baud)
+	d.autobaud.enabled = false
 
-		case demodStateWaitStop:
+	d.dsp = newDsp(d.settings.OneFreq, d.settings.ZeroFreq, d.samplerate)
 
-			/* wait until we are in the middle of stop bit */
+	d.autobaud.estimate = d.settings.Baud
+	go d.run()
+	return d
 
-			d.sample--
-			if d.sample == 0 {
-				nextState = demodStateWaitStart
-			}
+}
 
-		}
+func (d *Demodulator) run() {
 
-		d.state = nextState
-
-		/* auto baud detection state machine ----------------------------*/
-
-		/*
-		   Starts a counter at falling edge that marks the
-		   beginning of the start bit.  Measures distance to
-		   next rising edge.  Calculates the distance from
-		   that rising edge to ideal position of the nearest
-		   edge for (i) the 50 baud case and (ii) the 45 baud
-		   case.  This gives us a distance metric for each
-		   possible baud rate.  The distance measure is
-		   smoothed over three samples.  The baud rate with
-		   the smallest distance is chosen as the current baud
-		   rate estimate.
-		*/
-
-		nextState = d.autobaud.state
-
-		switch d.autobaud.state {
-		case autobaudStateWaitStart:
-			/* start bit kicks off this state machine */
-			if d.state == demodStateSample {
-				nextState = autobaudStateWaitZeroX
-				d.autobaud.zeroX = 0
-			}
-		case autobaudStateWaitZeroX:
+	var nextState int
+	var sample int  // down counter for sampling instant
+	var bit int     // current bit being received
+	var baudot byte // received code
+	var zeroX int
+	var remainders map[int]int
+
+	state := demodStateWaitStart // current demod state machine state
+	var autobaudState int
+	if d.autobaud.enabled {
+		autobaudState = autobaudStateWaitStart
+	} else {
+		autobaudState = autobaudStateDisabled
+	}
+	count := 0
+	for sam := range d.input {
+		count++
+		if count%d.div > 0 {
 
-			d.autobaud.zeroX++
+			continue
+		}
+		//	d.dsp.demod(d.l.update(float64(sam)))
+		d.dsp.demod(float64(sam))
+
+		if d.sigOut {
+			m0, m1, m2 := d.dsp.level()
+			d.sigOutput <- [3]float64{m0, m1, m2}
+
+		} else {
+			//fmt.Println(d.dsp.level())
+			nextState = state
+
+			switch state {
+			case demodStateWaitStart:
+				// The demodulator sits in this state when it
+				// is waiting for a start bit.  When a
+				// "0" start-bit is detected that is
+				// above a minimum threshold it transitions
+				// out of this state.
+
+				if d.dsp.zeroPresent() {
+					sample = int(float64(d.samplerate) / d.settings.Baud * 1.5)
+					baudot = 0
+					bit = 0
+					nextState = demodStateSample
+					//	fmt.Println("demodStateSample")
 
-			if d.dsp.edgeDetected() {
-				/* OK, rising edge detected */
+				}
 
-				/* determine distance to closest edge assuming 50 baud */
+			case demodStateSample:
 
-				dist75 := d.sampleRate / 75
-				edge = 0
-				for i := 0; i < (d.dataBits + 1); i++ {
-					dist = absint(edge - d.autobaud.zeroX)
-					if dist < dist75 {
-						dist75 = dist
+				sample--
+				if sample == 0 {
+					if d.dsp.onePresent() {
+						baudot |= (1 << uint(bit))
+					}
+					bit++
+					if bit == d.settings.DataBits {
+
+						/* complete baudot char has been received */
+
+						sample = int(float64(d.samplerate) / d.settings.Baud)
+						nextState = demodStateWaitStop
+						//	fmt.Println("demodStateWaitStop", baudot)
+						d.output <- baudot
+					} else {
+						/* sample next bit 1 bit-period later */
+						sample = int(float64(d.samplerate) / d.settings.Baud)
 					}
-					edge += d.sampleRate / 75
 				}
 
-				/* determine distance to closest edge assuming 50 baud */
+				/* check for d.sampleRateK signal drop out */
 
-				dist50 := d.sampleRate / 50
-				edge = 0
-				for i := 0; i < (d.dataBits + 1); i++ {
-					dist = absint(edge - d.autobaud.zeroX)
-					if dist < dist50 {
-						dist50 = dist
-					}
-					edge += d.sampleRate / 50
-				}
+				if !d.dsp.carrier() {
+					d.minSigTimeout++
 
-				/* determine distance to closest edge assuming 47 baud */
+					/* If signal drops out for approx one bit period
+					   assume we have lost d.sampleRateK signal */
+					if d.minSigTimeout > d.samplesPerBit {
+						nextState = demodStateWaitStart
+						fmt.Println("demodStateWaitStart")
 
-				dist47 := d.sampleRate / 47
-				edge = 0
-				for i := 0; i < (d.dataBits + 1); i++ {
-					dist = absint(edge - d.autobaud.zeroX)
-					if dist < dist47 {
-						dist47 = dist
 					}
-					edge += d.sampleRate / 47
+				} else {
+					d.minSigTimeout = 0
 				}
 
-				/* determine distance to closest edge assuming 45 baud */
+			case demodStateWaitStop:
 
-				dist45 := d.sampleRate / 45
-				edge = 0
-				for i := 0; i < (d.dataBits + 1); i++ {
-					dist = absint(edge - d.autobaud.zeroX)
-					if dist < dist45 {
-						dist45 = dist
-					}
-					edge += d.sampleRate / 45
-				}
+				/* wait until we are in the middle of stop bit */
 
-				/* update 3-point smoothed distance estimates */
+				sample--
+				if sample == 0 {
+					nextState = demodStateWaitStart
+					//fmt.Println("demodStateWaitStart")
+				}
 
-				dist75Smooth := dist75 + demDist75[0] + demDist75[1]
-				demDist75[1] = demDist75[0]
-				demDist75[0] = dist75
+			}
 
-				dist50Smooth := dist50 + demDist50[0] + demDist50[1]
-				demDist50[1] = demDist50[0]
-				demDist50[0] = dist50
+			state = nextState
 
-				dist47Smooth := dist47 + demDist47[0] + demDist47[1]
-				demDist47[1] = demDist47[0]
-				demDist47[0] = dist47
+			// auto baud detection state machine
+			// This deviates quite a bit from the original C implementation.
+			// Starts a counter at falling edge that marks the
+			// beginning of the start bit.  Measures time to
+			// next rising edge.  This time is presumably from
+			// 1 to 6 bit periods long, so the remainder from divinging
+			// the time span by a numbe of bit periods for different baud
+			// rates is accumulated. The baud rate that divides the most
+			// evenly into all measured bit periods is the estimated baud rate.
 
-				dist45Smooth := dist45 + demDist45[0] + demDist45[1]
-				demDist45[1] = demDist45[0]
-				demDist45[0] = dist45
+			nextState = autobaudState
 
-				/* make a decision on baud rate */
+			switch autobaudState {
+			case autobaudStateWaitStart:
+				/* start bit kicks off this state machine */
+				if state == demodStateSample {
+					nextState = autobaudStateWaitZeroX
+					zeroX = 0
+					remainders = map[int]int{45: 0, 47: 0, 50: 0, 75: 0}
 
-				if (dist75Smooth < dist47Smooth) && (dist75Smooth < dist45Smooth) && (dist75Smooth < dist50Smooth) {
-					d.autobaud.estimate = 75
-				}
-				if (dist50Smooth < dist47Smooth) && (dist50Smooth < dist45Smooth) && (dist50Smooth < dist75Smooth) {
-					d.autobaud.estimate = 50
-				}
-				if (dist47Smooth < dist50Smooth) && (dist47Smooth < dist45Smooth) && (dist47Smooth < dist75Smooth) {
-					d.autobaud.estimate = 47
-				}
-				if (dist45Smooth < dist50Smooth) && (dist45Smooth < dist47Smooth) && (dist45Smooth < dist75Smooth) {
-					d.autobaud.estimate = 45
 				}
+			case autobaudStateWaitZeroX:
 
-				//printf("obl.autobaud_zerox: %d dist50: %02d dist47: %02d dist45: %02d est: %d\n",
-				//       obl.autobaud_zerox, dist50Smooth, dist47Smooth, dist45Smooth, obl.dem_baud_est);
-				nextState = autobaudStateWaitStop
-			}
+				zeroX++
 
-			/* reset autobaud state machine, e.g. if d.sampleRateK drops out before
-			   we get a zero crossing */
+				if d.dsp.edgeDetected() {
 
-			if d.state != demodStateSample {
-				nextState = autobaudStateWaitStop
-			}
+					estimate := 45 // pick one as a starting point
+					minRemainder := remainders[estimate]
 
-		case autobaudStateWaitStop:
-			if d.state == demodStateWaitStop {
-				nextState = autobaudStateWaitStart
-			}
+					for b, t := range remainders {
+						q := t + (zeroX % (d.samplerate / b))
+						remainders[b] = q
+						if q < minRemainder {
+							minRemainder = q
+							estimate = b
+						}
+					}
+
+					d.autobaud.estimate = float64(estimate)
+					nextState = autobaudStateWaitStop
+				}
+
+				// reset autobaud state machine, e.g. if signal drops out before
+				// we get a zero crossing
 
-		case autobaudStateDisabled:
+				if state != demodStateSample {
+					nextState = autobaudStateWaitStop
+				}
+
+			case autobaudStateWaitStop:
+				if state == demodStateWaitStop {
+					nextState = autobaudStateWaitStart
+				}
 
-		default:
+			case autobaudStateDisabled:
 
+			}
+			autobaudState = nextState
 		}
-		d.autobaud.state = nextState
 	}
 
 }

dsp.go

@@ -11,67 +11,128 @@
 
 package openbaudot
 
+import "math"
+
 type dsp struct {
-	demOne      [2]float64 // previous 2 output samples of one filter
-	demOneQ0    [2]int16   // previous 2 output samples of one filter
-	demZero     [2]float64 // previous 2 output samples of zero filter
-	demZeroQ0   [2]int16   // previous 2 output samples of one filter
-	demLpfIn    []int16    // previous LPFOrder LPF input samples
-	pdemLpfIn   int        // ptr to oldest LPF input sample
-	demLpf      int        // current LPF output value
-	demTotalIn  []int16    // previous LPFOrder energy input samples
-	pdemTotalIn int        // ptr to oldest energy sample
-	demTotal    int        // current energy output value
-	c1, c2, c3  int16      // precomputed values for demod_dsp
-	lpfOrder    int        // LPFOrder Low pass filter order
-	minThresh   int        // MinThresh ratio for vaild signal
+	demLpf    float64 // current LPF output value
+	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
+	lpfTotal *lpf
+
+	r float64
 }
 
+func newDsp(oneF, zeroF, sampleRate int) *dsp {
+
+	lfpOrder := 20
+
+	beta := .95
+
+	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),
+		lpfTotal:  newLpf(lfpOrder),
+	}
+}
 func (d *dsp) edgeDetected() bool {
 	return d.demLpf > d.minThresh*d.demTotal
 }
 
-func (d *dsp) dropout() bool {
-	return absint(d.demLpf) < d.minThresh*d.demTotal || d.demTotal == 0
+func (d *dsp) carrier() bool {
+	return d.carrierDetect
 }
 
-func (d *dsp) signalPresent() bool {
-	return d.demTotal != 0 && d.demLpf < -1*d.minThresh*d.demTotal
+func (d *dsp) level() (float64, float64, float64) {
+	return d.meter0, d.meter1, d.meter2
 }
 
 func (d *dsp) onePresent() bool {
-	return d.demLpf > 0
+	return d.oneTone
 }
 
-func (d *dsp) demod(sam int16) { //short *buffer, int samples)
-
-	sam >>= 5
-
-	oneQ0 := sam
-	oneQ0 += multq15(d.c1, d.demOneQ0[0])
-	oneQ0 -= multq15(d.c2, d.demOneQ0[1])
-	d.demOneQ0[1] = d.demOneQ0[0]
-	d.demOneQ0[0] = oneQ0
-
-	zeroQ0 := sam
-	zeroQ0 += multq15(d.c3, d.demZeroQ0[0])
-	zeroQ0 -= multq15(d.c2, d.demZeroQ0[1])
-	d.demZeroQ0[1] = d.demZeroQ0[0]
-	d.demZeroQ0[0] = zeroQ0
-
-	x := abs16(oneQ0) - abs16(zeroQ0)
-	d.demLpf -= int(d.demLpfIn[d.pdemLpfIn])
-	d.demLpf += int(x)
-	d.demLpfIn[d.pdemLpfIn] = x
-	d.pdemLpfIn = (d.pdemLpfIn + 1) % d.lpfOrder
-
-	/* now work out total energy estimate, this is used to
-	   determine if a valid signal is present by comparing
-	   the modem tone to total energy ratio */
-
-	x = abs16(sam)
-	d.demTotal -= int(d.demTotalIn[d.pdemTotalIn])
-	d.demTotal += int(x)
-	d.demTotalIn[d.pdemTotalIn] = x
-	d.pdemTotalIn = (d.pdemTotalIn + 1) % d.lpfOrder
+func (d *dsp) zeroPresent() bool {
+	return d.zeroTone
+}
+
+type lpf struct {
+	x []float64
+	t float64
+}
+
+func newLpf(size int) *lpf {
+	l := new(lpf)
+	l.x = make([]float64, size)
+	return l
+}
+
+func (l *lpf) update(v float64) float64 {
+
+	o := l.x[0]
+	l.x = append(l.x, v)
+	l.x = l.x[1:]
+
+	l.t -= o
+	l.t += v
+
+	return l.t
+}
+
+type bandPass struct {
+	dem0 float64
+	dem1 float64
+	w    float64
+	beta float64
+}
+
+func newBandPass(fc int, fs int, beta float64) *bandPass {
+	f := new(bandPass)
+	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 {
+	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
+
 }

examples/audioin/main.go

@@ -0,0 +1,118 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/gordonklaus/portaudio"
+	"github.com/naleek/openbaudot"
+)
+
+func main() {
+
+	s := &openbaudot.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()
+	charset := openbaudot.LoadCharset(&openbaudot.USTTY)
+	//
+	// encoderIn := make(chan rune)
+	// modulatorIn := make(chan byte)
+
+	demodulatorIn := make(chan int16)
+	decoderIn := make(chan byte)
+	decoderOut := make(chan rune)
+
+	//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)
+
+	go func() {
+		for {
+			r := <-decoderOut
+			fmt.Printf("%c", r)
+		}
+	}()
+
+	stream.Start()
+	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{}{}
+	// }()
+
+}
+
+// // 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/demtest.go

@@ -0,0 +1,145 @@
+package main
+
+import (
+	"fmt"
+	"math"
+	"math/rand"
+
+	"github.com/naleek/openbaudot"
+)
+
+// 96000 = 14
+// 48000 = 7
+// 44100 = 7
+// 22050 = 3
+// 11025 = 1
+// 8000 = 1
+func maisn() {
+	// lpf := 100
+	// l := newLpf(lpf)
+	//	for i := 5000; i <= 44100; i += 1000 {
+	// l.update(dostuff(11025))
+	//	dostuff(11025)
+	dostuff(8000)
+	// dostuff(11025)
+	// dostuff(22050)
+	// dostuff(44100)
+	// dostuff(48000)
+	// dostuff(96000)
+
+	// 	fmt.Printf("%d\t%f\n", i-lpf/2, v)
+	//}
+}
+func dostuff(freq int) float64 {
+
+	done := make(chan bool)
+
+	s := &openbaudot.ModemSettings{
+		Baud:       45,
+		StopBits:   2,
+		DataBits:   5,
+		SampleRate: freq,
+		OneFreq:    2125,
+		ZeroFreq:   2295,
+	}
+
+	demodulatorIn := make(chan int16)
+	demodulatorOut := make(chan [3]float64)
+
+	go func() {
+
+		// pulse
+		// for i := 0; i <= 200; i++ {
+		// 	if i == 50 {
+		// 		demodulatorIn <- int16(16384)
+		// 	} else {
+		// 		demodulatorIn <- int16(0)
+		// 	}
+		// }
+		//
+		// for samp := 0; samp <= s.SampleRate/45; samp++ {
+		// 	phase := 2 * math.Pi * float64(samp) / float64(s.SampleRate) * 2125 * 2
+		// 	demodulatorIn <- int16(math.Sin(phase) * 16384)
+		// }
+		// //	noise
+		for i := 0; i <= s.SampleRate/4; i++ {
+			n := rand.Float64()
+			demodulatorIn <- int16(n * 16384)
+		}
+		for x := 0; x <= 5; x++ {
+			for samp := 0; samp <= s.SampleRate/45; samp++ {
+				phase := 2 * math.Pi * float64(samp) / float64(s.SampleRate) * float64(s.OneFreq)
+				n := rand.Float64()
+				demodulatorIn <- int16((math.Sin(phase) + n) * 16384)
+			}
+
+			for samp := 0; samp <= s.SampleRate/45; samp++ {
+				phase := 2 * math.Pi * float64(samp) / float64(s.SampleRate) * float64(s.ZeroFreq)
+				n := rand.Float64()
+				demodulatorIn <- int16((math.Sin(phase) + n) * 16384)
+			}
+		}
+
+		//
+		// for samp := 0; samp <= s.SampleRate/1; samp++ {
+		// 	phase := 2 * math.Pi * float64(samp) / float64(s.SampleRate) * float64(s.ZeroFreq)
+		// 	demodulatorIn <- int16(math.Sin(phase) * 16384)
+		// }
+		// for samp := 0; samp <= s.SampleRate/40; samp++ {
+		// 	phase := 2 * math.Pi * float64(samp) / float64(s.SampleRate) * float64(s.OneFreq)
+		// 	demodulatorIn <- int16(math.Sin(phase) * 16384)
+		// }
+		//
+		// for samp := 0; samp <= s.SampleRate/40; samp++ {
+		// 	phase := 2 * math.Pi * float64(samp) / float64(s.SampleRate) * float64(s.ZeroFreq)
+		// 	demodulatorIn <- int16(math.Sin(phase) * 16384)
+		// }
+		// for samp := 0; samp <= s.SampleRate/10; samp++ {
+		// 	phase := 2 * math.Pi * float64(samp) / float64(s.SampleRate) * float64(s.ZeroFreq)
+		// 	demodulatorIn <- int16(math.Sin(phase) * 16384)
+		// }
+
+		done <- true
+	}()
+
+	openbaudot.NewDumbDemodulator(s, demodulatorIn, demodulatorOut)
+	c := 0
+	running := true
+	var r float64
+	for running {
+		select {
+		case v := <-demodulatorOut:
+			fmt.Printf("%f\t%f\t%f\n", v[0], v[1], v[2])
+			r = v[0]
+
+			c++
+		case <-done:
+
+			running = false
+		}
+	}
+	return r
+}
+
+type lpf struct {
+	x []float64
+	t float64
+}
+
+func newLpf(size int) *lpf {
+	l := new(lpf)
+	l.x = make([]float64, size)
+	return l
+}
+
+func (l *lpf) update(v float64) float64 {
+
+	o := l.x[0]
+	l.x = append(l.x, v)
+	l.x = l.x[1:]
+
+	l.t -= o
+	l.t += v
+
+	return l.t
+}

examples/main.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"fmt"
+	"time"
 
 	"github.com/naleek/openbaudot"
 )
@@ -21,67 +22,34 @@ func main() {
 
 	encoderIn := make(chan rune)
 	modulatorIn := make(chan byte)
-	modulatorOut := make(chan int16)
 
-	// demodulatorIn := make(chan int16)
-	// decoderIn := make(chan byte)
-	// decoderOut := make(chan rune)
+	demodulatorIn := make(chan int16)
+	decoderIn := make(chan byte)
+	decoderOut := make(chan rune)
 
-	//done := make(chan struct{})
+	done := make(chan struct{})
 
-	sig := make(chan int)
+	//sig := make(chan [2]float64)
 	encoder := openbaudot.NewEncoder(encoderIn, modulatorIn, charset)
-	openbaudot.NewModulator(s, modulatorIn, modulatorOut)
-	openbaudot.NewDumbDemodulator(s, modulatorOut, sig)
-
-	// go func() {
-	// 	for b := range modulatorOut {
-	// 		demodulatorIn <- b
-	// 		time.Sleep(125 * time.Microsecond)
-	// 	}
-	// }()
-
-	// callback := func(event int, data interface{}) {
-	// 	switch event {
-	// 	case openbaudot.EventIdle:
-	// 		//fmt.Println("EventIdle")
-	// 		encoder.EncodeString("r")
-	//
-	// 	}
-	//
-	// }
-	go encoder.EncodeString("ry")
-	c := 0
-	for b := range sig {
-
-		fmt.Println(b)
-		if c == s.SampleRate {
-			break
+	openbaudot.NewModulator(s, modulatorIn, demodulatorIn)
+	openbaudot.NewDemodulator(s, demodulatorIn, decoderIn)
+	openbaudot.NewDecoder(decoderIn, decoderOut, charset)
+
+	go func() {
+		encoder.EncodeString("hello world")
+		time.Sleep(2000 * time.Millisecond)
+		done <- struct{}{}
+	}()
+
+	running := true
+	for running {
+		select {
+		case r := <-decoderOut:
+			fmt.Printf("%c", r)
+		case <-done:
+			running = false
 		}
-		c++
 	}
-
-	// modulator.SetCallback(callback)
-
-	// go func() {
-	// 	for b := range modulatorOut {
-	// 		demodulatorIn <- b
-	// 		time.Sleep(125 * time.Microsecond)
-	// 	}
-	// }()
-
-	// openbaudot.NewDemodulator(s, demodulatorIn, decoderIn)
-	// openbaudot.NewDecoder(decoderIn, decoderOut, charset)
-	//
-	// running := true
-	// for running {
-	// 	select {
-	// 	case r := <-decoderOut:
-	// 		fmt.Printf("%c", r)
-	// 	case <-done:
-	// 		running = false
-	// 	}
-	// }
 }
 
 // // NewOBL is fun

modulator.go

@@ -26,8 +26,8 @@ type Modulator struct {
 	input  chan byte
 	output chan int16
 
-	baud            float64 // modulator baud rate
-	dataBits        int
+	settings *ModemSettings
+
 	samplesPerBit   int     // number of samples for one bit
 	phaseQ16        uint16  // phase acc 0..2math.Pi -> 0..65536
 	amplitude       int16   // peak modulator amplitude for one tone
@@ -36,29 +36,25 @@ type Modulator struct {
 	wOneQ16         uint16  // scaled one freq 0..2math.Pi -> 0..65536
 	wZeroQ16        uint16  // scaled zero freq 0..2math.Pi -> 0..65536
 	sinLutQ15       []int16 // sine lookup table
-	sampleRate      int     // sample rate
 	callback        Callback
 }
 
 // NewModulator is fun
-func NewModulator(s ModemSettings, input chan byte, output chan int16) *Modulator {
+func NewModulator(s *ModemSettings, input chan byte, output chan int16) *Modulator {
 
 	m := new(Modulator)
-	// mod.input = make(chan code)
-	// mod.output = make(chan int16)
 
 	m.input = input
 	m.output = output
 
-	m.baud = s.Baud
-	m.dataBits = s.DataBits
-	m.sampleRate = s.SampleRate
-	m.samplesPerBit = int(float64(m.sampleRate) / m.baud)
-	m.numStopHalfBits = int(math.Floor(s.StopBits / .5))
+	m.settings = s
+
+	m.samplesPerBit = int(float64(m.settings.SampleRate) / m.settings.Baud)
+	m.numStopHalfBits = int(math.Floor(m.settings.StopBits / .5))
 	m.numStopSamples = m.numStopHalfBits * m.samplesPerBit / 2
 	m.amplitude = 16384
 
-	wOne, wZero := calculateW(2125, 2295, m.sampleRate)
+	wOne, wZero := calculateW(m.settings.OneFreq, m.settings.ZeroFreq, m.settings.SampleRate)
 
 	m.wOneQ16 = uint16((65536 / (2.0 * math.Pi)) * wOne)
 	m.wZeroQ16 = uint16((65536 / (2.0 * math.Pi)) * wZero)
@@ -114,14 +110,15 @@ func (m *Modulator) run() {
 			case c = <-m.input:
 				modSample = 0
 				nextState = modStateStart
+				//fmt.Println("modStateStart")
 				//obl.callback(EventTransmitState, TransmitStart)
 				idleSamples = 0
 			default:
-				m.modulate(0)
+				m.modulate(1)
 
-				if idleSamples < m.sampleRate {
+				if idleSamples < m.settings.SampleRate {
 					idleSamples++
-				} else if idleSamples == m.sampleRate {
+				} else if idleSamples == m.settings.SampleRate {
 					if m.callback != nil {
 						m.callback(EventIdle, 0)
 					}
@@ -137,6 +134,8 @@ func (m *Modulator) run() {
 				modBit = int(c & 0x1)
 				modSample = 0
 				nextState = modStateBit
+				//fmt.Println("modStateBit")
+
 			}
 		case modStateBit:
 			m.modulate(modBit)
@@ -146,8 +145,10 @@ func (m *Modulator) run() {
 				modSample = 0
 				modNbit++
 				modBit = int((c >> uint(modNbit)) & 0x1)
-				if modNbit == m.dataBits {
+				if modNbit == m.settings.DataBits {
 					nextState = modStateStop
+					//	fmt.Println("modStateStop")
+
 				}
 			}
 		case modStateStop: