cleanup

code.go

+// 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 openbaudot
 
 import "unicode"
 
-/*
- * OBL openbaudot Library
- *
- * 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 software was developed with support from the National Institute on
- * Disability and Rehabilitation Research, US Dept of Education under Grant
- * # H133E990006 and H133E040014
- *
- * 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.
- *
- * This library is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this library; if not, write to the Free Software Foundation,
- * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- *
- * Please send a copy of any improved versions of the library to:
- * Jeff Knighton, Voiceriver Inc, jeff.knighton@voiceriver.com
- * Gunnar Hellstrom, Omnitor AB, Box 92054, 12006 Stockholm, SWEDEN
- * Gregg Vanderheiden, Trace Center, U of Wisconsin, Madison, Wi 53706
- *
- * file...: obl.go
- * original author.: Keelan Lightfoot
- * Created: 20 May 2017
- *
- */
-
 const (
 	shiftUnknown = iota
 	shiftLetter

common.go

+// 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 openbaudot provides a set of tools to encode, modulate, demodulate and
+// baudot/TTY/RTTY data streams
 package openbaudot
 
 import "math"
 
-/*
- * OBL openbaudot Library
- *
- * 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 software was developed with support from the National Institute on
- * Disability and Rehabilitation Research, US Dept of Education under Grant
- * # H133E990006 and H133E040014
- *
- * 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.
- *
- * This library is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this library; if not, write to the Free Software Foundation,
- * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- *
- * Please send a copy of any improved versions of the library to:
- * Jeff Knighton, Voiceriver Inc, jeff.knighton@voiceriver.com
- * Gunnar Hellstrom, Omnitor AB, Box 92054, 12006 Stockholm, SWEDEN
- * Gregg Vanderheiden, Trace Center, U of Wisconsin, Madison, Wi 53706
- *
- * file...: obl.go
- * original author.: Keelan Lightfoot
- * Created: 20 May 2017
- *
- */
-
 const (
-
-	// LETR  Letters Baudot code
-	LETR byte = 0x1f
-	// FIGR Figures Baudot code
-	FIGR byte = 0x1b
-	// CRLFThresh start looking for space
-	CRLFThresh = 60
-	// CRLFForce force CR-LF
-	CRLFForce = 72
-
-	// ModStateIdle no data in mod buffer, idling
-	ModStateIdle = 0
-	// ModStateStart modulating start bit
-	ModStateStart = 1
-	// ModStateBit modulating a baudot bit
-	ModStateBit = 2
-	// ModStateStop modulating stop bit
-	ModStateStop = 3
-	// ModStateHold modulating hold tone
-	ModStateHold = 4
-
-	// LPFOrder Low pass filter order
-	LPFOrder = 20 // 20
-
-	/* oblDemodulate() state machine states */
-
-	// DemodStateWaitStart wait for start bit
-	DemodStateWaitStart = 0 /**/
-	// DemodStateSample sampling demod bits
-	DemodStateSample = 1 /**/
-	// DemodStateWaitStop wait for stop bit
-	DemodStateWaitStop = 2 /**/
-
-	// MinThresh ratio for vaild signal
-	MinThresh = 3
-
-	/* auto baud detection state machine states */
-
-	// AutobaudStateWaitStart waiting for start bit
-	AutobaudStateWaitStart = 0
-	// AutobaudStateWaitZeroX waiting for zero crossing
-	AutobaudStateWaitZeroX = 1
-	// AutobaudStateWaitStop waiting for stop bit
-	AutobaudStateWaitStop = 2
-	// AutobaudStateDisabled disabled
-	AutobaudStateDisabled = 3
-
-	/* top level state machines states */
-
 	// EventDemodChar is fun
 	EventDemodChar = iota
 	// EventDemodAbort is fun
 	EventIdle
 )
 
-/* precomputed constants for demodDsp */
+// Callback is func
+type Callback func(event int, data interface{})
 
-var (
-	// sampleRate Sample rate
-	sampleRate = 8000
-	// Beta filter bandwidth factor
-	Beta = 0.95 //.95
-)
+// ModemSettings is fun
+type ModemSettings struct {
+	Baud       float64
+	StopBits   float64
+	DataBits   int
+	SampleRate int
+}
 
-func multq(x, y int16) int16 {
+func multq15(x, y int16) int16 {
 	return int16((int(x) * int(y)) >> 15)
-
 }
 
-// abs16 returns the absolute value of x.
 func abs16(x int16) int16 {
 	if x < 0 {
 		return -x
 	return x
 }
 
-// absint returns the absolute value of x.
 func absint(x int) int {
 	if x < 0 {
 		return -x
 	return x
 }
 
-func calculateW(oneF int, zeroF int) (float64, float64) {
+func calculateW(oneF int, zeroF int, sampleRate int) (float64, float64) {
 	wOne := (2 * math.Pi * float64(oneF) / float64(sampleRate))   //1400 // WOne 1 freq in normalised rads
 	wZero := (2 * math.Pi * float64(zeroF) / float64(sampleRate)) //1800 // WZero 0 freq in normazlised rads
 	return wOne, wZero
 }
-
-// Callback is func
-type Callback func(event int, data interface{})

decoder.go

-package openbaudot
+// 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.
 
-/*
- * OBL openbaudot Library
- *
- * 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 software was developed with support from the National Institute on
- * Disability and Rehabilitation Research, US Dept of Education under Grant
- * # H133E990006 and H133E040014
- *
- * 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.
- *
- * This library is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this library; if not, write to the Free Software Foundation,
- * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- *
- * Please send a copy of any improved versions of the library to:
- * Jeff Knighton, Voiceriver Inc, jeff.knighton@voiceriver.com
- * Gunnar Hellstrom, Omnitor AB, Box 92054, 12006 Stockholm, SWEDEN
- * Gregg Vanderheiden, Trace Center, U of Wisconsin, Madison, Wi 53706
- *
- * file...: obl.go
- * original author.: Keelan Lightfoot
- * Created: 20 May 2017
- *
- */
+package openbaudot
 
-// Decoder is fun
+// Decoder converts a stream of bytes representing baudot codes into a stream
+// of unicode runes.
 type Decoder struct {
 	input   chan byte
 	output  chan rune
 	charset *CodeSet
 }
 
-// NewDecoder is fun
+// NewDecoder creates a new decoder.
 func NewDecoder(input chan byte, output chan rune, charset *CodeSet) *Decoder {
 	d := new(Decoder)
 	d.input = input
 	shift := shiftLetter
 	for c := range d.input {
 		switch c {
-		case LETR:
+		case d.charset.UnshiftCode:
 			shift = shiftLetter
 			//obl.callback(EventDemodCase, Letters)
-		case FIGR:
+		case d.charset.ShiftCode:
 			shift = shiftFigure
 		//	obl.callback(EventDemodCase, Figures)
 		default:

demodulator.go

+// 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 openbaudot
 
 import "math"
 
-/*
- * OBL openbaudot Library
- *
- * 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 software was developed with support from the National Institute on
- * Disability and Rehabilitation Research, US Dept of Education under Grant
- * # H133E990006 and H133E040014
- *
- * 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.
- *
- * This library is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this library; if not, write to the Free Software Foundation,
- * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- *
- * Please send a copy of any improved versions of the library to:
- * Jeff Knighton, Voiceriver Inc, jeff.knighton@voiceriver.com
- * Gunnar Hellstrom, Omnitor AB, Box 92054, 12006 Stockholm, SWEDEN
- * Gregg Vanderheiden, Trace Center, U of Wisconsin, Madison, Wi 53706
- *
- * file...: obl.go
- * original author.: Keelan Lightfoot
- * Created: 20 May 2017
- *
- */
+const (
+	demodStateWaitStart = iota
+	demodStateSample
+	demodStateWaitStop
+
+	autobaudStateWaitStart = iota
+	autobaudStateWaitZeroX
+	autobaudStateWaitStop
+	autobaudStateDisabled
+)
 
 // Demodulator is fun
 type Demodulator struct {
 	samplesPerBit int
 	dsp           *dsp
 	dataBits      int
+	sampleRate    int
 	autobaud      struct {
 		enabled  bool    // audio baud detection enable/disable flag
 		state    int     // auto buad detection state mach state
 }
 
 // NewDemodulator is fun
-func NewDemodulator(baud float64, stopBits float64, dataBits int, input chan int16, output chan byte) *Demodulator {
+func NewDemodulator(s ModemSettings, input chan int16, output chan byte) *Demodulator {
 
 	d := new(Demodulator)
 	d.input = input
 	d.output = output
-	d.state = DemodStateWaitStart
+	d.state = demodStateWaitStart
 	//d.lettersFigures = Letters
-	d.baud = baud
-	d.dataBits = dataBits
-	d.samplesPerBit = int(float64(sampleRate) / d.baud)
+	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)
 
-	wOne, wZero := calculateW(2125, 2295)
+	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),
+		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.autobaud.estimate = d.baud
 	if d.autobaud.enabled {
-		d.autobaud.state = AutobaudStateWaitStart
+		d.autobaud.state = autobaudStateWaitStart
 	} else {
-		d.autobaud.state = AutobaudStateDisabled
+		d.autobaud.state = autobaudStateDisabled
 	}
 	go d.run()
 	return d
 		nextState = d.state
 
 		switch d.state {
-		case DemodStateWaitStart:
+		case demodStateWaitStart:
 			/*
 			   The demodulator sits in this state when it
-			   is waiting for a start bit.  When a sampleRateK
+			   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(sampleRate)/d.baud + float64(sampleRate)/(2*d.baud))
+				d.sample = int(float64(d.sampleRate)/d.baud + float64(d.sampleRate)/(2*d.baud))
 				d.baudot = 0
 				d.bit = 0
-				nextState = DemodStateSample
+				nextState = demodStateSample
 			}
-		case DemodStateSample:
+		case demodStateSample:
 
 			d.sample--
 			if d.sample == 0 {
 					d.output <- d.baudot
 					//fmt.Printf("Demodulator done %d\n", d.baudot)
 
-					d.sample = int(float64(sampleRate) / d.baud)
-					nextState = DemodStateWaitStop
+					d.sample = int(float64(d.sampleRate) / d.baud)
+					nextState = demodStateWaitStop
 				} else {
 					/* sample next bit 1 bit-period later */
-					d.sample = int(float64(sampleRate) / d.baud)
+					d.sample = int(float64(d.sampleRate) / d.baud)
 				}
 			}
 
-			/* check for sampleRateK signal drop out */
+			/* check for d.sampleRateK signal drop out */
 
 			//return d.demTotal != 0 && d.demLpf < -1*MinThresh*d.demTotal
 
 				d.minSigTimeout++
 
 				/* If signal drops out for approx one bit period
-				   assume we have lost sampleRateK signal */
+				   assume we have lost d.sampleRateK signal */
 				if d.minSigTimeout > d.samplesPerBit {
-					nextState = DemodStateWaitStart
+					nextState = demodStateWaitStart
 				}
 			} else {
 				d.minSigTimeout = 0
 			}
 
-		case DemodStateWaitStop:
+		case demodStateWaitStop:
 
 			/* wait until we are in the middle of stop bit */
 
 			d.sample--
 			if d.sample == 0 {
-				nextState = DemodStateWaitStart
+				nextState = demodStateWaitStart
 			}
 
 		}
 		nextState = d.autobaud.state
 
 		switch d.autobaud.state {
-		case AutobaudStateWaitStart:
+		case autobaudStateWaitStart:
 			/* start bit kicks off this state machine */
-			if d.state == DemodStateSample {
-				nextState = AutobaudStateWaitZeroX
+			if d.state == demodStateSample {
+				nextState = autobaudStateWaitZeroX
 				d.autobaud.zeroX = 0
 			}
-		case AutobaudStateWaitZeroX:
+		case autobaudStateWaitZeroX:
 
 			d.autobaud.zeroX++
 
 
 				/* determine distance to closest edge assuming 50 baud */
 
-				dist75 := sampleRate / 75
+				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
 					}
-					edge += sampleRate / 75
+					edge += d.sampleRate / 75
 				}
 
 				/* determine distance to closest edge assuming 50 baud */
 
-				dist50 := sampleRate / 50
+				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 += sampleRate / 50
+					edge += d.sampleRate / 50
 				}
 
 				/* determine distance to closest edge assuming 47 baud */
 
-				dist47 := sampleRate / 47
+				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 += sampleRate / 47
+					edge += d.sampleRate / 47
 				}
 
 				/* determine distance to closest edge assuming 45 baud */
 
-				dist45 := sampleRate / 45
+				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 += sampleRate / 45
+					edge += d.sampleRate / 45
 				}
 
 				/* update 3-point smoothed distance estimates */
 
 				//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
+				nextState = autobaudStateWaitStop
 			}
 
-			/* reset autobaud state machine, e.g. if sampleRateK drops out before
+			/* reset autobaud state machine, e.g. if d.sampleRateK drops out before
 			   we get a zero crossing */
 
-			if d.state != DemodStateSample {
-				nextState = AutobaudStateWaitStop
+			if d.state != demodStateSample {
+				nextState = autobaudStateWaitStop
 			}
 
-		case AutobaudStateWaitStop:
-			if d.state == DemodStateWaitStop {
-				nextState = AutobaudStateWaitStart
+		case autobaudStateWaitStop:
+			if d.state == demodStateWaitStop {
+				nextState = autobaudStateWaitStart
 			}
 
-		case AutobaudStateDisabled:
+		case autobaudStateDisabled:
 
 		default:
 

dsp.go

-package openbaudot
+// 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.
 
-/*
- * OBL openbaudot Library
- *
- * 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 software was developed with support from the National Institute on
- * Disability and Rehabilitation Research, US Dept of Education under Grant
- * # H133E990006 and H133E040014
- *
- * 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.
- *
- * This library is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this library; if not, write to the Free Software Foundation,
- * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- *
- * Please send a copy of any improved versions of the library to:
- * Jeff Knighton, Voiceriver Inc, jeff.knighton@voiceriver.com
- * Gunnar Hellstrom, Omnitor AB, Box 92054, 12006 Stockholm, SWEDEN
- * Gregg Vanderheiden, Trace Center, U of Wisconsin, Madison, Wi 53706
- *
- * file...: obl.go
- * original author.: Keelan Lightfoot
- * Created: 20 May 2017
- *
- */
+package openbaudot
 
 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    [LPFOrder]int16 // previous LPFOrder LPF input samples
-	pdemLpfIn   int             // ptr to oldest LPF input sample
-	demLpf      int             // current LPF output value
-	demTotalIn  [LPFOrder]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
-
+	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
 }
 
 func (d *dsp) edgeDetected() bool {
-	return d.demLpf > MinThresh*d.demTotal
+	return d.demLpf > d.minThresh*d.demTotal
 }
 
 func (d *dsp) dropout() bool {
-	return absint(d.demLpf) < MinThresh*d.demTotal || d.demTotal == 0
+	return absint(d.demLpf) < d.minThresh*d.demTotal || d.demTotal == 0
 }
 
 func (d *dsp) signalPresent() bool {
-	return d.demTotal != 0 && d.demLpf < -1*MinThresh*d.demTotal
+	return d.demTotal != 0 && d.demLpf < -1*d.minThresh*d.demTotal
 }
 
 func (d *dsp) onePresent() bool {
 	sam >>= 5
 
 	oneQ0 := sam
-	oneQ0 += multq(d.c1, d.demOneQ0[0])
-	oneQ0 -= multq(d.c2, d.demOneQ0[1])
+	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 += multq(d.c3, d.demZeroQ0[0])
-	zeroQ0 -= multq(d.c2, d.demZeroQ0[1])
+	zeroQ0 += multq15(d.c3, d.demZeroQ0[0])
+	zeroQ0 -= multq15(d.c2, d.demZeroQ0[1])
 	d.demZeroQ0[1] = d.demZeroQ0[0]
 	d.demZeroQ0[0] = zeroQ0
 
 	d.demLpf -= int(d.demLpfIn[d.pdemLpfIn])
 	d.demLpf += int(x)
 	d.demLpfIn[d.pdemLpfIn] = x
-	d.pdemLpfIn = (d.pdemLpfIn + 1) % LPFOrder
+	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
 	d.demTotal -= int(d.demTotalIn[d.pdemTotalIn])
 	d.demTotal += int(x)
 	d.demTotalIn[d.pdemTotalIn] = x
-	d.pdemTotalIn = (d.pdemTotalIn + 1) % LPFOrder
+	d.pdemTotalIn = (d.pdemTotalIn + 1) % d.lpfOrder
 }

encoder.go

-package openbaudot
+// 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.
 
-/*
- * OBL openbaudot Library
- *
- * 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 software was developed with support from the National Institute on
- * Disability and Rehabilitation Research, US Dept of Education under Grant
- * # H133E990006 and H133E040014
- *
- * 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.
- *
- * This library is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this library; if not, write to the Free Software Foundation,
- * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- *
- * Please send a copy of any improved versions of the library to:
- * Jeff Knighton, Voiceriver Inc, jeff.knighton@voiceriver.com
- * Gunnar Hellstrom, Omnitor AB, Box 92054, 12006 Stockholm, SWEDEN
- * Gregg Vanderheiden, Trace Center, U of Wisconsin, Madison, Wi 53706
- *
- * file...: obl.go
- * original author.: Keelan Lightfoot
- * Created: 20 May 2017
- *
- */
+package openbaudot
 
 // Encoder is fun
 type Encoder struct {
-	input    chan rune
-	output   chan byte
-	autoWrap bool // true for auto CRLF mode
-	autoCRLF bool
-	charset  *CodeSet
+	input           chan rune
+	output          chan byte
+	autoWrap        bool // true for auto CRLF mode
+	autoCRLF        bool
+	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
 }
 
 // NewEncoder is fun
 	e.input = input
 	e.output = output
 	e.charset = charset
-
+	e.crlfThresh = 60
+	e.crlfForceThresh = 72
 	go e.run()
 	return e
 }
 
 // EncodeString is fun
-func (t *Encoder) EncodeString(s string) {
+func (e *Encoder) EncodeString(s string) {
 	go func() {
 		for _, c := range s {
-			t.input <- c
+			e.input <- c
 		}
 	}()
 }
 
-func (t *Encoder) run() {
+func (e *Encoder) run() {
 
 	var modCase int           // current Letters/Figures state
 	var charsWithoutCRLF int  // number of chars we have handled without inserting a CR-LF
 	var charsWithoutShift int // number of chars we have handled without seeing a shift
-	for r := range t.input {
-		c := t.charset.toCode(r)
+	for r := range e.input {
+		c := e.charset.toCode(r)
 
 		/*this rune can either be rendered as a Figures character,
 		  a Letters character or WHITESPACE which can be rendered by
 			we must send something, so we'll choose the more common
 			Letters case*/
 			if modCase == shiftUnknown {
-				t.output <- t.charset.unshift()
+				e.output <- e.charset.unshift()
 			}
 
 			modCase = shiftWhitespace
 			  our modulator's current state, so add a new case char
 			  here*/
 			if c.shift == shiftLetter {
-				t.output <- t.charset.unshift()
+				e.output <- e.charset.unshift()
 			} else {
-				t.output <- t.charset.shift()
+				e.output <- e.charset.shift()
 			}
 
 			/*and save our current state*/
 		   at least every 72 characters. */
 		if charsWithoutShift > 70 {
 			if modCase == shiftWhitespace {
-				t.output <- t.charset.unshift() /*doesn't matter which, so how 'bout LETR*/
+				e.output <- e.charset.unshift() /*doesn't matter which, so how 'bout LETR*/
 			} else if modCase == shiftLetter {
-				t.output <- t.charset.unshift()
+				e.output <- e.charset.unshift()
 			} else {
-				t.output <- t.charset.shift()
+				e.output <- e.charset.shift()
 			}
 			charsWithoutShift = 0
 		}
 		/* we need to ensure that we send a carriage return/linefeed
 		 * at least every 72 characters, but we start looking for a
 		 * space character starting at 60 characters */
-		if !t.autoWrap {
+		if !e.autoWrap {
 			/*we just insert our regular character*/
-			t.output <- c.toByte()
+			e.output <- c.toByte()
 
-			if t.autoCRLF {
+			if e.autoCRLF {
 				if r == '\n' {
-					t.output <- t.charset.toByte('\r')
+					e.output <- e.charset.toByte('\r')
 				} else if r == '\r' {
-					t.output <- t.charset.toByte('\n')
+					e.output <- e.charset.toByte('\n')
 				}
 			}
 
-		} else if (charsWithoutCRLF > 59) && (modCase == shiftWhitespace) {
+		} else if (charsWithoutCRLF > e.crlfThresh) && (modCase == shiftWhitespace) {
 			/*insert the cr-lf instead of the space character*/
-			t.output <- t.charset.toByte('\r')
-			t.output <- t.charset.toByte('\n')
+			e.output <- e.charset.toByte('\r')
+			e.output <- e.charset.toByte('\n')
 			charsWithoutCRLF = 0
-		} else if charsWithoutCRLF > 70 {
+		} else if charsWithoutCRLF > e.crlfForceThresh {
 			/*insert the cr-lf followed by the character*/
-			t.output <- t.charset.toByte('\r')
-			t.output <- t.charset.toByte('\n')
-			t.output <- c.toByte()
+			e.output <- e.charset.toByte('\r')
+			e.output <- e.charset.toByte('\n')
+			e.output <- c.toByte()
 			charsWithoutCRLF = 0
 		} else {
 			/*we just insert our regular character*/
-			t.output <- c.toByte()
+			e.output <- c.toByte()
 
-			if t.autoCRLF {
+			if e.autoCRLF {
 				if r == '\n' {
-					t.output <- t.charset.toByte('\r')
+					e.output <- e.charset.toByte('\r')
 				} else if r == '\r' {
-					t.output <- t.charset.toByte('\n')
+					e.output <- e.charset.toByte('\n')
 				}
 			}
 

examples/main.go

 )
 
 func main() {
-	baud := 45.45
-	stopBits := 2.0
+
+	s := openbaudot.ModemSettings{
+		Baud:       45.45,
+		StopBits:   2,
+		DataBits:   5,
+		SampleRate: 8000,
+	}
 
 	charset := openbaudot.USTTY.Initialize()
 
 	done := make(chan struct{})
 
 	encoder := openbaudot.NewEncoder(encoderIn, modulatorIn, charset)
-	modulator := openbaudot.NewModulator(baud, stopBits, 5, modulatorIn, modulatorOut)
+	modulator := openbaudot.NewModulator(s, modulatorIn, modulatorOut)
 
 	callback := func(event int, data interface{}) {
 		switch event {
 		}
 	}()
 
-	openbaudot.NewDemodulator(baud, stopBits, 5, demodulatorIn, decoderIn)
+	openbaudot.NewDemodulator(s, demodulatorIn, decoderIn)
 	openbaudot.NewDecoder(decoderIn, decoderOut, charset)
 
 	running := true

modulator.go

+// 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 openbaudot
 
 import "math"
 
-/*
- * OBL openbaudot Library
- *
- * 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 software was developed with support from the National Institute on
- * Disability and Rehabilitation Research, US Dept of Education under Grant
- * # H133E990006 and H133E040014
- *
- * 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.
- *
- * This library is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this library; if not, write to the Free Software Foundation,
- * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- *
- * Please send a copy of any improved versions of the library to:
- * Jeff Knighton, Voiceriver Inc, jeff.knighton@voiceriver.com
- * Gunnar Hellstrom, Omnitor AB, Box 92054, 12006 Stockholm, SWEDEN
- * Gregg Vanderheiden, Trace Center, U of Wisconsin, Madison, Wi 53706
- *
- * file...: obl.go
- * original author.: Keelan Lightfoot
- * Created: 20 May 2017
- *
- */
+const (
+	modStateIdle = iota
+	modStateStart
+	modStateBit
+	modStateStop
+	modStateHold
+)
 
 // Modulator is fun
 type Modulator struct {
 	input  chan byte
 	output chan int16
 
-	baud           float64 // modulator baud rate
-	dataBits       int
-	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
-	numStopBits    int    // number of stop bits
-	numStopSamples int    // number of samples for stop bit
-	wOneQ16        uint16 // scaled one freq 0..2math.Pi -> 0..65536
-	wZeroQ16       uint16 // scaled zero freq 0..2math.Pi -> 0..65536
-	sinLutQ15      []int16
-
-	callback Callback
+	baud            float64 // modulator baud rate
+	dataBits        int
+	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
+	numStopHalfBits int     // number of stop bits
+	numStopSamples  int     // number of samples for stop bit
+	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(baud float64, stopBits float64, dataBits int, 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)
 	m.input = input
 	m.output = output
 
-	m.baud = baud
-	m.dataBits = dataBits
-	m.samplesPerBit = int(float64(sampleRate) / m.baud)
-	m.numStopBits = int(math.Floor(stopBits / .5))
-	m.numStopSamples = m.numStopBits * m.samplesPerBit / 2
+	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.numStopSamples = m.numStopHalfBits * m.samplesPerBit / 2
 	m.amplitude = 16384
 
-	wOne, wZero := calculateW(2125, 2295)
+	wOne, wZero := calculateW(2125, 2295, m.sampleRate)
 
 	m.wOneQ16 = uint16((65536 / (2.0 * math.Pi)) * wOne)
 	m.wZeroQ16 = uint16((65536 / (2.0 * math.Pi)) * wZero)
 	*/
 	if bit != 0 {
 		m.phaseQ16 += m.wOneQ16
-		m.output <- multq(m.amplitude, m.sinLutQ15[m.phaseQ16>>2])
+		m.output <- multq15(m.amplitude, m.sinLutQ15[m.phaseQ16>>2])
 
 	} else {
 		m.phaseQ16 += m.wZeroQ16
-		m.output <- multq(m.amplitude, m.sinLutQ15[m.phaseQ16>>2])
+		m.output <- multq15(m.amplitude, m.sinLutQ15[m.phaseQ16>>2])
 	}
 }
 
 	for {
 		nextState = modState
 		switch modState {
-		case ModStateIdle:
+		case modStateIdle:
 			select {
 			case c = <-m.input:
 				modSample = 0
-				nextState = ModStateStart
+				nextState = modStateStart
 				//obl.callback(EventTransmitState, TransmitStart)
 				idleSamples = 0
 			default:
 				m.modulate(0)
 
-				if idleSamples < sampleRate {
+				if idleSamples < m.sampleRate {
 					idleSamples++
-				} else if idleSamples == sampleRate {
+				} else if idleSamples == m.sampleRate {
 					if m.callback != nil {
 						m.callback(EventIdle, 0)
 					}
 					idleSamples++
 				}
 			}
-		case ModStateStart:
+		case modStateStart:
 			m.modulate(0)
 			modSample++
 			// after sending start bit send LSB data bit
 				modNbit = 0
 				modBit = int(c & 0x1)
 				modSample = 0
-				nextState = ModStateBit
+				nextState = modStateBit
 			}
-		case ModStateBit:
+		case modStateBit:
 			m.modulate(modBit)
 			modSample++
 			// when this data bit complete, send next data bit
 				modNbit++
 				modBit = int((c >> uint(modNbit)) & 0x1)
 				if modNbit == m.dataBits {
-					nextState = ModStateStop
+					nextState = modStateStop
 				}
 			}
-		case ModStateStop:
+		case modStateStop:
 			m.modulate(1)
 			modSample++
 			// when stop bit complete start transmission of next char, or enter idle state
 			if modSample == m.numStopSamples {
 				modSample = 0
-				nextState = ModStateIdle
+				nextState = modStateIdle
 			}
 			// 	(obl.callback)(obl,OBL_EVENT_TX_STATE, OBL_TRANSMIT_STOP);
 		}