more fun

chopper.go

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

common.go

@@ -22,10 +22,18 @@ const (
 	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
+
+	// EventActive is triggered when the modulator exits out of an idle period to begin modulating
+	EventActive
+	// EventIdle is triggered after idle
 	EventIdle
+	
+	
+	// EventStartBit is triggered with the falling edge of the start bit when transmitting a character
+	EventStartBit
+	// EventStopBit is triggered with rising edge of the stop bit when transmitting a character
+	EventStopBit
+	
 	// EventEncodeStringComplete is fun
 	EventEncodeStringComplete
 )

decoder.go

@@ -17,6 +17,13 @@ type Decoder struct {
 	input   chan byte
 	output  chan rune
 	charset *CodeSet
+	usos bool
+}
+
+// UnshiftOnSpace sets how the decoder behaves when a space is received while in figures
+// mode
+func (d *Decoder) UnshiftOnSpace(usos bool) {
+	d.usos = usos
 }
 
 // NewDecoder creates a new decoder.
@@ -36,13 +43,18 @@ func (d *Decoder) run() {
 		switch c {
 		case d.charset.UnshiftCode:
 			shift = shiftLetter
-			//obl.callback(EventDemodCase, Letters)
+			//TODO: Trigger EventDemodCase
 		case d.charset.ShiftCode:
 			shift = shiftFigure
-		//	obl.callback(EventDemodCase, Figures)
+			//TODO: Trigger EventDemodCase
 		default:
+			r := d.charset.toRune(shift, c)
+			if d.usos && shift == shiftFigure && r == ' ' {
+				shift = shiftLetter
+				//TODO: Trigger EventUnshiftOnSpace
+			}
 			d.output <- d.charset.toRune(shift, c)
-			//	obl.callback(obl,EventDemodChar, ascii);
+			//TODO: Trigger EventDemodChar
 		}
 	}
 }

demodulator.go

@@ -39,45 +39,13 @@ type Demodulator struct {
 	sigOut        bool
 	samplerate    int
 	div           int
+	inhibitOutput bool
 	autobaud      struct {
 		enabled  bool    // audio baud detection enable/disable flag
 		estimate float64 // autobaud estimate
 	}
 }
 
-// NewDumbDemodulator is fun
-func NewDumbDemodulator(s *ModemSettings, input chan int16, sigOutput chan [3]float64) *Demodulator {
-
-	d := new(Demodulator)
-	d.input = input
-	d.sigOutput = sigOutput
-
-	d.settings = s
-
-	// the bandpass filter is picky about the sample rate, and the output is perfectly
-	// balanced when the sample rate is 3x the center frequency, so lets divide the sample
-	// rate down to as close to that as we can get.
-
-	centerFrequency := math.Abs(float64(d.settings.OneFreq)+float64(d.settings.ZeroFreq)) / 2 * 3
-
-	d.div = int(math.Floor(float64(d.settings.SampleRate) / float64(centerFrequency)))
-	if d.div == 0 {
-		d.div = 1
-	}
-
-	d.samplerate = d.settings.SampleRate / d.div
-	//d.div = div
-	d.samplesPerBit = int(float64(d.samplerate) / d.settings.Baud)
-	d.autobaud.enabled = false
-
-	d.dsp = newDsp(d.settings.OneFreq, d.settings.ZeroFreq, d.samplerate)
-
-	d.autobaud.estimate = d.settings.Baud
-	d.sigOut = true
-
-	go d.run()
-	return d
-}
 
 // NewDemodulator is fun
 func NewDemodulator(s *ModemSettings, input chan int16, output chan byte) *Demodulator {
@@ -108,6 +76,10 @@ func NewDemodulator(s *ModemSettings, input chan int16, output chan byte) *Demod
 
 }
 
+func (d *Demodulator) Inhibit(i bool) {
+	d.inhibitOutput = i
+}
+
 func (d *Demodulator) run() {
 
 	var nextState int
@@ -168,13 +140,12 @@ func (d *Demodulator) run() {
 					}
 					bit++
 					if bit == d.settings.DataBits {
-
-						/* complete baudot char has been received */
-
+						// complete baudot char has been received
 						sample = int(float64(d.samplerate) / d.settings.Baud)
 						nextState = demodStateWaitStop
-						//	fmt.Println("demodStateWaitStop", baudot)
-						d.output <- baudot
+						if !d.inhibitOutput {
+							d.output <- baudot
+						}
 					} else {
 						/* sample next bit 1 bit-period later */
 						sample = int(float64(d.samplerate) / d.settings.Baud)

examples/rttymodem/main.go

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

modulator.go

@@ -15,6 +15,7 @@ import "math"
 
 const (
 	modStateIdle = iota
+	modStateReady
 	modStateStart
 	modStateBit
 	modStateStop
@@ -37,6 +38,8 @@ type Modulator struct {
 	wZeroQ16        uint16  // scaled zero freq 0..2math.Pi -> 0..65536
 	sinLutQ15       []int16 // sine lookup table
 	callback        Callback
+	
+	idleDelay int
 }
 
 // NewModulator is fun
@@ -53,7 +56,7 @@ func NewModulator(s *ModemSettings, input chan byte, output chan int16) *Modulat
 	m.numStopHalfBits = int(math.Floor(m.settings.StopBits / .5))
 	m.numStopSamples = m.numStopHalfBits * m.samplesPerBit / 2
 	m.amplitude = 16384
-
+	m.idleDelay = m.settings.SampleRate
 	wOne, wZero := calculateW(m.settings.OneFreq, m.settings.ZeroFreq, m.settings.SampleRate)
 
 	m.wOneQ16 = uint16((65536 / (2.0 * math.Pi)) * wOne)
@@ -72,6 +75,12 @@ func (m *Modulator) SetCallback(callback Callback) {
 	m.callback = callback
 }
 
+// SetIdleDelay sets how long (in samples) that the modulator must be in the ready state 
+// before switching to the idle state
+func (m *Modulator) SetIdleDelay(d int) {
+	m.idleDelay = d
+}
+
 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
@@ -109,24 +118,33 @@ func (m *Modulator) run() {
 	for {
 		nextState = modState
 		switch modState {
+		case modStateReady:
+			fallthrough
 		case modStateIdle:
 			select {
 			case c = <-m.input:
 				modSample = 0
 				nextState = modStateStart
-				//fmt.Println("modStateStart")
-				//obl.callback(EventTransmitState, TransmitStart)
 				idleSamples = 0
+				if m.callback != nil {
+					m.callback(EventStartBit, 0)
+					if (modState == modStateIdle) {
+						m.callback(EventActive, 0)
+					}
+				}
 			default:
 				m.modulate(1)
 
-				if idleSamples < m.settings.SampleRate {
-					idleSamples++
-				} else if idleSamples == m.settings.SampleRate {
-					if m.callback != nil {
-						m.callback(EventIdle, 0)
+				if modState == modStateReady {
+					if idleSamples < m.idleDelay {
+						idleSamples++
+					} else {
+						nextState = modStateIdle
+						if m.callback != nil {
+							m.callback(EventIdle, 0)
+						}
+						idleSamples++
 					}
-					idleSamples++
 				}
 			}
 		case modStateStart:
@@ -138,7 +156,6 @@ func (m *Modulator) run() {
 				modBit = int(c & 0x1)
 				modSample = 0
 				nextState = modStateBit
-				//fmt.Println("modStateBit")
 
 			}
 		case modStateBit:
@@ -161,7 +178,10 @@ func (m *Modulator) run() {
 			// when stop bit complete start transmission of next char, or enter idle state
 			if modSample == m.numStopSamples {
 				modSample = 0
-				nextState = modStateIdle
+				nextState = modStateReady
+				if m.callback != nil {
+					m.callback(EventStopBit, 0)
+				}
 			}
 			// 	(obl.callback)(obl,OBL_EVENT_TX_STATE, OBL_TRANSMIT_STOP);
 		}