Exemple #1
0
        /// <summary>
        /// Begin a file print
        /// </summary>
        /// <param name="fileName">File to print</param>
        /// <param name="source">Channel that requested the file to be printed</param>
        /// <returns>Code result</returns>
        public static async Task <CodeResult> Start(string fileName, CodeChannel source)
        {
            // Initialize the file
            using (await _lock.LockAsync())
            {
                if (_file != null)
                {
                    return(new CodeResult(MessageType.Error, "A file is already being printed"));
                }

                _file    = new BaseFile(fileName, CodeChannel.File);
                IsPaused = IsAborted = false;
            }

            // Wait for all pending firmware codes on the source channel to finish first
            await SPI.Interface.Flush(source);

            // Reset the resume event
            if (_resumeEvent.IsSet)
            {
                await _resumeEvent.WaitAsync();
            }

            // Analyze it and update the object model
            ParsedFileInfo info = await FileInfoParser.Parse(fileName);

            using (await Model.Provider.AccessReadWriteAsync())
            {
                Model.Provider.Get.Channels[CodeChannel.File].VolumetricExtrusion = false;
                Model.Provider.Get.Job.File.Assign(info);
            }

            // Notify RepRapFirmware and start processing the file in the background
            Console.WriteLine($"[info] Printing file '{fileName}'");
            SPI.Interface.SetPrintStarted();
            _ = Task.Run(RunPrint);

            // Return a result
            using (await Model.Provider.AccessReadOnlyAsync())
            {
                if (Model.Provider.Get.Channels[source].Compatibility == Compatibility.Marlin)
                {
                    return(new CodeResult(MessageType.Success, "File opened\nFile selected"));
                }
                else
                {
                    return(new CodeResult());
                }
            }
        }
Exemple #2
0
        public async Task TestEmpty()
        {
            string         filePath = System.IO.Path.Combine(Directory.GetCurrentDirectory(), "File/GCodes/Circle.gcode");
            ParsedFileInfo info     = await FileInfoParser.Parse(filePath);

            TestContext.Out.Write(JsonConvert.SerializeObject(info, Formatting.Indented));

            Assert.IsNotNull(info.FileName);
            Assert.AreNotEqual(0, info.Size);
            Assert.IsNotNull(info.LastModified);
            Assert.AreEqual(0, info.Height);
            Assert.AreEqual(0.5, info.FirstLayerHeight);
            Assert.AreEqual(0, info.LayerHeight);
            Assert.AreEqual(0, info.Filament.Count);
            Assert.AreEqual("", info.GeneratedBy);
            Assert.AreEqual(0, info.PrintTime);
            Assert.AreEqual(0, info.SimulatedTime);
        }
 /// <summary>
 /// Retrieves file information from the given filename
 /// </summary>
 /// <returns>File info</returns>
 public override Task <ParsedFileInfo> Execute() => FileInfoParser.Parse(FileName);
Exemple #4
0
        /// <summary>
        /// Process an M-code that should be interpreted by the control server
        /// </summary>
        /// <param name="code">Code to process</param>
        /// <returns>Result of the code if the code completed, else null</returns>
        public static async Task <CodeResult> Process(Commands.Code code)
        {
            switch (code.MajorNumber)
            {
            // Stop or Unconditional stop
            // Sleep or Conditional stop
            case 0:
            case 1:
                if (await SPI.Interface.Flush(code))
                {
                    using (await Print.LockAsync())
                    {
                        if (Print.IsFileSelected)
                        {
                            // M0/M1 may be used in a print file to terminate it
                            if (code.Channel != CodeChannel.File && !Print.IsPaused)
                            {
                                return(new CodeResult(MessageType.Error, "Pause the print before attempting to cancel it"));
                            }

                            // Invalidate the print file and make sure no more codes are read from it
                            code.CancellingPrint = true;
                            Print.Cancel();
                        }
                    }
                    break;
                }
                throw new OperationCanceledException();

            // List SD card
            case 20:
                if (await SPI.Interface.Flush(code))
                {
                    CodeParameter pParam    = code.Parameter('P');
                    string        directory = await FilePath.ToPhysicalAsync(pParam ?? "", FileDirectory.GCodes);

                    int startAt = Math.Max(code.Parameter('R') ?? 0, 0);

                    // Check if JSON file lists were requested
                    CodeParameter sParam = code.Parameter('S', 0);
                    if (sParam == 2)
                    {
                        string json = FileLists.GetFiles(pParam, directory, startAt);
                        return(new CodeResult(MessageType.Success, json));
                    }
                    if (sParam == 3)
                    {
                        string json = FileLists.GetFileList(pParam, directory, startAt);
                        return(new CodeResult(MessageType.Success, json));
                    }

                    // Print standard G-code response
                    Compatibility compatibility;
                    using (await Model.Provider.AccessReadOnlyAsync())
                    {
                        compatibility = Model.Provider.Get.Channels[code.Channel].Compatibility;
                    }

                    StringBuilder result = new StringBuilder();
                    if (compatibility == Compatibility.Me || compatibility == Compatibility.RepRapFirmware)
                    {
                        result.AppendLine("GCode files:");
                    }
                    else if (compatibility == Compatibility.Marlin || compatibility == Compatibility.NanoDLP)
                    {
                        result.AppendLine("Begin file list:");
                    }

                    int  numItems  = 0;
                    bool itemFound = false;
                    foreach (string file in Directory.EnumerateFileSystemEntries(directory))
                    {
                        if (numItems++ >= startAt)
                        {
                            string filename = Path.GetFileName(file);
                            if (compatibility == Compatibility.Marlin || compatibility == Compatibility.NanoDLP)
                            {
                                result.AppendLine(filename);
                            }
                            else
                            {
                                if (itemFound)
                                {
                                    result.Append(',');
                                }
                                result.Append($"\"{filename}\"");
                            }
                            itemFound = true;
                        }
                    }

                    if (compatibility == Compatibility.Marlin || compatibility == Compatibility.NanoDLP)
                    {
                        if (!itemFound)
                        {
                            result.AppendLine("NONE");
                        }
                        result.Append("End file list");
                    }

                    return(new CodeResult(MessageType.Success, result.ToString()));
                }
                throw new OperationCanceledException();

            // Select a file to print
            case 23:
            case 32:
                if (await SPI.Interface.Flush(code))
                {
                    string file = code.GetUnprecedentedString();
                    if (string.IsNullOrWhiteSpace(file))
                    {
                        return(new CodeResult(MessageType.Error, "Filename expected"));
                    }

                    string physicalFile = await FilePath.ToPhysicalAsync(file, FileDirectory.GCodes);

                    if (!File.Exists(physicalFile))
                    {
                        return(new CodeResult(MessageType.Error, $"Could not find file {file}"));
                    }

                    using (await Print.LockAsync())
                    {
                        if (code.Channel != CodeChannel.File && Print.IsPrinting)
                        {
                            return(new CodeResult(MessageType.Error, "Cannot set file to print, because a file is already being printed"));
                        }
                        await Print.SelectFile(physicalFile);
                    }

                    if (await code.EmulatingMarlin())
                    {
                        return(new CodeResult(MessageType.Success, "File opened\nFile selected"));
                    }
                    return(new CodeResult(MessageType.Success, $"File {file} selected for printing"));
                }
                throw new OperationCanceledException();


            // Resume a file print
            case 24:
                if (await SPI.Interface.Flush(code))
                {
                    using (await Print.LockAsync())
                    {
                        if (!Print.IsFileSelected)
                        {
                            return(new CodeResult(MessageType.Error, "Cannot print, because no file is selected!"));
                        }
                    }

                    // Let RepRapFirmware process this request so it can invoke resume.g. When M24 completes, the file is resumed
                    break;
                }
                throw new OperationCanceledException();

            // Set SD position
            case 26:
                if (await SPI.Interface.Flush(code))
                {
                    using (await Print.LockAsync())
                    {
                        if (!Print.IsFileSelected)
                        {
                            return(new CodeResult(MessageType.Error, "Not printing a file"));
                        }

                        CodeParameter sParam = code.Parameter('S');
                        if (sParam != null)
                        {
                            Print.FilePosition = sParam;
                        }
                    }

                    // P is not supported yet

                    return(new CodeResult());
                }
                throw new OperationCanceledException();

            // Report SD print status
            case 27:
                if (await SPI.Interface.Flush(code))
                {
                    using (await Print.LockAsync())
                    {
                        if (Print.IsFileSelected)
                        {
                            return(new CodeResult(MessageType.Success, $"SD printing byte {Print.FilePosition}/{Print.FileLength}"));
                        }
                        return(new CodeResult(MessageType.Success, "Not SD printing."));
                    }
                }
                throw new OperationCanceledException();

            // Begin write to SD card
            case 28:
                if (await SPI.Interface.Flush(code))
                {
                    int numChannel = (int)code.Channel;
                    using (await Commands.Code.FileLocks[numChannel].LockAsync())
                    {
                        if (Commands.Code.FilesBeingWritten[numChannel] != null)
                        {
                            return(new CodeResult(MessageType.Error, "Another file is already being written to"));
                        }

                        string file = code.GetUnprecedentedString();
                        if (string.IsNullOrWhiteSpace(file))
                        {
                            return(new CodeResult(MessageType.Error, "Filename expected"));
                        }

                        string prefix       = (await code.EmulatingMarlin()) ? "ok\n" : string.Empty;
                        string physicalFile = await FilePath.ToPhysicalAsync(file, FileDirectory.GCodes);

                        try
                        {
                            FileStream   fileStream = new FileStream(physicalFile, FileMode.Create, FileAccess.Write);
                            StreamWriter writer     = new StreamWriter(fileStream);
                            Commands.Code.FilesBeingWritten[numChannel] = writer;
                            return(new CodeResult(MessageType.Success, prefix + $"Writing to file: {file}"));
                        }
                        catch (Exception e)
                        {
                            _logger.Debug(e, "Failed to open file for writing");
                            return(new CodeResult(MessageType.Error, prefix + $"Can't open file {file} for writing."));
                        }
                    }
                }
                throw new OperationCanceledException();

            // End write to SD card
            case 29:
                if (await SPI.Interface.Flush(code))
                {
                    int numChannel = (int)code.Channel;
                    using (await Commands.Code.FileLocks[numChannel].LockAsync())
                    {
                        if (Commands.Code.FilesBeingWritten[numChannel] != null)
                        {
                            Stream stream = Commands.Code.FilesBeingWritten[numChannel].BaseStream;
                            Commands.Code.FilesBeingWritten[numChannel].Dispose();
                            Commands.Code.FilesBeingWritten[numChannel] = null;
                            stream.Dispose();

                            if (await code.EmulatingMarlin())
                            {
                                return(new CodeResult(MessageType.Success, "Done saving file."));
                            }
                            return(new CodeResult());
                        }
                        break;
                    }
                }
                throw new OperationCanceledException();

            // Delete a file on the SD card
            case 30:
                if (await SPI.Interface.Flush(code))
                {
                    string file         = code.GetUnprecedentedString();
                    string physicalFile = await FilePath.ToPhysicalAsync(file);

                    try
                    {
                        File.Delete(physicalFile);
                    }
                    catch (Exception e)
                    {
                        _logger.Debug(e, "Failed to delete file");
                        return(new CodeResult(MessageType.Error, $"Failed to delete file {file}: {e.Message}"));
                    }
                }
                throw new OperationCanceledException();

            // For case 32, see case 23

            // Return file information
            case 36:
                if (code.Parameters.Count > 0)
                {
                    if (await SPI.Interface.Flush(code))
                    {
                        string file = await FilePath.ToPhysicalAsync(code.GetUnprecedentedString());

                        try
                        {
                            ParsedFileInfo info = await FileInfoParser.Parse(file);

                            string json = JsonSerializer.Serialize(info, JsonHelper.DefaultJsonOptions);
                            return(new CodeResult(MessageType.Success, "{\"err\":0," + json.Substring(1)));
                        }
                        catch (Exception e)
                        {
                            _logger.Debug(e, "Failed to return file information");
                            return(new CodeResult(MessageType.Success, "{\"err\":1}"));
                        }
                    }
                    throw new OperationCanceledException();
                }
                break;

            // Simulate file
            case 37:
                if (await SPI.Interface.Flush(code))
                {
                    CodeParameter pParam = code.Parameter('P');
                    if (pParam != null)
                    {
                        string file = pParam;
                        if (string.IsNullOrWhiteSpace(file))
                        {
                            return(new CodeResult(MessageType.Error, "Filename expected"));
                        }

                        string physicalFile = await FilePath.ToPhysicalAsync(file, FileDirectory.GCodes);

                        if (!File.Exists(physicalFile))
                        {
                            return(new CodeResult(MessageType.Error, $"GCode file \"{file}\" not found\n"));
                        }

                        using (await Print.LockAsync())
                        {
                            if (code.Channel != CodeChannel.File && Print.IsPrinting)
                            {
                                return(new CodeResult(MessageType.Error, "Cannot set file to simulate, because a file is already being printed"));
                            }

                            await Print.SelectFile(physicalFile, true);

                            // Simulation is started when M37 has been processed by the firmware
                        }
                    }
                    break;
                }
                throw new OperationCanceledException();

            // Compute SHA1 hash of target file
            case 38:
                if (await SPI.Interface.Flush(code))
                {
                    string file         = code.GetUnprecedentedString();
                    string physicalFile = await FilePath.ToPhysicalAsync(file);

                    try
                    {
                        using FileStream stream = new FileStream(file, FileMode.Open, FileAccess.Read);

                        byte[] hash;
                        using System.Security.Cryptography.SHA1 sha1 = System.Security.Cryptography.SHA1.Create();
                        hash = await Task.Run(() => sha1.ComputeHash(stream), Program.CancelSource.Token);

                        return(new CodeResult(MessageType.Success, BitConverter.ToString(hash).Replace("-", string.Empty)));
                    }
                    catch (Exception e)
                    {
                        _logger.Debug(e, "Failed to compute SHA1 checksum");
                        if (e is AggregateException ae)
                        {
                            e = ae.InnerException;
                        }
                        return(new CodeResult(MessageType.Error, $"Could not compute SHA1 checksum for file {file}: {e.Message}"));
                    }
                }
                throw new OperationCanceledException();

            // Report SD card information
            case 39:
                if (await SPI.Interface.Flush(code))
                {
                    using (await Model.Provider.AccessReadOnlyAsync())
                    {
                        int index = code.Parameter('P', 0);
                        if (code.Parameter('S', 0) == 2)
                        {
                            if (index < 0 || index >= Model.Provider.Get.Storages.Count)
                            {
                                return(new CodeResult(MessageType.Success, $"{{\"SDinfo\":{{\"slot\":{index},present:0}}}}"));
                            }

                            Storage storage = Model.Provider.Get.Storages[index];
                            var     output  = new
                            {
                                SDinfo = new
                                {
                                    slot     = index,
                                    present  = 1,
                                    capacity = storage.Capacity,
                                    free     = storage.Free,
                                    speed    = storage.Speed
                                }
                            };
                            return(new CodeResult(MessageType.Success, JsonSerializer.Serialize(output, JsonHelper.DefaultJsonOptions)));
                        }
                        else
                        {
                            if (index < 0 || index >= Model.Provider.Get.Storages.Count)
                            {
                                return(new CodeResult(MessageType.Error, $"Bad SD slot number: {index}"));
                            }

                            Storage storage = Model.Provider.Get.Storages[index];
                            return(new CodeResult(MessageType.Success, $"SD card in slot {index}: capacity {storage.Capacity / (1000 * 1000 * 1000):F2}Gb, free space {storage.Free / (1000 * 1000 * 1000):F2}Gb, speed {storage.Speed / (1000 * 1000):F2}MBytes/sec"));
                        }
                    }
                }
                throw new OperationCanceledException();

            // Emergency Stop - unconditional and interpreteted immediately when read
            case 112:
                await SPI.Interface.RequestEmergencyStop();

                using (await Model.Provider.AccessReadWriteAsync())
                {
                    Model.Provider.Get.State.Status = MachineStatus.Halted;
                }
                return(new CodeResult());

            // Immediate DSF diagnostics
            case 122:
                if (code.Parameter('B', 0) == 0 && code.GetUnprecedentedString() == "DSF")
                {
                    CodeResult result = new CodeResult();
                    await Diagnostics(result);

                    return(result);
                }
                break;

            // Display message and optionally wait for response
            case 291:
                if (code.Parameter('S') == 2 || code.Parameter('S') == 3)
                {
                    throw new NotSupportedException();
                }
                break;

            // Save heightmap
            case 374:
                if (await SPI.Interface.Flush(code))
                {
                    string file         = code.Parameter('P', FilePath.DefaultHeightmapFile);
                    string physicalFile = await FilePath.ToPhysicalAsync(file, FileDirectory.System);

                    try
                    {
                        if (await SPI.Interface.LockMovementAndWaitForStandstill(code.Channel))
                        {
                            Heightmap map;
                            try
                            {
                                map = await SPI.Interface.GetHeightmap();
                            }
                            finally
                            {
                                await SPI.Interface.UnlockAll(code.Channel);
                            }

                            if (map.NumX * map.NumY > 0)
                            {
                                await map.Save(physicalFile);

                                string virtualFile = await FilePath.ToVirtualAsync(physicalFile);

                                using (await Model.Provider.AccessReadWriteAsync())
                                {
                                    Model.Provider.Get.Move.HeightmapFile = virtualFile;
                                }
                                return(new CodeResult(MessageType.Success, $"Height map saved to file {file}"));
                            }
                            return(new CodeResult());
                        }
                    }
                    catch (Exception e)
                    {
                        _logger.Debug(e, "Failed to save height map");
                        if (e is AggregateException ae)
                        {
                            e = ae.InnerException;
                        }
                        return(new CodeResult(MessageType.Error, $"Failed to save height map to file {file}: {e.Message}"));
                    }
                }
                throw new OperationCanceledException();

            // Load heightmap
            case 375:
                if (await SPI.Interface.Flush(code))
                {
                    string file         = code.Parameter('P', FilePath.DefaultHeightmapFile);
                    string physicalFile = await FilePath.ToPhysicalAsync(file, FileDirectory.System);

                    try
                    {
                        Heightmap map = new Heightmap();
                        await map.Load(physicalFile);

                        if (await SPI.Interface.LockMovementAndWaitForStandstill(code.Channel))
                        {
                            try
                            {
                                await SPI.Interface.SetHeightmap(map);
                            }
                            finally
                            {
                                await SPI.Interface.UnlockAll(code.Channel);
                            }

                            string virtualFile = await FilePath.ToVirtualAsync(physicalFile);

                            using (await Model.Provider.AccessReadWriteAsync())
                            {
                                Model.Provider.Get.Move.HeightmapFile = virtualFile;
                            }
                            return(new CodeResult(MessageType.Success, $"Height map loaded from file {file}"));
                        }
                    }
                    catch (Exception e)
                    {
                        _logger.Debug(e, "Failed to load height map");
                        if (e is AggregateException ae)
                        {
                            e = ae.InnerException;
                        }
                        return(new CodeResult(MessageType.Error, $"Failed to load height map from file {file}: {e.Message}"));
                    }
                }
                throw new OperationCanceledException();

            // Create Directory on SD-Card
            case 470:
                if (await SPI.Interface.Flush(code))
                {
                    string path = code.Parameter('P');
                    if (path == null)
                    {
                        return(new CodeResult(MessageType.Error, "Missing directory name"));
                    }
                    string physicalPath = await FilePath.ToPhysicalAsync(path);

                    try
                    {
                        Directory.CreateDirectory(physicalPath);
                    }
                    catch (Exception e)
                    {
                        _logger.Debug(e, "Failed to create directory");
                        return(new CodeResult(MessageType.Error, $"Failed to create directory {path}: {e.Message}"));
                    }
                }
                throw new OperationCanceledException();

            // Rename File/Directory on SD-Card
            case 471:
                if (await SPI.Interface.Flush(code))
                {
                    string from = code.Parameter('S');
                    string to   = code.Parameter('T');

                    try
                    {
                        string source = await FilePath.ToPhysicalAsync(from);

                        string destination = await FilePath.ToPhysicalAsync(to);

                        if (File.Exists(source))
                        {
                            if (File.Exists(destination) && code.Parameter('D', false))
                            {
                                File.Delete(destination);
                            }
                            File.Move(source, destination);
                        }
                        else if (Directory.Exists(source))
                        {
                            if (Directory.Exists(destination) && code.Parameter('D', false))
                            {
                                // This could be recursive but at the moment we mimic RRF's behaviour
                                Directory.Delete(destination);
                            }
                            Directory.Move(source, destination);
                        }
                        throw new FileNotFoundException();
                    }
                    catch (Exception e)
                    {
                        _logger.Debug(e, "Failed to rename file or directory");
                        return(new CodeResult(MessageType.Error, $"Failed to rename file or directory {from} to {to}: {e.Message}"));
                    }
                }
                throw new OperationCanceledException();

            // Store parameters
            case 500:
                if (await SPI.Interface.Flush(code))
                {
                    await Utility.ConfigOverride.Save(code);

                    return(new CodeResult());
                }
                throw new OperationCanceledException();

            // Print settings
            case 503:
                if (await SPI.Interface.Flush(code))
                {
                    string configFile = await FilePath.ToPhysicalAsync(FilePath.ConfigFile, FileDirectory.System);

                    if (File.Exists(configFile))
                    {
                        string content = await File.ReadAllTextAsync(configFile);

                        return(new CodeResult(MessageType.Success, content));
                    }

                    string configFileFallback = await FilePath.ToPhysicalAsync(FilePath.ConfigFileFallback, FileDirectory.System);

                    if (File.Exists(configFileFallback))
                    {
                        string content = await File.ReadAllTextAsync(configFileFallback);

                        return(new CodeResult(MessageType.Success, content));
                    }
                    return(new CodeResult(MessageType.Error, "Configuration file not found"));
                }
                throw new OperationCanceledException();

            // Set configuration file folder
            case 505:
                if (await SPI.Interface.Flush(code))
                {
                    string directory = code.Parameter('P'), physicalDirectory = await FilePath.ToPhysicalAsync(directory, "sys");

                    if (Directory.Exists(physicalDirectory))
                    {
                        string virtualDirectory = await FilePath.ToVirtualAsync(physicalDirectory);

                        using (await Model.Provider.AccessReadWriteAsync())
                        {
                            Model.Provider.Get.Directories.System = virtualDirectory;
                        }
                        return(new CodeResult());
                    }
                    return(new CodeResult(MessageType.Error, "Directory not found"));
                }
                throw new OperationCanceledException();

            // Set Name
            case 550:
                if (await SPI.Interface.Flush(code))
                {
                    // Verify the P parameter
                    string pParam = code.Parameter('P');
                    if (pParam.Length > 40)
                    {
                        return(new CodeResult(MessageType.Error, "Machine name is too long"));
                    }

                    // Strip letters and digits from the machine name
                    string machineName = string.Empty;
                    foreach (char c in Environment.MachineName)
                    {
                        if (char.IsLetterOrDigit(c))
                        {
                            machineName += c;
                        }
                    }

                    // Strip letters and digits from the desired name
                    string desiredName = string.Empty;
                    foreach (char c in pParam)
                    {
                        if (char.IsLetterOrDigit(c))
                        {
                            desiredName += c;
                        }
                    }

                    // Make sure the subset of letters and digits is equal
                    if (!machineName.Equals(desiredName, StringComparison.CurrentCultureIgnoreCase))
                    {
                        return(new CodeResult(MessageType.Error, "Machine name must consist of the same letters and digits as configured by the Linux hostname"));
                    }

                    // Hostname is legit - pretend we didn't see this code so RRF can interpret it
                    break;
                }
                throw new OperationCanceledException();

            // Configure filament
            case 703:
                if (await SPI.Interface.Flush(code))
                {
                    await Model.Updater.WaitForFullUpdate();

                    break;
                }
                throw new OperationCanceledException();

            // Set current RTC date and time
            case 905:
                if (await SPI.Interface.Flush(code))
                {
                    bool seen = false;

                    CodeParameter pParam = code.Parameter('P');
                    if (pParam != null)
                    {
                        if (DateTime.TryParseExact(pParam, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime date))
                        {
                            System.Diagnostics.Process.Start("timedatectl", $"set-time {date:yyyy-MM-dd}").WaitForExit();
                            seen = true;
                        }
                        else
                        {
                            return(new CodeResult(MessageType.Error, "Invalid date format"));
                        }
                    }

                    CodeParameter sParam = code.Parameter('S');
                    if (sParam != null)
                    {
                        if (DateTime.TryParseExact(sParam, "HH:mm:ss", CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime time))
                        {
                            System.Diagnostics.Process.Start("timedatectl", $"set-time {time:HH:mm:ss}").WaitForExit();
                            seen = true;
                        }
                        else
                        {
                            return(new CodeResult(MessageType.Error, "Invalid time format"));
                        }
                    }

                    if (!seen)
                    {
                        return(new CodeResult(MessageType.Success, $"Current date and time: {DateTime.Now:yyyy-MM-dd HH:mm:ss}"));
                    }
                }
                throw new OperationCanceledException();

            // Start/stop event logging to SD card
            case 929:
                if (await SPI.Interface.Flush(code))
                {
                    CodeParameter sParam = code.Parameter('S');
                    if (sParam == null)
                    {
                        using (await Model.Provider.AccessReadOnlyAsync())
                        {
                            return(new CodeResult(MessageType.Success, $"Event logging is {(Model.Provider.Get.State.LogFile != null ? "enabled" : "disabled")}"));
                        }
                    }

                    if (sParam > 0)
                    {
                        string file = code.Parameter('P', Utility.Logger.DefaultLogFile);
                        if (string.IsNullOrWhiteSpace(file))
                        {
                            return(new CodeResult(MessageType.Error, "Missing filename in M929 command"));
                        }

                        string physicalFile = await FilePath.ToPhysicalAsync(file, FileDirectory.System);

                        await Utility.Logger.Start(physicalFile);
                    }
                    else
                    {
                        await Utility.Logger.Stop();
                    }

                    return(new CodeResult());
                }
                throw new OperationCanceledException();

            // Update the firmware
            case 997:
                if (((int[])code.Parameter('S', new int[] { 0 })).Contains(0) && code.Parameter('B', 0) == 0)
                {
                    if (await SPI.Interface.Flush(code))
                    {
                        string iapFile, firmwareFile;
                        using (await Model.Provider.AccessReadOnlyAsync())
                        {
                            if (!string.IsNullOrEmpty(Model.Provider.Get.Electronics.ShortName))
                            {
                                // There are now two different IAP binaries, check which one to use
                                iapFile = Model.Provider.Get.Electronics.Firmware.Version.Contains("3.0beta")
                                        ? $"Duet3iap_spi_{Model.Provider.Get.Electronics.ShortName}.bin"
                                        : $"Duet3_SBCiap_{Model.Provider.Get.Electronics.ShortName}.bin";
                                firmwareFile = $"Duet3Firmware_{Model.Provider.Get.Electronics.ShortName}.bin";
                            }
                            else
                            {
                                // ShortName field is not present - this must be a really old firmware version
                                iapFile      = $"Duet3iap_spi.bin";
                                firmwareFile = "Duet3Firmware.bin";
                            }
                        }

                        iapFile = await FilePath.ToPhysicalAsync(iapFile, FileDirectory.System);

                        if (!File.Exists(iapFile))
                        {
                            return(new CodeResult(MessageType.Error, $"Failed to find IAP file {iapFile}"));
                        }

                        firmwareFile = await FilePath.ToPhysicalAsync(firmwareFile, FileDirectory.System);

                        if (!File.Exists(firmwareFile))
                        {
                            return(new CodeResult(MessageType.Error, $"Failed to find firmware file {firmwareFile}"));
                        }

                        using FileStream iapStream      = new FileStream(iapFile, FileMode.Open, FileAccess.Read);
                        using FileStream firmwareStream = new FileStream(firmwareFile, FileMode.Open, FileAccess.Read);
                        await SPI.Interface.UpdateFirmware(iapStream, firmwareStream);

                        return(new CodeResult());
                    }
                    throw new OperationCanceledException();
                }
                break;

            // Request resend of line
            case 998:
                throw new NotSupportedException();

            // Reset controller - unconditional and interpreteted immediately when read
            case 999:
                if (code.Parameters.Count == 0)
                {
                    await SPI.Interface.RequestReset();

                    return(new CodeResult());
                }
                break;
            }
            return(null);
        }
        /// <summary>
        /// Process an M-code that should be interpreted by the control server
        /// </summary>
        /// <param name="code">Code to process</param>
        /// <returns>Result of the code if the code completed, else null</returns>
        public static async Task <CodeResult> Process(Commands.Code code)
        {
            switch (code.MajorNumber)
            {
            // Cancel print
            case 0:
            case 1:
                if (Print.IsPrinting)
                {
                    await Print.Cancel();
                }
                break;

            // Select a file to print
            case 23:
            {
                string file = await FilePath.ToPhysicalAsync(code.GetUnprecedentedString(), "gcodes");

                if (File.Exists(file))
                {
                    using (await _fileToPrintLock.LockAsync())
                    {
                        _fileToPrint = file;
                    }
                    return(new CodeResult(MessageType.Success, $"File {code.GetUnprecedentedString()} selected for printing"));
                }
                return(new CodeResult(MessageType.Error, $"Could not find file {code.GetUnprecedentedString()}"));
            }

            // Resume a file print
            case 24:
                if (!Print.IsPaused)
                {
                    string file;
                    using (await _fileToPrintLock.LockAsync())
                    {
                        file = string.Copy(_fileToPrint);
                    }

                    if (string.IsNullOrEmpty(file))
                    {
                        return(new CodeResult(MessageType.Error, "Cannot print, because no file is selected!"));
                    }

                    // FIXME Emulate Marlin via "File opened\nFile selected". IMHO this should happen via a CodeChannel property
                    return(await Print.Start(file, code.Channel));
                }
                break;

            // Pause print
            case 25:
            case 226:
                if (Print.IsPrinting && !Print.IsPaused)
                {
                    // Stop sending file instructions to the firmware
                    await Print.Pause();
                }
                break;

            // Set SD position
            case 26:
            {
                CodeParameter sParam = code.Parameter('S');
                if (sParam != null)
                {
                    Print.Position = sParam;
                }
                // P is not supported yet
                return(new CodeResult());
            }

            // Report SD print status
            case 27:
                if (Print.IsPrinting)
                {
                    return(new CodeResult(MessageType.Success, $"SD printing byte {Print.Position}/{Print.Length}"));
                }
                return(new CodeResult(MessageType.Success, "Not SD printing."));

            // Delete a file on the SD card
            case 30:
            {
                string file = code.GetUnprecedentedString();
                try
                {
                    File.Delete(await FilePath.ToPhysicalAsync(file));
                    return(new CodeResult());
                }
                catch (Exception e)
                {
                    return(new CodeResult(MessageType.Error, $"Failed to delete file {file}: {e.Message}"));
                }
            }

            // Start a file print
            case 32:
            {
                string file = await FilePath.ToPhysicalAsync(code.GetUnprecedentedString(), "gcodes");

                if (File.Exists(file))
                {
                    using (await _fileToPrintLock.LockAsync())
                    {
                        _fileToPrint = file;
                    }
                    return(await Print.Start(file, code.Channel));
                }
                return(new CodeResult(MessageType.Error, $"Could not find file {code.GetUnprecedentedString()}"));
            }

            // Return file information
            case 36:
                if (code.Parameters.Count > 0)
                {
                    try
                    {
                        string file = await FilePath.ToPhysicalAsync(code.GetUnprecedentedString());

                        ParsedFileInfo info = await FileInfoParser.Parse(file);

                        string json = JsonConvert.SerializeObject(info, JsonHelper.DefaultSettings);
                        return(new CodeResult(MessageType.Success, "{\"err\":0," + json.Substring(1)));
                    }
                    catch
                    {
                        return(new CodeResult(MessageType.Success, "{\"err\":1}"));
                    }
                }
                break;

            // Simulate file
            case 37:
                // TODO: Check if file exists
                // TODO: Execute and await pseudo-M37 with IsPreProcessed = true so the firmware enters the right simulation state
                // TODO: Start file print
                return(new CodeResult(MessageType.Warning, "M37 is not supported yet"));

            // Compute SHA1 hash of target file
            case 38:
            {
                string file = await FilePath.ToPhysicalAsync(code.GetUnprecedentedString());

                try
                {
                    using (FileStream stream = new FileStream(file, FileMode.Open, FileAccess.Read))
                    {
                        byte[] hash;
                        using (var sha1 = System.Security.Cryptography.SHA1.Create())
                        {
                            hash = await Task.Run(() => sha1.ComputeHash(stream), Program.CancelSource.Token);
                        }
                        return(new CodeResult(MessageType.Success, BitConverter.ToString(hash).Replace("-", "")));
                    }
                }
                catch (AggregateException ae)
                {
                    return(new CodeResult(MessageType.Error, $"Could not compute SHA1 checksum for file {file}: {ae.InnerException.Message}"));
                }
            }

            // Report SD card information
            case 39:
                using (await Model.Provider.AccessReadOnlyAsync())
                {
                    int index = code.Parameter('P', 0);
                    if (code.Parameter('S', 0) == 2)
                    {
                        if (index < 0 || index >= Model.Provider.Get.Storages.Count)
                        {
                            return(new CodeResult(MessageType.Success, $"{{\"SDinfo\":{{\"slot\":{index},present:0}}}}"));
                        }

                        Storage storage = Model.Provider.Get.Storages[index];
                        var     output  = new
                        {
                            SDinfo = new
                            {
                                slot     = index,
                                present  = 1,
                                capacity = storage.Capacity,
                                free     = storage.Free,
                                speed    = storage.Speed
                            }
                        };
                        return(new CodeResult(MessageType.Success, JsonConvert.SerializeObject(output)));
                    }
                    else
                    {
                        if (index < 0 || index >= Model.Provider.Get.Storages.Count)
                        {
                            return(new CodeResult(MessageType.Error, $"Bad SD slot number: {index}"));
                        }

                        Storage storage = Model.Provider.Get.Storages[index];
                        return(new CodeResult(MessageType.Success, $"SD card in slot {index}: capacity {storage.Capacity / (1000 * 1000 * 1000):F2}Gb, free space {storage.Free / (1000 * 1000 * 1000):F2}Gb, speed {storage.Speed / (1000 * 1000):F2}MBytes/sec"));
                    }
                }

            // Emergency Stop
            case 112:
                await SPI.Interface.RequestEmergencyStop();

                using (await Model.Provider.AccessReadWriteAsync())
                {
                    Model.Provider.Get.State.Status = MachineStatus.Halted;
                }
                return(new CodeResult());

            // Immediate DSF diagnostics
            case 122:
                if (code.GetUnprecedentedString() == "DSF")
                {
                    CodeResult result = new CodeResult();
                    await Diagnostics(result);

                    return(result);
                }
                break;

            // Message box acknowledgement
            case 292:
                code.Flags |= CodeFlags.IsPrioritized;
                break;

            // Save heightmap
            case 374:
            {
                string file = code.Parameter('P', FilePath.DefaultHeightmapFile);

                try
                {
                    Heightmap map = await SPI.Interface.GetHeightmap();

                    await map.Save(await FilePath.ToPhysicalAsync(file, "sys"));

                    return(new CodeResult(MessageType.Success, $"Height map saved to file {file}"));
                }
                catch (AggregateException ae)
                {
                    return(new CodeResult(MessageType.Error, $"Failed to save height map to file {file}: {ae.InnerException.Message}"));
                }
            }

            // Load heightmap
            case 375:
            {
                string file = await FilePath.ToPhysicalAsync(code.Parameter('P', FilePath.DefaultHeightmapFile), "sys");

                try
                {
                    Heightmap map = new Heightmap();
                    await map.Load(file);

                    await SPI.Interface.SetHeightmap(map);

                    return(new CodeResult());
                }
                catch (AggregateException ae)
                {
                    return(new CodeResult(MessageType.Error, $"Failed to load height map from file {file}: {ae.InnerException.Message}"));
                }
            }

            // Create Directory on SD-Card
            case 470:
            {
                string path = code.Parameter('P', "");
                try
                {
                    Directory.CreateDirectory(await FilePath.ToPhysicalAsync(path));
                    return(new CodeResult());
                }
                catch (Exception e)
                {
                    return(new CodeResult(MessageType.Error, $"Failed to create directory {path}: {e.Message}"));
                }
            }

            // Rename File/Directory on SD-Card
            case 471:
            {
                string from = code.Parameter('S');
                string to   = code.Parameter('T');

                try
                {
                    string source = await FilePath.ToPhysicalAsync(from);

                    string destination = await FilePath.ToPhysicalAsync(to);

                    if (File.Exists(source))
                    {
                        if (File.Exists(destination) && code.Parameter('D', false))
                        {
                            File.Delete(destination);
                        }
                        File.Move(source, destination);
                    }
                    else if (Directory.Exists(source))
                    {
                        if (Directory.Exists(destination) && code.Parameter('D', false))
                        {
                            // This could be recursive but at the moment we mimic RRF's behaviour
                            Directory.Delete(destination);
                        }
                        Directory.Move(source, destination);
                    }
                    throw new FileNotFoundException();
                }
                catch (Exception e)
                {
                    return(new CodeResult(MessageType.Error, $"Failed to rename file or directory {from} to {to}: {e.Message}"));
                }
            }

            // Store parameters
            case 500:
                await Utility.ConfigOverride.Save(code);

                break;

            // Print settings
            case 503:
            {
                string configFile = await FilePath.ToPhysicalAsync(FilePath.ConfigFile, "sys");

                if (File.Exists(configFile))
                {
                    string content = await File.ReadAllTextAsync(configFile);

                    return(new CodeResult(MessageType.Success, content));
                }
                configFile = await FilePath.ToPhysicalAsync(FilePath.ConfigFileFallback, "sys");

                if (File.Exists(configFile))
                {
                    string content = await File.ReadAllTextAsync(configFile);

                    return(new CodeResult(MessageType.Success, content));
                }
                return(new CodeResult(MessageType.Error, "Configuration file not found"));
            }

            // Set Name
            case 550:
            {
                // Verify the P parameter
                string pParam = code.Parameter('P');
                if (pParam.Length > 40)
                {
                    return(new CodeResult(MessageType.Error, "Machine name is too long"));
                }

                // Strip letters and digits from the machine name
                string machineName = "";
                foreach (char c in Environment.MachineName)
                {
                    if (char.IsLetterOrDigit(c))
                    {
                        machineName += c;
                    }
                }

                // Strip letters and digits from the desired name
                string desiredName = "";
                foreach (char c in pParam)
                {
                    if (char.IsLetterOrDigit(c))
                    {
                        desiredName += c;
                    }
                }

                // Make sure the subset of letters and digits is equal
                if (!machineName.Equals(desiredName, StringComparison.CurrentCultureIgnoreCase))
                {
                    return(new CodeResult(MessageType.Error, "Machine name must consist of the same letters and digits as configured by the Linux hostname"));
                }
            }
            break;

            // Set current RTC date and time
            case 905:
            {
                bool seen = false;

                CodeParameter pParam = code.Parameter('P');
                if (pParam != null)
                {
                    if (DateTime.TryParseExact(pParam, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime date))
                    {
                        System.Diagnostics.Process.Start("timedatectl", $"set-time {date:yyyy-MM-dd}").WaitForExit();
                        seen = true;
                    }
                    else
                    {
                        return(new CodeResult(MessageType.Error, "Invalid date format"));
                    }
                }

                CodeParameter sParam = code.Parameter('S');
                if (sParam != null)
                {
                    if (DateTime.TryParseExact(sParam, "HH:mm:ss", CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime time))
                    {
                        System.Diagnostics.Process.Start("timedatectl", $"set-time {time:HH:mm:ss}").WaitForExit();
                        seen = true;
                    }
                    else
                    {
                        return(new CodeResult(MessageType.Error, "Invalid time format"));
                    }
                }

                if (!seen)
                {
                    return(new CodeResult(MessageType.Success, $"Current date and time: {DateTime.Now:yyyy-MM-dd HH:mm:ss}"));
                }
            }
            break;

            // Start/stop event logging to SD card
            case 929:
            {
                CodeParameter sParam = code.Parameter('S');
                if (sParam == null)
                {
                    using (await Model.Provider.AccessReadOnlyAsync())
                    {
                        return(new CodeResult(MessageType.Success, $"Event logging is {(Model.Provider.Get.State.LogFile != null ? "enabled" : "disabled")}"));
                    }
                }

                if (sParam > 0)
                {
                    string filename = code.Parameter('P', Utility.Logger.DefaultLogFile);
                    if (string.IsNullOrWhiteSpace(filename))
                    {
                        return(new CodeResult(MessageType.Error, "Missing filename in M929 command"));
                    }

                    using (await Model.Provider.AccessReadWriteAsync())
                    {
                        string physicalFilename = await FilePath.ToPhysicalAsync(filename, "sys");

                        await Utility.Logger.Start(physicalFilename);

                        Model.Provider.Get.State.LogFile = filename;
                    }

                    return(new CodeResult());
                }

                using (await Model.Provider.AccessReadWriteAsync())
                {
                    await Utility.Logger.Stop();

                    Model.Provider.Get.State.LogFile = null;
                }
                return(new CodeResult());
            }

            // Update the firmware
            case 997:
                if (((int[])code.Parameter('S', new int[] { 0 })).Contains(0))
                {
                    string iapFile = await FilePath.ToPhysicalAsync(Settings.IapFile, "sys");

                    if (!File.Exists(iapFile))
                    {
                        return(new CodeResult(MessageType.Error, $"Failed to find IAP file {iapFile}"));
                    }

                    string firmwareFile = await FilePath.ToPhysicalAsync(code.Parameter('P') ?? Settings.FirmwareFile, "sys");

                    if (!File.Exists(firmwareFile))
                    {
                        return(new CodeResult(MessageType.Error, $"Failed to find firmware file {code.Parameter('P') ?? Settings.FirmwareFile}"));
                    }

                    FileStream iapStream      = new FileStream(iapFile, FileMode.Open, FileAccess.Read);
                    FileStream firmwareStream = new FileStream(firmwareFile, FileMode.Open, FileAccess.Read);
                    SPI.Interface.UpdateFirmware(iapStream, firmwareStream);
                }
                // TODO: Implement mechanism for expansion boards
                return(new CodeResult());

            // Reset controller
            case 999:
                if (code.Parameters.Count == 0)
                {
                    await SPI.Interface.RequestReset();

                    return(new CodeResult());
                }
                break;
            }
            return(null);
        }
Exemple #6
0
        /// <summary>
        /// Process an M-code that should be interpreted by the control server
        /// </summary>
        /// <param name="code">Code to process</param>
        /// <returns>Result of the code if the code completed, else null</returns>
        public static async Task <CodeResult> Process(Commands.Code code)
        {
            switch (code.MajorNumber)
            {
            // Cancel print
            case 0:
            case 1:
                if (Print.IsPrinting)
                {
                    await Print.Cancel();
                }
                break;

            // Select a file to print
            case 23:
            {
                string file = await FilePath.ToPhysical(code.GetUnprecedentedString(), "gcodes");

                if (File.Exists(file))
                {
                    using (await _fileToPrintLock.LockAsync())
                    {
                        _fileToPrint = file;
                    }
                    return(new CodeResult(MessageType.Success, $"File {file} selected for printing"));
                }
                return(new CodeResult(MessageType.Error, $"Could not find file {file}"));
            }

            // Resume a file print
            case 24:
                if (!Print.IsPaused)
                {
                    string file;
                    using (await _fileToPrintLock.LockAsync())
                    {
                        file = string.Copy(_fileToPrint);
                    }

                    if (string.IsNullOrEmpty(file))
                    {
                        return(new CodeResult(MessageType.Error, "Cannot print, because no file is selected!"));
                    }

                    // FIXME Emulate Marlin via "File opened\nFile selected". IMHO this should happen via a CodeChannel property
                    return(await Print.Start(file, code.Channel));
                }
                break;

            // Pause print
            case 25:
            case 226:
                if (Print.IsPrinting && !Print.IsPaused)
                {
                    // Stop sending file instructions to the firmware
                    await Print.Pause();
                }
                break;

            // Set SD position
            case 26:
            {
                CodeParameter sParam = code.Parameter('S');
                if (sParam != null)
                {
                    Print.Position = sParam;
                }
                // P is not supported yet
                return(new CodeResult());
            }

            // Report SD print status
            case 27:
                if (Print.IsPrinting)
                {
                    return(new CodeResult(MessageType.Success, $"SD printing byte {Print.Position}/{Print.Length}"));
                }
                return(new CodeResult(MessageType.Success, "Not SD printing."));

            // Delete a file on the SD card
            case 30:
            {
                string file = code.GetUnprecedentedString();
                try
                {
                    File.Delete(await FilePath.ToPhysical(file));
                    return(new CodeResult());
                }
                catch (Exception e)
                {
                    return(new CodeResult(MessageType.Error, $"Failed to delete file {file}: {e.Message}"));
                }
            }

            // Start a file print
            case 32:
            {
                string file = await FilePath.ToPhysical(code.GetUnprecedentedString(), "gcodes");

                using (await _fileToPrintLock.LockAsync())
                {
                    _fileToPrint = file;
                }
                return(await Print.Start(file, code.Channel));
            }

            // Return file information
            case 36:
                if (code.Parameters.Count > 0)
                {
                    try
                    {
                        string file = await FilePath.ToPhysical(code.GetUnprecedentedString());

                        ParsedFileInfo info = await FileInfoParser.Parse(file);

                        string json = JsonConvert.SerializeObject(info, JsonHelper.DefaultSettings);
                        return(new CodeResult(MessageType.Success, "{\"err\":0," + json.Substring(1)));
                    }
                    catch
                    {
                        return(new CodeResult(MessageType.Success, "{\"err\":1}"));
                    }
                }
                break;

            // Simulate file
            case 37:
                // TODO: Check if file exists
                // TODO: Execute and await pseudo-M37 with IsPreProcessed = true so the firmware enters the right simulation state
                // TODO: Start file print
                return(new CodeResult(MessageType.Warning, "M37 is not supported yet"));

            // Compute SHA1 hash of target file
            case 38:
            {
                string file = await FilePath.ToPhysical(code.GetUnprecedentedString());

                try
                {
                    using (FileStream stream = new FileStream(file, FileMode.Open, FileAccess.Read))
                    {
                        var    sha1 = System.Security.Cryptography.SHA1.Create();
                        byte[] hash = await Task.Run(() => sha1.ComputeHash(stream), Program.CancelSource.Token);

                        return(new CodeResult(MessageType.Success, BitConverter.ToString(hash).Replace("-", "")));
                    }
                }
                catch (AggregateException ae)
                {
                    return(new CodeResult(MessageType.Error, $"Could not compute SHA1 checksum for file {file}: {ae.InnerException.Message}"));
                }
            }

            // Report SD card information
            case 39:
                using (await Model.Provider.AccessReadOnlyAsync())
                {
                    int index = code.Parameter('P', 0);
                    if (code.Parameter('S', 0) == 2)
                    {
                        if (index < 0 || index >= Model.Provider.Get.Storages.Count)
                        {
                            return(new CodeResult(MessageType.Success, $"{{\"SDinfo\":{{\"slot\":{index},present:0}}}}"));
                        }

                        Storage storage = Model.Provider.Get.Storages[index];
                        var     output  = new
                        {
                            SDinfo = new
                            {
                                slot     = index,
                                present  = 1,
                                capacity = storage.Capacity,
                                free     = storage.Free,
                                speed    = storage.Speed
                            }
                        };
                        return(new CodeResult(MessageType.Success, JsonConvert.SerializeObject(output)));
                    }
                    else
                    {
                        if (index < 0 || index >= Model.Provider.Get.Storages.Count)
                        {
                            return(new CodeResult(MessageType.Error, $"Bad SD slot number: {index}"));
                        }

                        Storage storage = Model.Provider.Get.Storages[index];
                        return(new CodeResult(MessageType.Success, $"SD card in slot {index}: capacity {storage.Capacity / (1000 * 1000 * 1000):F2}Gb, free space {storage.Free / (1000 * 1000 * 1000):F2}Gb, speed {storage.Speed / (1000*1000):F2}MBytes/sec"));
                    }
                }

            // Return from macro
            case 99:
                if (!MacroFile.AbortLastFile(code.Channel))
                {
                    return(new CodeResult(MessageType.Error, "Not executing a macro file"));
                }
                return(new CodeResult());

            // Emergency Stop
            case 112:
                await SPI.Interface.RequestEmergencyStop();

                using (await Model.Provider.AccessReadWriteAsync())
                {
                    Model.Provider.Get.State.Status = MachineStatus.Halted;
                }
                return(new CodeResult());

            // Immediate DSF diagnostics
            case 122:
                if (code.GetUnprecedentedString() == "DSF")
                {
                    CodeResult result = new CodeResult();
                    await Diagnostics(result);

                    return(result);
                }
                break;

            // Save heightmap
            case 374:
            {
                string file = code.Parameter('P', "heightmap.csv");

                try
                {
                    Heightmap map = await SPI.Interface.GetHeightmap();

                    await map.Save(await FilePath.ToPhysical(file, "sys"));

                    return(new CodeResult(MessageType.Success, $"Height map saved to file {file}"));
                }
                catch (AggregateException ae)
                {
                    return(new CodeResult(MessageType.Error, $"Failed to save height map to file {file}: {ae.InnerException.Message}"));
                }
            }

            // Load heightmap
            case 375:
            {
                string file = await FilePath.ToPhysical(code.Parameter('P', "heightmap.csv"), "sys");

                try
                {
                    Heightmap map = new Heightmap();
                    await map.Load(file);

                    await SPI.Interface.SetHeightmap(map);

                    return(new CodeResult());
                }
                catch (AggregateException ae)
                {
                    return(new CodeResult(MessageType.Error, $"Failed to load height map from file {file}: {ae.InnerException.Message}"));
                }
            }

            // Create Directory on SD-Card
            case 470:
            {
                string path = code.Parameter('P', "");
                try
                {
                    Directory.CreateDirectory(await FilePath.ToPhysical(path));
                    return(new CodeResult());
                }
                catch (Exception e)
                {
                    return(new CodeResult(MessageType.Error, $"Failed to create directory {path}: {e.Message}"));
                }
            }

            // Rename File/Directory on SD-Card
            case 471:
            {
                string from = code.Parameter('S');
                string to   = code.Parameter('T');

                try
                {
                    string source = await FilePath.ToPhysical(from);

                    string destination = await FilePath.ToPhysical(to);

                    if (File.Exists(source))
                    {
                        if (File.Exists(destination) && code.Parameter('D', false))
                        {
                            File.Delete(destination);
                        }
                        File.Move(source, destination);
                    }
                    else if (Directory.Exists(source))
                    {
                        if (Directory.Exists(destination) && code.Parameter('D', false))
                        {
                            // This could be recursive but at the moment we mimic RRF's behaviour
                            Directory.Delete(destination);
                        }
                        Directory.Move(source, destination);
                    }
                    throw new FileNotFoundException();
                }
                catch (Exception e)
                {
                    return(new CodeResult(MessageType.Error, $"Failed to rename file or directory {from} to {to}: {e.Message}"));
                }
            }

            // Store parameters
            case 500:
                await Utility.ConfigOverride.Save(code);

                break;

            // Print settings
            case 503:
            {
                string configFile = await FilePath.ToPhysical(MacroFile.ConfigFile, "sys");

                if (File.Exists(configFile))
                {
                    string content = await File.ReadAllTextAsync(configFile);

                    return(new CodeResult(MessageType.Success, content));
                }
                return(new CodeResult(MessageType.Error, "Configuration file not found"));
            }

            // Reset controller
            case 999:
                if (code.Parameters.Count == 0)
                {
                    await SPI.Interface.RequestReset();

                    return(new CodeResult());
                }
                break;
            }
            return(null);
        }