Scripts to Patch ArduPilot for UAV Toolbox : v1.0

Author: arunMathamkode

README.md

@@ -0,0 +1,46 @@
+# Scripts to Patch ArduPilot® for UAV Toolbox
+
+This repository provides an automation script that applies specific modifications to the ArduPilot® codebase in order to integrate a Simulink®-specific library (AC_Simulink).  
+
+This repository is designed to use alongside the UAV Toolbox Support Package for ArduPilot® Autopilots
+
+
+## Prerequisites 
+- A local checkout of the ArduCopter-4.6.2 or ArduPlane-4.6.2 repository (GPL v3).
+
+### MathWorks Products (https://www.mathworks.com)
+
+Requires MATLAB® release R2025b
+- [MATLAB®](https://www.mathworks.com/products/matlab.html)
+- [Simulink®](https://www.mathworks.com/products/simulink.html)
+- UAV Toolbox Support Package for ArduPilot® Autopilots
+
+## Installation
+Clone this repository:
+
+```
+git clone https://github.com/mathworks-robotics/scripts-patch-ardupilot-uav-toolbox
+cd scripts-patch-ardupilot-uav-toolbox
+git checkout v1.0
+```
+
+
+## Usage
+
+
+Run the automation script in MATLAB, providing the path to your local ArduPilot repository and the intended vehicle type.  
+Currently, only **`Copter`** and **`Plane`** are supported as valid vehicle types.
+
+`runArduPilotPatch(<path-to-ardupilot-repo>, 'Copter')
+`
+
+## License
+
+The license is available in the License.txt file in this GitHub repository.
+
+## Community Support
+You can post your queries on the [MATLAB Central]() page for the support package.<!--- Link to the UAV Toolbox Support package for ArduPilot Autopilots file exchange will be added when it is created-->
+You can also add your questions at [MATLAB Answers](https://www.mathworks.com/matlabcentral/answers/index).
+
+Copyright 2025 The MathWorks, Inc.
+

SECURITY.md

@@ -0,0 +1,6 @@
+# Reporting Security Vulnerabilities 
+
+If you believe you have discovered a security vulnerability, please report it to 
+[[email protected]](mailto:[email protected]). Please see 
+[MathWorks Vulnerability Disclosure Policy for Security Researchers](https://www.mathworks.com/company/aboutus/policies_statements/vulnerability-disclosure-policy.html) 
+for additional information.  

applyCodeInsertions.m

@@ -0,0 +1,120 @@
+function applyCodeInsertions(rootPath, jsonPath)
+% APPLYCODEINSERTIONS Apply code insertions/replacements described in JSON.
+%   Skips any insertion if the same TAG is already present in the target file.
+%
+%   applyCodeInsertions(rootPath, jsonPath)
+%
+% Inputs
+%   rootPath - repository root (string)
+%   jsonPath - path to JSON config (string)
+%
+% Behavior
+%   - For each file entry in JSON, reads the file into memory and processes
+%     insertions in ascending line order.
+%   - Before applying an insertion/replacement that would add a TAG block,
+%     searches the file for the start tag "<comment_style> TAG: <tag>".
+%     If found, the insertion/replacement is skipped to avoid duplicate inserts.
+%   - Writes updated file content with LF line endings.
+
+    % Load and decode the JSON configuration file
+    jsonText = fileread(jsonPath);
+    config = jsondecode(jsonText);
+
+    % Iterate over each file entry in the JSON
+    for f = 1:length(config.files)
+        fileEntry = config.files(f);
+
+        % Convert relative path to platform-specific format
+        relParts = strsplit(fileEntry.path, '/');           % Split path by '/'
+        relPath = fullfile(relParts{:});                    % Reconstruct using platform-specific separator
+        filePath = fullfile(rootPath, relPath);             % Combine with root path
+
+        % Check if the file exists before attempting to modify
+        if ~isfile(filePath)
+            error('File not found: %s', filePath);
+        end
+
+        % Determine tag prefix from JSON or fallback to default
+        if isfield(fileEntry, 'comment_style')
+            tagPrefix = strtrim(fileEntry.comment_style);   % Use specified comment style
+        else
+            tagPrefix = '//';                               % Default to C/C++ style
+        end
+
+        % Read the file content into a string array (one line per element)
+        fileContent = readlines(filePath);
+
+        % Sort insertions by line number ascending
+        % This ensures we apply edits top-to-bottom and can track line shifts correctly
+        insertions = fileEntry.insertions;
+        [~, idx] = sort([insertions.line]);
+        insertions = insertions(idx);
+
+        % Initialize line shift tracker
+        % This variable tracks how many lines have been added or removed
+        % so that subsequent operations can adjust their target line numbers
+        lineShift = 0;
+
+        % Process each insertion or replacement in order
+        for i = 1:length(insertions)
+            ins = insertions(i);
+            originalLine = ins.line;                         % Line number from JSON
+            adjustedLine = originalLine + lineShift;         % Adjusted for prior edits
+
+            codeBlock = string(ins.code);                    % Convert code block to string array
+            opType = lower(strtrim(ins.type));               % Normalize operation type
+            tag = strtrim(ins.tag);                          % Clean up tag string
+
+            %Wrap code block with tag markers using appropriate comment style
+            startTagLine = strcat(tagPrefix , " TAG: " , tag);
+            endTagLine   = strcat(tagPrefix , " END TAG: " , tag);
+            taggedBlock = [startTagLine; string(codeBlock); endTagLine];
+
+            % If the tag already exists anywhere in the file, skip this insertion
+            % We search for an exact line match of the start tag.
+            tagExistsIdx = find(fileContent == startTagLine, 1, 'first');
+            if ~isempty(tagExistsIdx)
+                fprintf('Skipping insertion for tag "%s" in %s: tag already present at line %d.\n', tag, filePath, tagExistsIdx);
+                % Do not modify fileContent or lineShift; continue to next insertion
+                continue;
+            end
+
+            % Apply the operation
+            switch opType
+                case "insert"
+                    % Insert the tagged block before the adjusted line
+                    fileContent = [fileContent(1:adjustedLine-1); taggedBlock; fileContent(adjustedLine:end)];
+                    lineShift = lineShift + length(taggedBlock);  % Update shift by number of inserted lines
+                    fprintf('Inserted tag "%s" into %s at line %d.\n', tag, filePath, adjustedLine);
+
+                case "replace"
+                    % Replace the adjusted line with the tagged block
+                    fileContent = [fileContent(1:adjustedLine-1); taggedBlock; fileContent(adjustedLine+1:end)];
+                    lineShift = lineShift + length(taggedBlock) - 1;  % Update shift by net line change
+                    fprintf('Replaced line %d in %s with tag "%s".\n', adjustedLine, filePath, tag);
+
+                otherwise
+                    error('Unknown operation type "%s" in file %s.', opType, filePath);
+            end
+        end
+
+        % Write the modified content back to the original file
+        writeLinesWithLF(fileContent, filePath);
+    end
+end
+
+function writeLinesWithLF(lines, filePath)
+    % WRITELINESWITHLF Writes lines to a file using LF-only line endings.
+    % This avoids platform-dependent CRLF endings (e.g., on Windows).
+    fid = fopen(filePath, 'w');
+    if fid == -1
+        error('Failed to open file: %s', filePath);
+    end
+
+    for i = 1:length(lines)-1
+        fprintf(fid, '%s\n', lines(i));  % Explicitly use \n for LF
+    end
+    % LF not needed for last line
+    fprintf(fid, '%s', lines(length(lines)));
+    fclose(fid);
+end

common/AC_Simulink_Base.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include <AP_Common/AP_Common.h>
+
+class AC_Simulink_Base {
+public:
+    virtual ~AC_Simulink_Base() {}
+    virtual void init() = 0;
+    virtual void update() = 0;
+    virtual void reset() = 0;
+};

common/AC_Simulink_Empty.cpp

@@ -0,0 +1,14 @@
+
+
+#include "AC_Simulink_Empty.h"
+AC_Simulink_Empty::AC_Simulink_Empty() {}
+
+void AC_Simulink_Empty::init() {
+}
+
+void AC_Simulink_Empty::update() {
+}
+
+void AC_Simulink_Empty::reset() {
+
+}

common/AC_Simulink_Empty.h

@@ -0,0 +1,18 @@
+#pragma once
+
+/// @file    AC_Simulink_Empty.h
+/// @brief   External mode implementation of Simulink integration
+
+#include "AC_Simulink_Base.h"
+
+class AC_Simulink_Empty : public AC_Simulink_Base {
+public:
+    AC_Simulink_Empty();
+    ~AC_Simulink_Empty() override {}
+
+    void init() override;
+    void update() override;
+    void reset() override;
+
+    CLASS_NO_COPY(AC_Simulink_Empty);
+};

common/AC_Simulink_Factory.cpp

@@ -0,0 +1,13 @@
+#include "AC_Simulink_Factory.h"
+
+AC_Simulink_Base* AC_Simulink_Factory::createSimulinkInstance() {
+#ifdef MW_EXTERNAL_MODE
+    return new AC_Simulink_ExtMode();
+#elif defined(MW_NORMAL_MODE)
+    return new AC_Simulink_Normal();
+#elif defined(MW_CONNECTEDIO_MODE)
+    return new AC_Simulink_ConnectedIO();
+#else   
+    return new AC_Simulink_Empty();
+#endif
+}

common/AC_Simulink_Factory.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "AC_Simulink_Base.h"
+#ifdef MW_EXTERNAL_MODE
+#include "AC_Simulink_ExtMode.h"
+#elif defined(MW_NORMAL_MODE)
+#include "AC_Simulink_Normal.h"
+#elif defined(MW_CONNECTEDIO_MODE)
+#include "AC_Simulink_ConnectedIO.h"
+#else
+#include "AC_Simulink_Empty.h"
+#endif
+class AC_Simulink_Factory {
+public:
+    static AC_Simulink_Base* createSimulinkInstance();
+};