Basic Reading Implementation (untested)

Author: RobertPendergrast

FprimeZephyrReference/Components/CMakeLists.txt

@@ -10,4 +10,4 @@ add_fprime_subdirectory("${CMAKE_CURRENT_LIST_DIR}/Burnwire/")
 add_fprime_subdirectory("${CMAKE_CURRENT_LIST_DIR}/BootloaderTrigger/")
 add_fprime_subdirectory("${CMAKE_CURRENT_LIST_DIR}/AntennaDeployer/")
 add_fprime_subdirectory("${CMAKE_CURRENT_LIST_DIR}/FsSpace/")
-add_fprime_subdirectory("${CMAKE_CURRENT_LIST_DIR}/CameraManager/")
+add_fprime_subdirectory("${CMAKE_CURRENT_LIST_DIR}/PayloadHandler/")

FprimeZephyrReference/Components/CameraManager/CameraManager.cpp

@@ -16,20 +16,20 @@
 
 register_fprime_library(
     AUTOCODER_INPUTS
-        "${CMAKE_CURRENT_LIST_DIR}/CameraManager.fpp"
+        "${CMAKE_CURRENT_LIST_DIR}/PayloadHandler.fpp"
     SOURCES
-        "${CMAKE_CURRENT_LIST_DIR}/CameraManager.cpp"
+        "${CMAKE_CURRENT_LIST_DIR}/PayloadHandler.cpp"
 #   DEPENDS
 #       MyPackage_MyOtherModule
 )
 
 ### Unit Tests ###
 # register_fprime_ut(
 #     AUTOCODER_INPUTS
-#         "${CMAKE_CURRENT_LIST_DIR}/CameraManager.fpp"
+#         "${CMAKE_CURRENT_LIST_DIR}/PayloadHandler.fpp"
 #     SOURCES
-#         "${CMAKE_CURRENT_LIST_DIR}/test/ut/CameraManagerTestMain.cpp"
-#         "${CMAKE_CURRENT_LIST_DIR}/test/ut/CameraManagerTester.cpp"
+#         "${CMAKE_CURRENT_LIST_DIR}/test/ut/PayloadHandlerTestMain.cpp"
+#         "${CMAKE_CURRENT_LIST_DIR}/test/ut/PayloadHandlerTester.cpp"
 #     DEPENDS
 #         STest # For rules-based testing
 #     UT_AUTO_HELPERS

FprimeZephyrReference/Components/CameraManager/CameraManager.hpp

@@ -0,0 +1,140 @@
+// ======================================================================
+// \title  PayloadHandler.cpp
+// \author robertpendergrast
+// \brief  cpp file for PayloadHandler component implementation class
+// ======================================================================
+#include "Os/File.hpp"
+#include "FprimeZephyrReference/Components/PayloadHandler/PayloadHandler.hpp"
+
+namespace Components {
+
+// ----------------------------------------------------------------------
+// Component construction and destruction
+// ----------------------------------------------------------------------
+
+PayloadHandler ::PayloadHandler(const char* const compName) : PayloadHandlerComponentBase(compName) {}
+PayloadHandler ::~PayloadHandler() {}
+
+
+// ----------------------------------------------------------------------
+// Handler implementations for typed input ports
+// ----------------------------------------------------------------------
+
+
+void PayloadHandler ::in_port_handler(FwIndexType portNum, Fw::Buffer& buffer, const Drv::ByteStreamStatus& status) {
+
+    const U8* data = buffer.getData();
+    FwSizeType size = buffer.getSize();
+
+    for (FwSizeType i = 0; i < size; i++) {
+        // Process each byte of data as needed
+        U8 byte = data[i];
+
+
+        if (!m_receiving){
+            // We are not currently receiving a file
+
+            // Append byte to line buffer: This is how we check the header to determine data type
+            if (m_lineIndex < sizeof(m_lineBuffer) - 1) {
+                m_lineBuffer[m_lineIndex++] = byte;
+            }
+
+            // Have we reached the end of the line? If so that means we have a header
+            // Check to see what the header is. 
+            if (byte == '\n' || byte == '\r') {
+                m_lineBuffer[m_lineIndex] = 0; // Null-terminate
+                m_lineIndex = 0;
+
+                // Check the header.
+                // Right now I'm just checking for an image start tag, but we can expand this to other types later
+                if (strstr((const char*)m_lineBuffer, "<IMG_START>")) {
+                    m_receiving = true;
+                    m_bytes_received = 0;
+                    m_expected_size = 0;
+                    continue; 
+                }
+
+                // If in receiving mode and expected size not set, this line is the size
+                if (m_receiving && m_expected_size == 0) {
+
+                    // First we set the expected size
+                    m_expected_size = atoi((const char*)m_lineBuffer);
+
+
+                    // Then we open the file to write to, which we will be writing to over a lot of iterations
+                    if (m_data_file_count >= 9) {
+                        m_data_file_count = 0;
+                    }
+
+                    char filenameBuffer[20];
+                    snprintf(filenameBuffer, sizeof(filenameBuffer), "payload_%d.jpg", m_data_file_count);
+                    m_currentFilename = filenameBuffer;
+
+                    // Open the file and prepare to write in the next iteration
+                    Os::File::Status fileStatus = m_file.open(m_currentFilename.c_str(), Os::File::OPEN_CREATE, Os::File::OVERWRITE);
+                    if (fileStatus != Os::File::OP_OK) {
+                        m_receiving = false;
+                        continue;
+                    }
+                    continue;
+                }
+            }
+
+
+        } else if (m_bytes_received < m_expected_size){
+            // We are currently receiving a file
+
+            // Cast byte to a buffer
+            // Write a byte to the file
+            FwSizeType oneByte = 1;
+            m_file.write(&byte, oneByte);
+            m_bytes_received++;
+
+            // Check to see if we are done receiving
+            if (m_bytes_received >= m_expected_size){
+                m_file.flush();
+                m_file.close();
+                m_receiving = false;   
+                m_data_file_count++;
+
+                // Log data received event
+                Fw::LogStringArg logPath(m_currentFilename.c_str());
+                this->log_ACTIVITY_HI_DataReceived(m_bytes_received, logPath);
+            }
+        }
+    }
+}
+
+// ----------------------------------------------------------------------
+// Handler implementations for commands
+// ----------------------------------------------------------------------
+
+void PayloadHandler ::SEND_COMMAND_cmdHandler(FwOpcodeType opCode, U32 cmdSeq, const Fw::CmdStringArg& cmd) {
+
+    // Append newline to command to send over UART
+    Fw::CmdStringArg tempCmd = cmd;  
+    tempCmd += "\n";                  
+    Fw::Buffer commandBuffer(
+        reinterpret_cast<U8*>(const_cast<char*>(tempCmd.toChar())), 
+        tempCmd.length()
+    );
+
+    // Send command over output port
+    Drv::ByteStreamStatus sendStatus = this->out_port_out(0, commandBuffer);
+
+    Fw::LogStringArg logCmd(cmd);
+    
+    // Log success or failure
+    if (sendStatus != Drv::ByteStreamStatus::OP_OK) {
+        this->log_WARNING_HI_CommandError(logCmd);
+        this->cmdResponse_out(opCode, cmdSeq, Fw::CmdResponse::EXECUTION_ERROR);
+        return;
+    }
+    else {
+        this->log_ACTIVITY_HI_CommandSuccess(logCmd);
+    }
+
+    this->cmdResponse_out(opCode, cmdSeq, Fw::CmdResponse::OK);
+}
+
+}  // namespace Components

FprimeZephyrReference/Components/CameraManager/CMakeLists.txt renamed to FprimeZephyrReference/Components/PayloadHandler/CMakeLists.txt

@@ -1,18 +1,22 @@
 module Components {
     @ Manager for Nicla Vision
-    passive component CameraManager {
+    passive component PayloadHandler {
 
         # One async command/port is required for active components
         # This should be overridden by the developers with a useful command/port
         @ TODO
-        sync command TAKE_IMAGE
+        sync command SEND_COMMAND(cmd: string)  # Command to send data over UART
 
-        event TakeImageError() severity warning high format "Failed to take picture"
+        event CommandError(cmd: string) severity warning high format "Failed to send {} command over UART"
 
-        event PictureTaken() severity activity high format "Picture Taken"
+        event CommandSuccess(cmd: string) severity activity high format "Command {} sent successfully"
+
+        event DataReceived( data: U8, path: string) severity activity high format "Stored {} bytes of payload data to {}"
 
         output port out_port: Drv.ByteStreamSend
 
+        sync input port in_port: Drv.ByteStreamData  
+
         ##############################################################################
         #### Uncomment the following examples to start customizing your component ####
         ##############################################################################

FprimeZephyrReference/Components/PayloadHandler/PayloadHandler.cpp

@@ -0,0 +1,66 @@
+// ======================================================================
+// \title  PayloadHandler.hpp
+// \author robertpendergrast
+// \brief  hpp file for PayloadHandler component implementation class
+// ======================================================================
+
+#ifndef FprimeZephyrReference_PayloadHandler_HPP
+#define FprimeZephyrReference_PayloadHandler_HPP
+
+#include <string>
+#include <cstddef>
+#include "Os/File.hpp"
+#include "FprimeZephyrReference/Components/PayloadHandler/PayloadHandlerComponentAc.hpp"
+
+namespace Components {
+
+class PayloadHandler final : public PayloadHandlerComponentBase {
+  public:
+    // ----------------------------------------------------------------------
+    // Component construction and destruction
+    // ----------------------------------------------------------------------
+
+    //! Construct PayloadHandler object
+    PayloadHandler(const char* const compName  //!< The component name
+    );
+
+    //! Destroy PayloadHandler object
+    ~PayloadHandler();
+
+    U8 m_data_file_count = 0;
+    bool m_receiving = false; 
+    U32 m_expected_size = 0;
+    U32 m_bytes_received = 0;
+
+    U8 m_lineBuffer[128];
+    size_t m_lineIndex = 0;
+    Os::File m_file;
+    std::string m_currentFilename;
+
+  private:
+    // ----------------------------------------------------------------------
+    // Handler implementations for typed input ports
+    // ----------------------------------------------------------------------
+
+    //! Handler implementation for in_port
+     //! Handler implementation for in_port
+    void in_port_handler(FwIndexType portNum,  //!< The port number
+                         Fw::Buffer& buffer,
+                         const Drv::ByteStreamStatus& status);
+
+  private:
+    // ----------------------------------------------------------------------
+    // Handler implementations for commands
+    // ----------------------------------------------------------------------
+
+    //! Handler implementation for command SEND_COMMAND
+    //!
+    //! TODO
+    void SEND_COMMAND_cmdHandler(FwOpcodeType opCode,  //!< The opcode
+                                 U32 cmdSeq,           //!< The command sequence number
+                                 const Fw::CmdStringArg& cmd);
+};
+
+}  // namespace Components
+
+#endif

FprimeZephyrReference/Components/CameraManager/CameraManager.fpp renamed to FprimeZephyrReference/Components/PayloadHandler/PayloadHandler.fpp

@@ -90,7 +90,7 @@ module ReferenceDeployment {
 
   instance fsSpace: Components.FsSpace base id 0x10030000
 
-  instance camera: Components.CameraManager base id 0x10031000
+  instance payload: Components.PayloadHandler base id 0x10031000
 
   instance peripheralUartDriver: Zephyr.ZephyrUartDriver base id 0x10032000
 

FprimeZephyrReference/Components/PayloadHandler/PayloadHandler.hpp

@@ -44,7 +44,7 @@ module ReferenceDeployment {
     # For UART sideband communication
     instance comDriver
     instance fsSpace
-    instance camera
+    instance payload
     instance peripheralUartDriver
 
 
@@ -164,8 +164,9 @@ module ReferenceDeployment {
       imuManager.temperatureGet -> lsm6dsoManager.temperatureGet
     }
 
-    connections Camera {
-      camera.out_port -> peripheralUartDriver.$send
+    connections PayloadHandler {
+      payload.out_port -> peripheralUartDriver.$send
+      peripheralUartDriver.$recv -> payload.in_port
     }
   }
 }