betaflight · demvlad · Jan 18, 2024 · Jan 19, 2024 · Jan 23, 2024 · Jan 24, 2024
diff --git a/Workspace/workspaces-ctzsnooze.json b/Workspace/workspaces-ctzsnooze.json
diff --git a/css/main.css b/css/main.css
diff --git a/css/menu.css b/css/menu.css
@@ -0,0 +1,102 @@
+:root {
+  --bgColor: #0fddaf;
+  --txtColor: #ffffff;
+  --borColor: rgba(0, 0, 0, 0);
+  --sizeVar: 8px;
+  --textPrimary: #4b4760;
+  --textSecondary: #7f7989;
+  --borderColor: #cccccc;
+}
+
+
+.flexDiv {
+  display: flex;
+  flex-direction: row;
+  align-items: flex-start;
+  width: fit-content;
+}
+
+.selectWrapper {
+  width: 100%;
+  position: relative;
+  padding-top: calc(var(--sizeVar) / 2);
+}
+
+.dropdown-content {
+  display: none;
+  border: 1px solid var(--borderColor);
+  box-sizing: border-box;
+  border-radius: calc(var(--sizeVar) / 2);
+  position: absolute;
+  width: auto;
+  left: 0;
+  right: 0;
+  overflow: visible;
+  background: #ffffff;
+  z-index: 300;
+  min-width: fit-content;
+}
+.dropdown-content div {
+  color: var(--textPrimary);
+  padding: 2px;
+  cursor: pointer;
+  white-space: nowrap;
+  width: auto;
+}
+
+.show { display: block;}
+
+.dropdown-content div:hover {
+  background-color: #f6f6f6;
+}
+
+.dropdown-content div:active {
+  font-style: italic;
+}
+
+.bottomBorder {
+  border-bottom: 1px solid var(--borderColor);
+}
+.topBorder {
+  border-top: 1px solid var(--borderColor);
+}
+.iconDiv {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+}
+.noSpace {
+  justify-content: flex-start;
+  gap: 6px;
+}
+.titleDiv {
+  pointer-events: none;
+  font-weight: 600;
+}
+.justHover i {
+  opacity: 0;
+}
+.justHover:hover i {
+  opacity: 1;
+}
+.dropdown-content .placeholder {
+  color: var(--textSecondary);
+  font-style: italic;
+}
+.dropdown-content .narrow {
+  padding-top: 10px;
+  padding-bottom: 10px;
+}
+.dropdown-content i {
+  color: var(--textSecondary);
+}
+.menu-button {
+  background-color: #f6f6f6;
+  font-weight: 700;
+  border: 1px solid black;
+  border-radius: 3px;
+}
+.minmax-control {
+  min-width: 60px;
+}
+
diff --git a/index.html b/index.html
@@ -17,12 +17,11 @@
     <link rel="stylesheet" href="css/keys_dialog.css">
     <link rel="stylesheet" href="css/user_settings_dialog.css">
     <link rel="stylesheet" href="node_modules/leaflet/dist/leaflet.css">
-
+    <link rel="stylesheet" href="css/menu.css">
     <script src="js/vendor/modernizr-2.6.2-respond-1.1.0.min.js"></script>
     <script src="node_modules/leaflet/dist/leaflet.js"></script>
     <script src="node_modules/leaflet-marker-rotation/src/rotatedMarker.js" type="module"></script>
     <script src="node_modules/Leaflet.MultiOptionsPolyline/Leaflet.MultiOptionsPolyline.js"></script>
-
 </head>
 
 <body>
@@ -2519,9 +2518,10 @@ <h4 class="modal-title">Shortcut Keys</h4>
                                                 <div class="key">0</div>
                                                 <div class="normal">to</div>
                                                 <div class="key">9</div>
+                                                <div class="key">S</div>
                                             </span>
                                             <div class="description">Save the current displayed graph configuration to workspace/favourite key 0 through
-                                                9 (this includes all graph smoothing and expo etc.).</div>
+                                                9 (this includes all graph smoothing, expo and min/max values etc.). The Shift-S save the configuration to current workspace.</div>
                                         </li>
                                         <li>
                                             <span class="keys">
@@ -3236,6 +3236,7 @@ <h4 class="modal-title">Advanced User Settings</h4>
     <script src="js/graph_config.js"></script>
     <script src="js/graph_legend.js"></script>
     <script src="js/workspace_selection.js"></script>
+    <script src="js/graph_minmax_setting_menu.js"></script>
     <script src="js/graph_config_dialog.js"></script>
     <script src="js/graph_spectrum_plot.js"></script>
     <script src="js/graph_spectrum_calc.js"></script>

diff --git a/js/flightlog.js b/js/flightlog.js
@@ -80,16 +80,21 @@ function FlightLog(logData) {
      * that the flightlog presents as one merged frame.
      */
     this.getStats = function(logIndex) {
-        var
-            rawStats = getRawStats(logIndex);
+        let rawStats = getRawStats(logIndex);
+
+        if (rawStats.field === undefined) {
+            rawStats.field = [];
+            for (let i = 0;  i < rawStats.frame.I.field.length; ++i) {
+                rawStats.field[i] = {
+                    min: Math.min(rawStats.frame.I.field[i].min, rawStats.frame.P.field[i].min),
+                    max: Math.max(rawStats.frame.I.field[i].max, rawStats.frame.P.field[i].max)
+                };
+            }
 
-        // Just modify the raw stats variable to add this field, the parser won't mind the extra field appearing:
-        if (rawStats.frame.S) {
-            rawStats.field = rawStats.frame.I.field.concat(rawStats.frame.S.field);
-        } else {
-            rawStats.field = rawStats.frame.I.field;
+            if (rawStats.frame.S) {
+                rawStats.field = rawStats.field.concat(rawStats.frame.S.field);
+            }
         }
-
         return rawStats;
     };
 
@@ -239,7 +244,7 @@ function FlightLog(logData) {
         if (!that.isFieldDisabled().SETPOINT) {
             fieldNames.push("rcCommands[0]", "rcCommands[1]", "rcCommands[2]", "rcCommands[3]"); // Custom calculated scaled rccommand
         }
-        if (!that.isFieldDisabled().GYRO && !that.isFieldDisabled().PID) {
+        if (!that.isFieldDisabled().GYRO && !that.isFieldDisabled().SETPOINT) {
             fieldNames.push("axisError[0]", "axisError[1]", "axisError[2]"); // Custom calculated error field
         }
 
@@ -632,7 +637,7 @@ function FlightLog(logData) {
                     }
 
                     // Add the Feedforward PID sum (P+I+D+F)
-                    if (!that.isFieldDisabled().GYRO && !that.isFieldDisabled().PID) {
+                    if (!that.isFieldDisabled().PID) {
                         for (var axis = 0; axis < 3; axis++) {
                             let pidSum =
                                 (axisPID[axis][0] !== undefined ? srcFrame[axisPID[axis][0]] : 0) +
@@ -681,7 +686,7 @@ function FlightLog(logData) {
                     }
 
                     // Calculate the PID Error
-                    if (!that.isFieldDisabled().GYRO && !that.isFieldDisabled().PID) {
+                    if (!that.isFieldDisabled().GYRO && !that.isFieldDisabled().SETPOINT) {
                         for (var axis = 0; axis < 3; axis++) {
                             let gyroADCdegrees = (gyroADC[axis] !== undefined ? that.gyroRawToDegreesPerSecond(srcFrame[gyroADC[axis]]) : 0);
                             destFrame[fieldIndex++] = destFrame[fieldIndexRcCommands + axis] - gyroADCdegrees;
@@ -1044,6 +1049,85 @@ function FlightLog(logData) {
     this.hasGpsData = function() {
         return this.getStats()?.frame?.G ? true : false;;
     };
+
+    this.getMinMaxForFieldDuringAllTime = function(field_name) {
+        let
+            stats = this.getStats(),
+            min = Number.MAX_VALUE,
+            max = -Number.MAX_VALUE;
+
+        let
+            fieldIndex = this.getMainFieldIndexByName(field_name),
+            fieldStat = fieldIndex !== undefined ? stats.field[fieldIndex] : false;
+
+        if (fieldStat) {
+            min = Math.min(min, fieldStat.min);
+            max = Math.max(max, fieldStat.max);
+        } else {
+            const mm = this.getMinMaxForFieldDuringTimeInterval(field_name, this.getMinTime(), this.getMaxTime());
+            if (mm !== undefined) {
+                min = Math.min(mm.min, min);
+                max = Math.max(mm.max, max);
+            }
+        }
+
+        return {min:min, max:max};
+    }
+
+    /**
+     * Function to compute of min and max curve values during time interval.
+     * @param field_name String: Curve fields name.
+     * @param start_time Integer: The interval start time .
+     * @end_time start_time Integer: The interval end time .
+     * @returns {min: MinValue, max: MaxValue} if success, or {min: Number.MAX_VALUE, max: Number.MAX_VALUE} if error
+     */
+    this.getMinMaxForFieldDuringTimeInterval = function(field_name, start_time, end_time) {
+        let chunks = this.getSmoothedChunksInTimeRange(start_time, end_time);
+        let startFrameIndex;
+        let minValue = Number.MAX_VALUE,
+            maxValue = -Number.MAX_VALUE;
+
+        const fieldIndex = this.getMainFieldIndexByName(field_name);
+        if (chunks.length == 0 || fieldIndex == undefined)
+            return undefined;
+
+        //Find the first sample that lies inside the window
+        for (startFrameIndex = 0; startFrameIndex < chunks[0].frames.length; startFrameIndex++) {
+            if (chunks[0].frames[startFrameIndex][FlightLogParser.prototype.FLIGHT_LOG_FIELD_INDEX_TIME] >= start_time) {
+                break;
+            }
+        }
+
+        // Pick the sample before that to begin plotting from
+        if (startFrameIndex > 0)
+            startFrameIndex--;
+
+        let frameIndex = startFrameIndex;
+        findingLoop:
+        for (let chunkIndex = 0; chunkIndex < chunks.length; chunkIndex++) {
+            const chunk = chunks[chunkIndex];
+            for (; frameIndex < chunk.frames.length; frameIndex++) {
+                const fieldValue = chunk.frames[frameIndex][fieldIndex];
+                const frameTime = chunk.frames[frameIndex][FlightLogParser.prototype.FLIGHT_LOG_FIELD_INDEX_TIME];
+                minValue = Math.min(minValue, fieldValue);
+                maxValue = Math.max(maxValue, fieldValue);
+                if(frameTime>end_time)
+                    break findingLoop;
+            }
+            frameIndex = 0;
+        }
+        return {
+            min: minValue,
+            max: maxValue
+        };
+    };
+
+    this.getCurrentLogRowsCount = function () {
+        const stats = this.getStats(this.getLogIndex());
+        const countI = stats.frame['I'] ? stats.frame['I'].totalCount : 0;
+        const countP = stats.frame['P'] ? stats.frame['P'].totalCount : 0;
+        return countI + countP;
+    };
 }
 
 FlightLog.prototype.accRawToGs = function(value) {
@@ -1054,8 +1138,6 @@ FlightLog.prototype.gyroRawToDegreesPerSecond = function(value) {
     return this.getSysConfig().gyroScale * 1000000 / (Math.PI / 180.0) * value;
 };
 
-
-
 /***
 
     The rcCommandToDegreesPerSecond function is betaflight version specific
@@ -1182,6 +1264,12 @@ FlightLog.prototype.rcCommandRawToThrottle = function(value) {
     return Math.min(Math.max(((value - this.getSysConfig().minthrottle) / (this.getSysConfig().maxthrottle - this.getSysConfig().minthrottle)) * 100.0, 0.0),100.0);
 };
 
+// rcCommandThrottle back transform function
+FlightLog.prototype.ThrottleTorcCommandRaw = function(value) {
+    // Throttle displayed as percentage
+    return  value / 100 * (this.getSysConfig().maxthrottle - this.getSysConfig().minthrottle) + this.getSysConfig().minthrottle;
+};
+
 FlightLog.prototype.rcMotorRawToPctPhysical = function(value) {
 
     // Motor displayed as percentage
@@ -1196,6 +1284,21 @@ FlightLog.prototype.rcMotorRawToPctPhysical = function(value) {
     }
     return Math.min(Math.max(motorPct, 0.0), 100.0);
 
+};
+// rcMotorRaw back transform function
+FlightLog.prototype.PctPhysicalTorcMotorRaw = function(value) {
+    // Motor displayed as percentage
+    let motorRaw;
+    if (this.isDigitalProtocol()) {
+        motorRaw = value / 100 * DSHOT_RANGE + DSHOT_MIN_VALUE;
+    } else {
+        const MAX_ANALOG_VALUE = this.getSysConfig().maxthrottle;
+        const MIN_ANALOG_VALUE = this.getSysConfig().minthrottle;
+        const ANALOG_RANGE = MAX_ANALOG_VALUE - MIN_ANALOG_VALUE;
+        motorRaw = value / 100 * ANALOG_RANGE + MIN_ANALOG_VALUE;
+    }
+    return motorRaw;
+
 };
 
 FlightLog.prototype.isDigitalProtocol = function() {
@@ -1341,4 +1444,6 @@ FlightLog.prototype.isFieldDisabled = function() {
             RPM           : (disabledFields & (1 << 12))!==0,
             GYROUNFILT    : (disabledFields & (1 << 13))!==0,
         };
+
+
 };