Initial commit

code.go

@@ -0,0 +1,220 @@
+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
+	shiftFigure
+	shiftWhitespace
+)
+
+var (
+	defaultSubstitutes = map[rune]rune{
+		'{': '(',
+		'}': ')',
+		'[': '(',
+		']': ')',
+	}
+	// TDD Telecommunications Device for the Deaf standard
+	TDD = CodeSet{
+		Codes: [2][]rune{
+			{'\b', 'E', '\n', 'A', ' ', 'S', 'I', 'U', '\r', 'D', 'R', 'J', 'N', 'F', 'C', 'K', 'T', 'Z', 'L', 'W', 'H', 'Y', 'P', 'Q', 'O', 'B', 'G', '\x0e', 'M', 'X', 'V', '\x0f'},
+			{'\b', '3', '\n', '-', ' ', ',', '8', '7', '\r', '$', '4', '\'', ',', '!', ':', '(', '5', '"', ')', '2', '=', '6', '0', '1', '9', '?', '+', '\x0e', '.', '/', ';', '\x0f'},
+		},
+		Substitutes: defaultSubstitutes,
+		Fallback:    '\'',
+		ShiftCode:   0x1b,
+		UnshiftCode: 0x1f,
+	}
+	// USTTY US Teletype Corporation
+	USTTY = CodeSet{
+		Codes: [2][]rune{
+			{'\x00', 'E', '\n', 'A', ' ', 'S', 'I', 'U', '\r', 'D', 'R', 'J', 'N', 'F', 'C', 'K', 'T', 'Z', 'L', 'W', 'H', 'Y', 'P', 'Q', 'O', 'B', 'G', '\x0e', 'M', 'X', 'V', '\x0f'},
+			{'\x00', '3', '\n', '-', ' ', '\a', '8', '7', '\r', '$', '4', '\'', ',', '!', ':', '(', '5', '"', ')', '2', '#', '6', '0', '1', '9', '?', '&', '\x0e', '.', '/', ';', '\x0f'},
+		},
+		Substitutes: defaultSubstitutes,
+		Fallback:    '-',
+		ShiftCode:   0x1b,
+		UnshiftCode: 0x1f,
+	}
+	// USITA2 USITA2
+	USITA2 = CodeSet{
+		Codes: [2][]rune{
+			{'\x00', 'E', '\n', 'A', ' ', 'S', 'I', 'U', '\r', 'D', 'R', 'J', 'N', 'F', 'C', 'K', 'T', 'Z', 'L', 'W', 'H', 'Y', 'P', 'Q', 'O', 'B', 'G', '\x0e', 'M', 'X', 'V', '\x0f'},
+			{'\x00', '3', '\n', '-', ' ', '\'', '8', '7', '\r', '$', '4', '\a', ',', '!', ':', '(', '5', '"', ')', '2', '=', '6', '0', '1', '9', '?', '&', '\x0e', '.', '/', '=', '\x0f'},
+		},
+		Substitutes: defaultSubstitutes,
+		Fallback:    '-',
+		ShiftCode:   0x1b,
+		UnshiftCode: 0x1f,
+	}
+	// Weather US Weather
+	Weather = CodeSet{
+		Codes: [2][]rune{
+			{'\x00', 'E', '\n', 'A', ' ', 'S', 'I', 'U', '\r', 'D', 'R', 'J', 'N', 'F', 'C', 'K', 'T', 'Z', 'L', 'W', 'H', 'Y', 'P', 'Q', 'O', 'B', 'G', '\x0e', 'M', 'X', 'V', '\x0f'},
+			{'\x00', '3', '\n', '↑', ' ', '\a', '8', '7', '\r', '↗', '4', '↙', '⦷', '→', '○', '←', '5', '+', '↖', '2', '↓', '6', '0', '1', '9', '⊕', '↘', '\x0e', '.', '/', '⦶', '\x0f'},
+		},
+		Substitutes: defaultSubstitutes,
+		Fallback:    '-',
+		ShiftCode:   0x1b,
+		UnshiftCode: 0x1f,
+	}
+	// Fractions US Fractions
+	Fractions = CodeSet{
+		Codes: [2][]rune{
+			{'\x00', 'E', '\n', 'A', ' ', 'S', 'I', 'U', '\r', 'D', 'R', 'J', 'N', 'F', 'C', 'K', 'T', 'Z', 'L', 'W', 'H', 'Y', 'P', 'Q', 'O', 'B', 'G', '\x0e', 'M', 'X', 'V', '\x0f'},
+			{'\x00', '3', '\n', '↑', ' ', '\a', '8', '7', '\r', '$', '4', '\'', '⅞', '¼', '⅛', '½', '5', '"', '¾', '2', ' ', '6', '0', '1', '9', '⅝', '&', '\x0e', '.', '/', '⅜', '\x0f'},
+		},
+		Substitutes: defaultSubstitutes,
+		Fallback:    '-',
+		ShiftCode:   0x1b,
+		UnshiftCode: 0x1f,
+	}
+)
+
+// CodeSet represents a teletype character set.
+type CodeSet struct {
+	// Codes specifies a mapping of runes to codes. There are two tables, 0 for ltrs, 1 for figs
+	Codes [2][]rune
+	// Substitutes specifies what characters to re-map to existing table entries
+	Substitutes map[rune]rune
+	// Fallback specifies what rune to use when a table entry or substitution cant be found
+	Fallback rune
+	// ShiftRune is fun
+	ShiftCode byte
+	// UnshiftRune is fun
+	UnshiftCode byte
+
+	runeToCodeSet map[rune]code
+}
+
+type code struct {
+	shift int
+	v     byte
+}
+
+//Initialize is fun
+func (cs *CodeSet) Initialize() *CodeSet {
+
+	cs.runeToCodeSet = make(map[rune]code)
+
+	for i, runes := range cs.Codes {
+
+		var shift int
+
+		switch i {
+		case 0:
+			shift = shiftLetter
+		case 1:
+			shift = shiftFigure
+		}
+
+		for v, r := range runes {
+			if c, exists := cs.runeToCodeSet[r]; exists {
+				c.shift = shiftWhitespace
+				cs.runeToCodeSet[r] = c
+			} else {
+				cs.runeToCodeSet[r] = code{
+					shift: shift,
+					v:     byte(v),
+				}
+			}
+
+		}
+	}
+
+	for in, out := range cs.Substitutes {
+		if _, ok := cs.runeToCodeSet[in]; ok {
+			// dont load a translation if it overlaps an existing table entry
+			continue
+		}
+		if b, ok := cs.runeToCodeSet[out]; ok {
+			// only set the translation if the output exists in table
+			cs.runeToCodeSet[in] = b
+		}
+	}
+	return cs
+}
+
+func (cs *CodeSet) toCode(r rune) code {
+
+	if c, ok := cs.runeToCodeSet[unicode.ToUpper(r)]; ok {
+		return c
+	}
+
+	return cs.runeToCodeSet[cs.Fallback]
+}
+
+func (cs *CodeSet) toByte(r rune) byte {
+
+	if c, ok := cs.runeToCodeSet[unicode.ToUpper(r)]; ok {
+		return c.v
+	}
+
+	return cs.runeToCodeSet[cs.Fallback].v
+}
+
+func (c code) toByte() byte {
+	return c.v
+}
+
+func (cs *CodeSet) shift() byte {
+	return cs.ShiftCode
+}
+
+func (cs *CodeSet) unshift() byte {
+	return cs.UnshiftCode
+}
+
+func (cs *CodeSet) toRune(shift int, b byte) rune {
+	var i int
+	switch shift {
+	case shiftLetter:
+		i = 0
+	case shiftFigure:
+		i = 1
+	}
+	if int(b) < len(cs.Codes[i]) {
+		return cs.Codes[i][int(b)]
+	}
+	return '�'
+}

common.go

@@ -0,0 +1,142 @@
+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
+	EventDemodAbort
+	// EventDemodCase inform application regarding a demodulated LETRS/Figures case character
+	EventDemodCase
+	// EventTransmitState data value is 1 for transmitting or 0 for not transmitting, and 2 for timeout (following transmit)
+	EventTransmitState
+	// EventIdle is fun
+	EventIdle
+)
+
+/* precomputed constants for demodDsp */
+
+var (
+	// sampleRate Sample rate
+	sampleRate = 8000
+	// Beta filter bandwidth factor
+	Beta = 0.95 //.95
+)
+
+func multq(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) {
+	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

@@ -0,0 +1,74 @@
+package openbaudot
+
+/*
+ * 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
+ *
+ */
+
+// Decoder is fun
+type Decoder struct {
+	input   chan byte
+	output  chan rune
+	charset *CodeSet
+}
+
+// NewDecoder is fun
+func NewDecoder(input chan byte, output chan rune, charset *CodeSet) *Decoder {
+	d := new(Decoder)
+	d.input = input
+	d.output = output
+	d.charset = charset
+
+	go d.run()
+	return d
+}
+
+func (d *Decoder) run() {
+	shift := shiftLetter
+	for c := range d.input {
+		switch c {
+		case LETR:
+			shift = shiftLetter
+			//obl.callback(EventDemodCase, Letters)
+		case FIGR:
+			shift = shiftFigure
+		//	obl.callback(EventDemodCase, Figures)
+		default:
+			d.output <- d.charset.toRune(shift, c)
+			//	obl.callback(obl,EventDemodChar, ascii);
+		}
+	}
+}

demodulator.go

@@ -0,0 +1,317 @@
+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
+ *
+ */
+
+// Demodulator is fun
+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
+	samplesPerBit int
+	dsp           *dsp
+	dataBits      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(baud float64, stopBits float64, dataBits int, input chan int16, output chan byte) *Demodulator {
+
+	d := new(Demodulator)
+	d.input = input
+	d.output = output
+	d.state = DemodStateWaitStart
+	//d.lettersFigures = Letters
+	d.baud = baud
+	d.dataBits = dataBits
+	d.samplesPerBit = int(float64(sampleRate) / d.baud)
+
+	wOne, wZero := calculateW(2125, 2295)
+
+	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),
+	}
+
+	d.autobaud.estimate = d.baud
+	if d.autobaud.enabled {
+		d.autobaud.state = AutobaudStateWaitStart
+	} else {
+		d.autobaud.state = AutobaudStateDisabled
+	}
+	go d.run()
+	return d
+
+}
+
+func (d *Demodulator) run() {
+
+	var nextState int
+	var edge, dist int
+
+	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
+
+	/* main loop, process sample by sample */
+
+	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 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.baudot = 0
+				d.bit = 0
+				nextState = DemodStateSample
+			}
+		case DemodStateSample:
+
+			d.sample--
+			if d.sample == 0 {
+				if d.dsp.onePresent() {
+					d.baudot |= (1 << uint(d.bit))
+				}
+				d.bit++
+
+				if d.bit == d.dataBits {
+
+					/* complete baudot char has been received */
+					d.output <- d.baudot
+					//fmt.Printf("Demodulator done %d\n", d.baudot)
+
+					d.sample = int(float64(sampleRate) / d.baud)
+					nextState = DemodStateWaitStop
+				} else {
+					/* sample next bit 1 bit-period later */
+					d.sample = int(float64(sampleRate) / d.baud)
+				}
+			}
+
+			/* check for sampleRateK signal drop out */
+
+			//return d.demTotal != 0 && d.demLpf < -1*MinThresh*d.demTotal
+
+			if d.dsp.dropout() {
+				d.minSigTimeout++
+
+				/* If signal drops out for approx one bit period
+				   assume we have lost sampleRateK signal */
+				if d.minSigTimeout > d.samplesPerBit {
+					nextState = DemodStateWaitStart
+				}
+			} else {
+				d.minSigTimeout = 0
+			}
+
+		case DemodStateWaitStop:
+
+			/* wait until we are in the middle of stop bit */
+
+			d.sample--
+			if d.sample == 0 {
+				nextState = DemodStateWaitStart
+			}
+
+		}
+
+		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:
+
+			d.autobaud.zeroX++
+
+			if d.dsp.edgeDetected() {
+				/* OK, rising edge detected */
+
+				/* determine distance to closest edge assuming 50 baud */
+
+				dist75 := 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
+				}
+
+				/* determine distance to closest edge assuming 50 baud */
+
+				dist50 := 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
+				}
+
+				/* determine distance to closest edge assuming 47 baud */
+
+				dist47 := 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
+				}
+
+				/* determine distance to closest edge assuming 45 baud */
+
+				dist45 := 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
+				}
+
+				/* update 3-point smoothed distance estimates */
+
+				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
+
+				dist47Smooth := dist47 + demDist47[0] + demDist47[1]
+				demDist47[1] = demDist47[0]
+				demDist47[0] = dist47
+
+				dist45Smooth := dist45 + demDist45[0] + demDist45[1]
+				demDist45[1] = demDist45[0]
+				demDist45[0] = dist45
+
+				/* make a decision on baud rate */
+
+				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
+				}
+
+				//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
+			}
+
+			/* reset autobaud state machine, e.g. if sampleRateK drops out before
+			   we get a zero crossing */
+
+			if d.state != DemodStateSample {
+				nextState = AutobaudStateWaitStop
+			}
+
+		case AutobaudStateWaitStop:
+			if d.state == DemodStateWaitStop {
+				nextState = AutobaudStateWaitStart
+			}
+
+		case AutobaudStateDisabled:
+
+		default:
+
+		}
+		d.autobaud.state = nextState
+	}
+
+}

dsp.go

@@ -0,0 +1,103 @@
+package openbaudot
+
+/*
+ * 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
+ *
+ */
+
+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
+
+}
+
+func (d *dsp) edgeDetected() bool {
+	return d.demLpf > MinThresh*d.demTotal
+}
+
+func (d *dsp) dropout() bool {
+	return absint(d.demLpf) < MinThresh*d.demTotal || d.demTotal == 0
+}
+
+func (d *dsp) signalPresent() bool {
+	return d.demTotal != 0 && d.demLpf < -1*MinThresh*d.demTotal
+}
+
+func (d *dsp) onePresent() bool {
+	return d.demLpf > 0
+}
+
+func (d *dsp) demod(sam int16) { //short *buffer, int samples)
+
+	sam >>= 5
+
+	oneQ0 := sam
+	oneQ0 += multq(d.c1, d.demOneQ0[0])
+	oneQ0 -= multq(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])
+	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) % 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) % LPFOrder
+}

encoder.go

@@ -0,0 +1,176 @@
+package openbaudot
+
+/*
+ * 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
+ *
+ */
+
+// Encoder is fun
+type Encoder struct {
+	input    chan rune
+	output   chan byte
+	autoWrap bool // true for auto CRLF mode
+	autoCRLF bool
+	charset  *CodeSet
+}
+
+// NewEncoder is fun
+func NewEncoder(input chan rune, output chan byte, charset *CodeSet) *Encoder {
+	e := new(Encoder)
+	e.input = input
+	e.output = output
+	e.charset = charset
+
+	go e.run()
+	return e
+}
+
+// EncodeString is fun
+func (t *Encoder) EncodeString(s string) {
+	go func() {
+		for _, c := range s {
+			t.input <- c
+		}
+	}()
+}
+
+func (t *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)
+
+		/*this rune can either be rendered as a Figures character,
+		  a Letters character or WHITESPACE which can be rendered by
+		  either character set*/
+		if r == '\r' || r == '\n' {
+			charsWithoutCRLF = 0
+		}
+
+		/*see if we need to first insert a case character*/
+		if c.shift == shiftWhitespace {
+			/*we have white space, we don't need to insert
+			a Letters/Figures case character.  We will insert
+			a case character when we transition from white
+			space to some other case.  The only exception to this
+			is when we are just starting to transmit, in which case
+			we must send something, so we'll choose the more common
+			Letters case*/
+			if modCase == shiftUnknown {
+				t.output <- t.charset.unshift()
+			}
+
+			modCase = shiftWhitespace
+		} else if c.shift != modCase {
+			/*case is either Letters or Figures and doesn't match
+			  our modulator's current state, so add a new case char
+			  here*/
+			if c.shift == shiftLetter {
+				t.output <- t.charset.unshift()
+			} else {
+				t.output <- t.charset.shift()
+			}
+
+			/*and save our current state*/
+			modCase = c.shift
+
+			/*and update our counter*/
+			charsWithoutShift = 0
+		}
+
+		/*we need to perform a little logic here to check for some
+		 * 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 modCase == shiftWhitespace {
+				t.output <- t.charset.unshift() /*doesn't matter which, so how 'bout LETR*/
+			} else if modCase == shiftLetter {
+				t.output <- t.charset.unshift()
+			} else {
+				t.output <- t.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 {
+			/*we just insert our regular character*/
+			t.output <- c.toByte()
+
+			if t.autoCRLF {
+				if r == '\n' {
+					t.output <- t.charset.toByte('\r')
+				} else if r == '\r' {
+					t.output <- t.charset.toByte('\n')
+				}
+			}
+
+		} else if (charsWithoutCRLF > 59) && (modCase == shiftWhitespace) {
+			/*insert the cr-lf instead of the space character*/
+			t.output <- t.charset.toByte('\r')
+			t.output <- t.charset.toByte('\n')
+			charsWithoutCRLF = 0
+		} else if charsWithoutCRLF > 70 {
+			/*insert the cr-lf followed by the character*/
+			t.output <- t.charset.toByte('\r')
+			t.output <- t.charset.toByte('\n')
+			t.output <- c.toByte()
+			charsWithoutCRLF = 0
+		} else {
+			/*we just insert our regular character*/
+			t.output <- c.toByte()
+
+			if t.autoCRLF {
+				if r == '\n' {
+					t.output <- t.charset.toByte('\r')
+				} else if r == '\r' {
+					t.output <- t.charset.toByte('\n')
+				}
+			}
+
+		}
+
+		charsWithoutShift++
+		charsWithoutCRLF++
+
+	}
+
+}

examples/main.go

@@ -0,0 +1,107 @@
+package main
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/naleek/openbaudot"
+)
+
+func main() {
+	baud := 45.45
+	stopBits := 2.0
+
+	charset := openbaudot.USTTY.Initialize()
+
+	encoderIn := make(chan rune)
+	modulatorIn := make(chan byte)
+	modulatorOut := make(chan int16)
+	demodulatorIn := make(chan int16)
+	decoderIn := make(chan byte)
+	decoderOut := make(chan rune)
+
+	done := make(chan struct{})
+
+	encoder := openbaudot.NewEncoder(encoderIn, modulatorIn, charset)
+	modulator := openbaudot.NewModulator(baud, stopBits, 5, modulatorIn, modulatorOut)
+
+	callback := func(event int, data interface{}) {
+		switch event {
+		case openbaudot.EventIdle:
+			fmt.Println("EventIdle")
+			encoder.EncodeString("Hello World")
+
+		}
+
+	}
+
+	modulator.SetCallback(callback)
+
+	go func() {
+		for b := range modulatorOut {
+			demodulatorIn <- b
+			time.Sleep(125 * time.Microsecond)
+		}
+	}()
+
+	openbaudot.NewDemodulator(baud, stopBits, 5, 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
+// 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
+// }

modulator.go

@@ -0,0 +1,184 @@
+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
+ *
+ */
+
+// 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
+}
+
+// NewModulator is fun
+func NewModulator(baud float64, stopBits float64, dataBits int, 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 = 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.amplitude = 16384
+
+	wOne, wZero := calculateW(2125, 2295)
+
+	m.wOneQ16 = uint16((65536 / (2.0 * math.Pi)) * wOne)
+	m.wZeroQ16 = uint16((65536 / (2.0 * math.Pi)) * wZero)
+
+	m.sinLutQ15 = make([]int16, 16384)
+	for i := 0; i < 16384; i++ {
+		m.sinLutQ15[i] = int16(32767 * math.Sin(2.0*math.Pi*float64(i)/float64(16384)))
+	}
+	go m.run()
+	return m
+}
+
+// SetCallback is fun
+func (m *Modulator) SetCallback(callback Callback) {
+	m.callback = callback
+}
+
+func (m *Modulator) modulate(bit int) { //short *buffer, int samples)
+	/* use of unsigned short in Q16 for format for phase
+	   accumulator leads to natural wrap-around at 2PI
+	   boundaries
+	*/
+	/* sin_lut_q15 is in Q15 format, therefore we rightshift 15 to
+	   get Q0 at modulator output.  We cast multiply arguments
+	   to 32 bit ints to ensure compiler uses a multiply with a 32
+	   bit result.
+	*/
+	if bit != 0 {
+		m.phaseQ16 += m.wOneQ16
+		m.output <- multq(m.amplitude, m.sinLutQ15[m.phaseQ16>>2])
+
+	} else {
+		m.phaseQ16 += m.wZeroQ16
+		m.output <- multq(m.amplitude, m.sinLutQ15[m.phaseQ16>>2])
+	}
+}
+
+func (m *Modulator) run() {
+
+	var modState int  // modulator state machine
+	var nextState int // next state of state machine
+	var c byte        // current baudot char being modulated
+	var modNbit int   // num bits modulated so far in this char
+	var modBit int    // current bit in modBaudot being modulated
+	var modSample int // current sample in bit being modulated
+	var idleSamples int
+
+	for {
+		nextState = modState
+		switch modState {
+		case ModStateIdle:
+			select {
+			case c = <-m.input:
+				modSample = 0
+				nextState = ModStateStart
+				//obl.callback(EventTransmitState, TransmitStart)
+				idleSamples = 0
+			default:
+				m.modulate(0)
+
+				if idleSamples < sampleRate {
+					idleSamples++
+				} else if idleSamples == sampleRate {
+					if m.callback != nil {
+						m.callback(EventIdle, 0)
+					}
+					idleSamples++
+				}
+			}
+		case ModStateStart:
+			m.modulate(0)
+			modSample++
+			// after sending start bit send LSB data bit
+			if modSample == m.samplesPerBit {
+				modNbit = 0
+				modBit = int(c & 0x1)
+				modSample = 0
+				nextState = ModStateBit
+			}
+		case ModStateBit:
+			m.modulate(modBit)
+			modSample++
+			// when this data bit complete, send next data bit
+			if modSample == m.samplesPerBit {
+				modSample = 0
+				modNbit++
+				modBit = int((c >> uint(modNbit)) & 0x1)
+				if modNbit == m.dataBits {
+					nextState = 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
+			}
+			// 	(obl.callback)(obl,OBL_EVENT_TX_STATE, OBL_TRANSMIT_STOP);
+		}
+		modState = nextState
+	}
+
+}