tweak autogain

Author: wiedehopf

demod_2400.c

@@ -290,12 +290,12 @@ void demodulate2400(struct mag_buf *mag) {
     uint16_t *statsProgress = m;
 
     const uint32_t statsWindow = MODES_SHORT_MSG_SAMPLES / 2; // half a short message
-    uint32_t loudSamples = 0;
-    uint32_t quietSamples = 0;
-    uint32_t quiet2Samples = 0;
-    uint32_t loudThreshold = 55000 * statsWindow; // max 65536
-    uint32_t quietThreshold = 800 * statsWindow;
-    uint32_t quiet2Threshold = 2 * quietThreshold;
+    uint32_t loudEvents = 0;
+    uint32_t noiseLowSamples = 0;
+    uint32_t noiseHighSamples = 0;
+    const uint32_t loudThreshold = Modes.loudThreshold * Modes.loudThreshold * statsWindow;
+    const uint32_t noiseLowThreshold = Modes.noiseLowThreshold * Modes.noiseLowThreshold * statsWindow;
+    const uint32_t noiseHighThreshold = Modes.noiseHighThreshold * Modes.noiseHighThreshold * statsWindow;
 
     for (; pa < stop; pa++) {
         int32_t pa_mag, base_noise, ref_level;
@@ -323,9 +323,9 @@ void demodulate2400(struct mag_buf *mag) {
             for (uint32_t i = 0; i < statsWindow; i++) {
                 magSum += pa[i];
             }
-            loudSamples += statsWindow * (magSum > loudThreshold);
-            quietSamples += statsWindow * (magSum < quietThreshold);
-            quiet2Samples += statsWindow * (magSum < quiet2Threshold);
+            loudEvents += (magSum > loudThreshold);
+            noiseLowSamples += statsWindow * (magSum < noiseLowThreshold);
+            noiseHighSamples += statsWindow * (magSum < noiseHighThreshold);
 
             statsProgress = pa + statsWindow;
         }
@@ -493,9 +493,9 @@ void demodulate2400(struct mag_buf *mag) {
         netUseMessage(mm);
     }
 
-    mag->loudSamples = loudSamples;
-    mag->quietSamples = quietSamples;
-    mag->quiet2Samples = quiet2Samples;
+    mag->loudEvents = loudEvents;
+    mag->noiseLowSamples = noiseLowSamples;
+    mag->noiseHighSamples = noiseHighSamples;
 
     /* update noise power */
     {

readsb.c

@@ -116,6 +116,12 @@ static void configSetDefaults(void) {
 
     // Now initialise things that should not be 0/NULL to their defaults
     Modes.gain = MODES_MAX_GAIN;
+
+    // 8 bit autogain defaults, will be squared and compared against magnitude data
+    Modes.loudThreshold = 245;
+    Modes.noiseLowThreshold = 25;
+    Modes.noiseHighThreshold = 35;
+
     Modes.freq = MODES_DEFAULT_FREQ;
     Modes.check_crc = 1;
     Modes.net_heartbeat_interval = MODES_NET_HEARTBEAT_INTERVAL;
@@ -752,61 +758,76 @@ static void *globeBinEntryPoint(void *arg) {
 }
 
 static void gainStatistics(struct mag_buf *buf) {
-    static uint64_t loudSamples;
-    static uint64_t quietSamples;
-    static uint64_t quiet2Samples;
+    static uint64_t loudEvents;
+    static uint64_t noiseLowSamples;
+    static uint64_t noiseHighSamples;
     static uint64_t totalSamples;
     static int slowRise;
     static int lastGain;
 
-    loudSamples += buf->loudSamples;
-    quietSamples += buf->quietSamples;
-    quiet2Samples += buf->quiet2Samples;
+    loudEvents += buf->loudEvents;
+    noiseLowSamples += buf->noiseLowSamples;
+    noiseHighSamples += buf->noiseHighSamples;
     totalSamples += buf->length;
 
-    if (totalSamples < 2 * Modes.sample_rate) {
+    double interval = 0.5;
+
+    if (totalSamples < interval * Modes.sample_rate) {
         return;
     }
 
-    double loudPercent = loudSamples / (double) totalSamples * 100.0;
-    double quietPercent = quietSamples / (double) totalSamples * 100.0;
-    double quiet2Percent = quiet2Samples / (double) totalSamples * 100.0;
-
-    // reset
-    loudSamples = 0;
-    quietSamples = 0;
-    quiet2Samples = 0;
-    totalSamples = 0;
+    double noiseLowPercent = noiseLowSamples / (double) totalSamples * 100.0;
+    double noiseHighPercent = noiseHighSamples / (double) totalSamples * 100.0;
 
     if (!Modes.autoGain) {
-        // don't adjust anything
-        return;
+        goto reset;
     }
 
-    if (loudPercent > 0.05 || quiet2Percent < 0.05) {
+    // 29 gain values for typical rtl-sdr
+    // allow startup to sweep entire range quickly, half it for double steps
+    int starting = getUptime() < (29 / 2.0 * interval) * SECONDS;
+
+    char *action = "";
+    int noiseLow = noiseLowPercent > 5; // too many samples < noiseLowThreshold
+    int noiseHigh = noiseHighPercent < 0.2; // too few samples < noiseHighThreshold
+    int loud = loudEvents > 1;
+    if (loud || noiseHigh) {
+        action = "decreased";
         Modes.lowerGain = 1;
-    } else if (
-            quietPercent > 10.0
-            ) {
-        if (getUptime() < 1 * MINUTES || slowRise > 10) {
+    } else if (noiseLow) {
+        if (starting || slowRise > 15 / interval) {
             slowRise = 0;
             Modes.increaseGain = 1;
+            action = "increased";
         } else {
             slowRise++;
         }
     }
+
     if (Modes.increaseGain || Modes.lowerGain) {
-        if (getUptime() < 1 * MINUTES) {
+        if (starting) {
             Modes.lowerGain *= 2;
             Modes.increaseGain *= 2;
         }
+        sdrSetGain();
         if (Modes.gain != lastGain) {
+            if (loud) {
+                fprintf(stderr, "%9s gain. loudEvents: %4lld\n", action, (long long) loudEvents);
+            } else if (noiseHigh) {
+                fprintf(stderr, "%9s gain. noise high.\n", action);
+            } else if (noiseLow) {
+                fprintf(stderr, "%9s gain. noise low.\n", action);
+            }
+            //fprintf(stderr, "%9s gain.  noiseLow: %5.2f %%  noiseHigh: %5.2f %%  loudEvents: %4lld\n", action, noiseLowPercent, noiseHighPercent, (long long) loudEvents);
             lastGain = Modes.gain;
-            fprintf(stderr, "loud: %8.4f %% quiet: %8.4f %% quiet2 %8.4f %%\n", loudPercent, quietPercent, quiet2Percent);
         }
-        sdrSetGain();
     }
 
+reset:
+    loudEvents = 0;
+    noiseLowSamples = 0;
+    noiseHighSamples = 0;
+    totalSamples = 0;
 }
 
 
@@ -1505,9 +1526,24 @@ static error_t parse_opt(int key, char *arg, struct argp_state *state) {
             Modes.dev_name = strdup(arg);
             break;
         case OptGain:
-            if (strcmp(arg, "auto") == 0) {
+            if (strcasestr(arg, "auto") == arg) {
                 Modes.autoGain = 1;
-                Modes.gain = 439;
+                char *argdup = strdup(arg);
+                tokenize(&argdup, ",", token, maxTokens);
+                if (token[1]) {
+                    Modes.gain = (int) (atof(token[1])*10); // Gain is in tens of DBs
+                } else {
+                    Modes.gain = 439;
+                }
+                if (token[2]) {
+                    Modes.noiseLowThreshold = atoi(token[2]);
+                }
+                if (token[3]) {
+                    Modes.noiseHighThreshold = atoi(token[3]);
+                }
+                if (token[4]) {
+                    Modes.loudThreshold = atoi(token[4]);
+                }
             } else {
                 Modes.gain = (int) (atof(arg)*10); // Gain is in tens of DBs
             }

readsb.h

@@ -456,9 +456,9 @@ struct mag_buf
     unsigned length; // Number of valid samples _after_ overlap. Total buffer length is buf->length + Modes.trailing_samples.
     int64_t sysTimestamp; // Estimated system time at start of block
     int64_t sysMicroseconds; // sysTimestamp in microseconds
-    uint32_t loudSamples;
-    uint32_t quietSamples;
-    uint32_t quiet2Samples;
+    uint32_t loudEvents;
+    uint32_t noiseLowSamples;
+    uint32_t noiseHighSamples;
     uint32_t padding2;
     uint16_t *data; // Magnitude data. Starts with Modes.trailing_samples worth of overlap from the previous block
 #if defined(__arm__)
@@ -536,6 +536,9 @@ struct _Modes
     int8_t increaseGain;
     int8_t lowerGain;
     int8_t autoGain;
+    uint32_t loudThreshold;
+    uint32_t noiseLowThreshold;
+    uint32_t noiseHighThreshold;
     int gain;
     int dc_filter; // should we apply a DC filter?
     int enable_agc;

sdr_rtlsdr.c

@@ -108,7 +108,8 @@ void rtlsdrSetGain() {
         int closest = getClosestGainIndex(Modes.gain);
         if (Modes.increaseGain) {
             closest += Modes.increaseGain;
-        } else if (Modes.lowerGain) {
+        }
+        if (Modes.lowerGain) {
             closest -= Modes.lowerGain;
         }
         if (closest >= RTLSDR.numgains) {