Better BER reporting and optimize CC1200 receive BER

Author: jancona

cc1200_modem.go

@@ -252,11 +252,13 @@ func (m *CC1200Modem) processSymbols() {
 func (m *CC1200Modem) rxPipeline(sampleSource chan int8) (chan float32, error) {
 	// modem samples -> DC filter --> RRC filter & scale
 	var err error
-	dcf, err := NewDCFilter(sampleSource, len(rrcTaps5))
+	dcf, err := NewDCFilter(sampleSource, 200) //len(rrcTaps5))
 	if err != nil {
 		return nil, fmt.Errorf("dc filter: %w", err)
 	}
-	s2s := NewSampleToSymbol(dcf.Source(), rrcTaps5, RXSymbolScalingCoeff)
+	// The 1.15 factor was empirically determined. A 15 second transmission from my CS7000
+	// had a BER of 3.3%, compared to 4.9% with the factor at 1.0
+	s2s := NewSampleToSymbol(dcf.Source(), rrcTaps5, RXSymbolScalingCoeff*1.15)
 	// ds, err := NewDownsampler(s2s.Source(), 5, 0)
 	// if err != nil {
 	// 	return nil, fmt.Errorf("downsampler: %w", err)

decoder.go

@@ -49,6 +49,8 @@ type Decoder struct {
 	lsfBytes     []byte
 	dashLog      *slog.Logger
 	lastLogTime  time.Time
+	errors       int
+	bits         int
 }
 
 // 8 preamble symbols, 8 for the syncword, and 960 for the payload.
@@ -79,6 +81,8 @@ func (d *Decoder) DecodeFrame(typ uint16, softBits []SoftBit) {
 			d.timeoutCnt = 0
 			d.lastStreamFN = 0xffff
 			d.lastPacketFN = 0xff
+			d.errors = e
+			d.bits = 368
 
 			if d.lsf.Type[1]&byte(LSFTypeStream) == byte(LSFTypeStream) {
 				d.syncedType = StreamSync
@@ -129,6 +133,8 @@ func (d *Decoder) DecodeFrame(typ uint16, softBits []SoftBit) {
 
 	case typ == PacketSync && d.syncedType == PacketSync:
 		pktFrame, e := d.decodePacketFrame(softBits)
+		d.errors += e
+		d.bits += 368
 		// log.Printf("[DEBUG] pktFrame: % x", pktFrame)
 		lastFrame := (pktFrame[25] >> 7) != 0
 
@@ -164,9 +170,9 @@ func (d *Decoder) DecodeFrame(typ uint16, softBits []SoftBit) {
 				if d.dashLog != nil {
 					if p.Type == PacketTypeSMS && len(p.Payload) > 0 {
 						msg := string(p.Payload[0 : len(p.Payload)-1])
-						d.dashLog.Info("", "type", "RF", "subtype", "Packet", "src", d.lsf.Src.Callsign(), "dst", d.lsf.Dst.Callsign(), "can", d.lsf.CAN(), "mer", json.Number(fmt.Sprintf("%f", float64(e)/3.68)), "packetType", p.Type, "smsMessage", msg)
+						d.dashLog.Info("", "type", "RF", "subtype", "Packet", "src", d.lsf.Src.Callsign(), "dst", d.lsf.Dst.Callsign(), "can", d.lsf.CAN(), "mer", json.Number(fmt.Sprintf("%f", float64(d.errors)/float64(d.bits)*100)), "packetType", p.Type, "smsMessage", msg)
 					} else {
-						d.dashLog.Info("", "type", "RF", "subtype", "Packet", "src", d.lsf.Src.Callsign(), "dst", d.lsf.Dst.Callsign(), "can", d.lsf.CAN(), "mer", json.Number(fmt.Sprintf("%f", float64(e)/3.68)), "packetType", p.Type)
+						d.dashLog.Info("", "type", "RF", "subtype", "Packet", "src", d.lsf.Src.Callsign(), "dst", d.lsf.Dst.Callsign(), "can", d.lsf.CAN(), "mer", json.Number(fmt.Sprintf("%f", float64(d.errors)/float64(d.bits)*100)), "packetType", p.Type)
 					}
 				}
 			} else {
@@ -183,6 +189,8 @@ func (d *Decoder) DecodeFrame(typ uint16, softBits []SoftBit) {
 		var fn uint16
 		d.frameData, lich, fn, lichCnt, e = d.decodeStreamFrame(softBits)
 		log.Printf("[DEBUG] frameData: [% 2x], lich: %02x, lichCnt: %d, d.lichParts: %04x, fn: %04x, d.lastStreamFN: %04x, e: %d", d.frameData, lich, lichCnt, d.lichParts, fn, d.lastStreamFN, e)
+		d.errors += e
+		d.bits += 272
 		if d.lastStreamFN+1 == fn&0x7fff {
 			if d.lichParts != 0x3F && lichCnt < 6 { //6 chunks = 0b111111
 				//reconstruct LSF chunk by chunk
@@ -243,7 +251,7 @@ func (d *Decoder) DecodeFrame(typ uint16, softBits []SoftBit) {
 				d.timeoutCnt = 0
 				if d.dashLog != nil && lastFrame {
 					log.Printf("[DEBUG] Last frame for RF voice stream %04x", d.streamID)
-					d.dashLog.Info("", "type", "RF", "subtype", "Voice End", "src", d.lsf.Src.Callsign(), "dst", d.lsf.Dst.Callsign(), "can", d.lsf.CAN(), "mer", json.Number(fmt.Sprintf("%f", float64(e)/2.72)))
+					d.dashLog.Info("", "type", "RF", "subtype", "Voice End", "src", d.lsf.Src.Callsign(), "dst", d.lsf.Dst.Callsign(), "can", d.lsf.CAN(), "mer", json.Number(fmt.Sprintf("%f", float64(d.errors)/float64(d.bits)*100)))
 				}
 			}
 			if lastFrame {
@@ -413,4 +421,6 @@ func (d *Decoder) reset() {
 	d.lastPacketFN = 0xff
 	d.lastStreamFN = 0xffff
 	d.lichParts = 0
+	d.errors = 0
+	d.bits = 0
 }

transform.go

@@ -15,11 +15,14 @@ const (
 	//40.0e3 is F_TCXO in kHz
 	//129 is `CFM_RX_DATA_OUT` register value at max. F_DEV
 	//datasheet might have this wrong (it says 64)
+
 	RXSymbolScalingCoeff = (1.0 / (0.8 / (40.0e3 / 2097152 * 0xAD) * 129.0))
+
 	//0xAD is `DEVIATION_M`, 2097152=2^21
 	//+0.8kHz is the deviation for symbol +1
 	//40.0e3 is F_TCXO in kHz
 	//64 is `CFM_TX_DATA_IN` register value for max. F_DEV
+
 	TXSymbolScalingCoeff = (0.8 / ((40.0e3 / 2097152) * 0xAD) * 64.0)
 )
 
@@ -196,24 +199,25 @@ func (t *Transform[I, O]) handle() {
 // Filter DC from int8 samples by subtracting a moving average
 type DCFilter struct {
 	Transform[int8, int8]
-	averageN  int
-	movingAvg int8
+	averageCnt int
+	movingAvg  int
 }
 
-func NewDCFilter(sink chan int8, averageN int) (DCFilter, error) {
+func NewDCFilter(sink chan int8, averageCnt int) (DCFilter, error) {
 	ret := DCFilter{
-		averageN: averageN,
+		averageCnt: averageCnt,
 	}
-	if averageN < 1 {
-		return ret, fmt.Errorf("averageN must be greater than zero")
+	if averageCnt < 1 {
+		return ret, fmt.Errorf("averageCnt must be greater than zero")
 	}
 	ret.Transform = NewTransform(sink, ret.dcFilter, 0)
 	return ret, nil
 }
 func (t *DCFilter) dcFilter(sample int8) []int8 {
-	t.movingAvg = int8((int(t.movingAvg)*(t.averageN-1) + int(sample)) / t.averageN)
-	// log.Printf("[DEBUG] movingAvg: %d, sample: %d, ret: %d", t.movingAvg, sample, sample-t.movingAvg)
-	return []int8{sample - t.movingAvg}
+	ret := sample - int8(t.movingAvg)
+	t.movingAvg = (t.movingAvg*(t.averageCnt-1) + int(sample)) / t.averageCnt
+	// log.Printf("[DEBUG] movingAvg: %d, sample: %d, ret: %d", t.movingAvg, sample, sample-int8(t.movingAvg))
+	return []int8{ret}
 }
 
 // scale samples by a factor