Dev/camera/tcp socket/tyler

CMakeLists.txt

@@ -72,6 +72,7 @@ include(${DEPS_DIRECTORY}/matplot/matplot.cmake)
 include(${DEPS_DIRECTORY}/protobuf/protobuf.cmake)
 include(${DEPS_DIRECTORY}/loguru/loguru.cmake)
 include(${DEPS_DIRECTORY}/imagemagick/imagemagick.cmake)
+include(${DEPS_DIRECTORY}/boost/boost.cmake)
 # =============================
 
 # =============================

deps/boost/boost.cmake

@@ -0,0 +1,16 @@
+function(target_add_boost target_name)
+    include(FetchContent)
+
+    FetchContent_Declare(boost 
+        URL https://github.com/boostorg/boost/releases/download/boost-1.87.0/boost-1.87.0-b2-nodocs.tar.gz
+        URL_HASH SHA256=d6c69e4459eb5d6ec208250291221e7ff4a2affde9af6e49c9303b89c687461f
+        DOWNLOAD_EXTRACT_TIMESTAMP true
+    )
+    FetchContent_MakeAvailable(boost)
+    # target_link_libraries(${target_name} PRIVATE
+    #     boost
+    # )
+    target_include_directories(${target_name} PRIVATE ${boost_SOURCE_DIR})
+
+
+endfunction()

include/camera/interface.hpp

@@ -101,4 +101,4 @@ class CameraInterface {
         std::shared_ptr<MavlinkClient> mavlinkClient) = 0;
 };
 
-#endif  // INCLUDE_CAMERA_INTERFACE_HPP_
+#endif  // INCLUDE_CAMERA_INTERFACE_HPP_

include/camera/rpi.hpp

@@ -0,0 +1,88 @@
+#ifndef INCLUDE_CAMERA_RPI_HPP_
+#define INCLUDE_CAMERA_RPI_HPP_
+
+
+#include <string>
+#include <memory>
+#include <optional>
+#include <shared_mutex>
+#include <thread>
+#include <deque>
+
+#include <nlohmann/json.hpp>
+
+#include "camera/interface.hpp"
+#include "network/mavlink.hpp"
+
+using json = nlohmann::json;
+
+using namespace std::chrono_literals; // NOLINT
+
+#include "interface.hpp"
+#include "network/udp_client.hpp"
+
+namespace asio = boost::asio;
+
+// const std::string SERVER_IP = "192.168.68.1";
+// const int SERVER_PORT = 25565;
+// const std::string SERVER_IP = "127.0.0.1";
+// const int SERVER_PORT = 5000;
+const std::uint8_t START_REQUEST = 's';
+const std::uint8_t PICTURE_REQUEST = 'I';
+const std::uint8_t END_REQUEST = 'e';
+const std::uint8_t LOCK_REQUEST = 'l';
+
+class RPICamera : public CameraInterface {
+	private:
+		UDPClient client;
+        asio::io_context io_context_;
+
+        std::atomic_bool connected;
+
+		std::deque<ImageData> imageQueue; // TODO: unsure if we actually need this if we're just gonna directly save images to disk
+
+		// lock for obc client?
+		// lock for imageQueue?	
+
+        /**
+         * Converts the image taken from the camera to a suitable format for the CV pipeline
+         */
+		std::optional<cv::Mat> imgConvert(std::vector<std::uint8_t> imgbuf);
+
+        /**
+         * Reads in the image data when taking a picture
+         */
+        std::vector<std::uint8_t> readImage();
+
+        /**
+         * Reads in the telemetry data when taking a picture
+         */
+        std::optional<ImageTelemetry> readTelemetry();
+
+        std::vector<std::uint8_t> readPacket();
+
+	public:
+
+		explicit RPICamera(CameraConfig config, asio::io_context* io_context_);
+
+		// TODO: destructor?
+		~RPICamera();
+
+		void connect() override;
+		bool isConnected() override;
+
+        std::optional<ImageData> getLatestImage() override {return std::nullopt;}
+        std::deque<ImageData> getAllImages() override {return std::deque<ImageData>();}
+		std::optional<ImageData> takePicture(const std::chrono::milliseconds& timeout, std::shared_ptr<MavlinkClient> mavlinkClient) override;
+
+        void startTakingPictures(const std::chrono::milliseconds& interval,
+            std::shared_ptr<MavlinkClient> mavlinkClient) override;
+        void stopTakingPictures() override;
+
+        void startStreaming() override;
+
+        // TODO: unsure how to implement
+        void ping();
+};
+
+#endif

include/network/camera_data.hpp

@@ -0,0 +1,82 @@
+#ifndef INCLUDE_NETWORK_CAMERA_DATA_HPP_
+#define INCLUDE_NETWORK_CAMERA_DATA_HPP_
+
+#include <iostream>
+#include <boost/serialization/serialization.hpp>
+#include <boost/serialization/vector.hpp>
+#include <boost/archive/binary_iarchive.hpp>
+#include <boost/archive/binary_oarchive.hpp>
+
+struct ImageData_t
+{
+    int width;
+    int height;
+    size_t imageSizeBytes;
+    std::vector<std::uint8_t> imgBuffer;
+
+    template<class Archive>
+	void serialize(Archive & ar, const unsigned int version){
+		ar & width;
+		ar & height;
+		ar & imageSizeBytes;
+		ar & imgBuffer;
+	}
+};
+
+// What does OBC needs from camera
+enum class RequestType_t
+{
+    SENDIMAGE
+};
+
+// TODO: unsure if these need to be in a namespace or not
+template<class Archive>
+void serialize(Archive & ar, RequestType_t & request, const unsigned int version) {
+	ar & static_cast<int>(request); // have to type cast enum class
+}
+
+// What is the status of the request (debugging + error handling)
+enum class ResponseType_t
+{
+    SUCC,
+    ERROR
+};
+
+// TODO: unsure if these need to be in a namespace or not
+template<class Archive>
+void serialize(Archive & ar, ResponseType_t & response, const unsigned int version) {
+	ar & static_cast<int>(response); // have to type cast enum class
+}
+
+// OBC requesting camera for something 
+struct CameraRequest_t
+{
+    // device id that requests (for debugging)
+    int pid;
+
+    // type of request, we should figure out edge cases
+    RequestType_t requestType;
+
+    template<class Archive>
+	void serialize(Archive & ar, const unsigned int version) {
+		ar & pid;
+		ar & requestType;
+	}
+};
+
+// Response back from camera to OBC
+struct CameraResponse_t
+{
+    int pid; 
+    ResponseType_t responseType;
+    ImageData_t imageData;
+
+    template<class Archive>
+	void serialize(Archive & ar, const unsigned int version) {
+		ar & pid;
+		ar & responseType;
+		ar & imageData;
+	}
+};
+
+#endif

include/network/rpi_connection.hpp

@@ -0,0 +1,27 @@
+#ifndef INCLUDE_NETWORK_RPI_CONNECTION_HPP_
+#define INCLUDE_NETWORK_RPI_CONNECTION_HPP_
+
+#include <iostream>
+
+const uint32_t IMG_WIDTH = 2028;
+const uint32_t IMG_HEIGHT = 1520;
+const uint32_t BUFFER_SIZE = IMG_WIDTH * IMG_HEIGHT * 3 / 2;
+
+// const std::string SERVER_IP = "192.168.68.1";
+// const int SERVER_PORT = 25565;
+
+// local testing only
+const std::string SERVER_IP = "0.0.0.0";
+const int SERVER_PORT = 5000;
+
+const int headerSize = 12;
+const uint32_t EXPECTED_MAGIC = 0x12345678;
+const size_t CHUNK_SIZE = 1024;
+
+struct Header {
+    uint32_t magic;
+    uint32_t total_chunks;
+    uint32_t mem_size;
+};
+
+#endif

include/network/serialize.hpp

@@ -0,0 +1,28 @@
+#ifndef INCLUDE_NETWORK_SERIALIZE_HPP_
+#define INCLUDE_NETWORK_SERIALIZE_HPP_
+
+#include <boost/asio.hpp>
+
+/*
+    Includes some reference on how to serialize and deserialize structs
+*/
+
+namespace serialh {
+    // TODO: make this so that it returns any struct
+    template <typename T>
+    void serialize(T* response, boost::asio::streambuf* buf) {
+        std::ostream os(buf);
+        boost::archive::binary_oarchive oa(os);
+        oa << *response;
+    }
+
+    // TODO: make this so that it returns any struct
+    template <typename T>
+    void deserialize(T* response, boost::asio::streambuf* buf) {
+        std::istream is(buf);
+        boost::archive::binary_iarchive ia(is);
+        ia >> *response;
+    }
+}
+
+#endif

include/network/tcp_client.hpp

@@ -0,0 +1,50 @@
+#ifndef INCLUDE_NETWORK_CLIENT_HPP_
+#define INCLUDE_NETWORK_CLIENT_HPP_
+
+#include <iostream>
+#include <boost/asio.hpp>
+#include <opencv2/opencv.hpp>
+#include "rpi_connection.hpp"
+
+namespace asio = boost::asio;
+
+class Client {
+    private:
+        asio::ip::tcp::socket socket_;
+        std::string ip;
+        int port;
+
+    public:
+
+        // TODO: should probably make the io_context a unique_ptr
+        Client(asio::io_context* io_context_, std::string ip, int port);
+
+        // TODO: do we need a destructor? probably to free the socket right?
+		// ~Client();
+
+        /**
+         * Connects to the specified ip and port
+         */
+        bool connect();
+
+        /**
+         * 
+         */
+        // TODO: so send is supposed to send a char but im unsure what the type should be uchar, uint8_t, etc.
+        bool send(std::uint8_t request);
+
+        /**
+         * Reads in the header and fills a Header struct
+         */
+        // std::optional<Header>
+        Header recvHeader();
+
+        /**
+         * Reads the actual data specified by the header
+         */
+        // std::optional<std::vector<std::uint8_t>>
+        std::vector<std::uint8_t> recvBody(const int bufSize);
+
+};
+
+#endif

include/network/tcp_server.hpp

@@ -0,0 +1,37 @@
+#ifndef INCLUDE_NETWORK_TCP_SERVER_HPP_
+#define INCLUDE_NETWORK_TCP_SERVER_HPP_
+
+#include <iostream>
+#include <boost/asio.hpp>
+#include <opencv2/opencv.hpp>
+
+namespace asio = boost::asio;
+
+class Server {
+    private:
+        std::string ip;
+        int port;
+        asio::ip::tcp::socket socket_;
+        asio::ip::tcp::acceptor acceptor_;
+
+        void takePicture();
+
+        cv::Mat createBGR();
+
+        cv::Mat createYUV();
+
+    public:
+        Server(asio::io_context* io_context_, std::string ip, int port);
+
+        void start();
+
+        void send();
+
+        void recv();
+
+        void handleRequest(char request);
+
+        void shutdown();
+};
+
+#endif 

include/network/udp_client.hpp

@@ -0,0 +1,31 @@
+#ifndef INCLUDE_NETWORK_UDP_CLIENT_HPP_
+#define INCLUDE_NETWORK_UDP_CLIENT_HPP_
+
+#include <iostream>
+#include <boost/asio.hpp>
+#include <opencv2/opencv.hpp>
+#include <loguru.hpp>
+#include "rpi_connection.hpp"
+
+namespace asio = boost::asio;
+
+class UDPClient {
+    private:
+        asio::ip::udp::socket socket_;
+        std::string ip;
+        int port;
+
+    public:
+        UDPClient(asio::io_context* io_context_, std::string ip, int port);
+
+        // there isnt really a notion of connect with connectionless udp sockets
+        bool connect();
+
+        bool send(std::uint8_t request);
+
+        Header recvHeader();
+
+        std::vector<std::uint8_t> recvBody(const int mem_size, const int total_chunks);
+};
+
+#endif