Use assigned address from SetSdkConnection instead of hard-coded address

.github/issue_template

@@ -1,59 +0,0 @@
-name: Bug Report
-about: File a bug report
-title: "[Bug]: "
-body:
-  - type: markdown
-    attributes:
-      value: |
-        Thanks for taking the time to fill out this bug report!        
-  - type: input
-    id: contact
-    attributes:
-      label: Contact Details
-      description: How can we get in touch with you if we need more info?
-      placeholder: ex. email@example.com
-    validations:
-      required: false
-  - type: textarea
-    id: what-happened
-    attributes:
-      label: What happened?
-      description: Also tell us, what did you expect to happen?
-      placeholder: Tell us what you see!
-      value: "A bug happened!"
-    validations:
-      required: true
-  - type: dropdown
-    id: version
-    attributes:
-      label: Version
-      description: What version of our software are you running?
-      options:
-        - 1.0.2 (Default)
-        - 1.0.3 (Edge)
-    validations:
-      required: true
-  - type: dropdown
-    id: browsers
-    attributes:
-      label: What browsers are you seeing the problem on?
-      multiple: true
-      options:
-        - Firefox
-        - Chrome
-        - Safari
-        - Microsoft Edge
-  - type: textarea
-    id: logs
-    attributes:
-      label: Relevant log output
-      description: Please copy and paste any relevant log output. This will be automatically formatted into code, so no need for backticks.
-      render: shell
-  - type: checkboxes
-    id: terms
-    attributes:
-      label: Code of Conduct
-      description: By submitting this issue, you agree to follow our [Code of Conduct](https://example.com)
-      options:
-        - label: I agree to follow this project's Code of Conduct
-          required: true

CMakeLists.txt

@@ -16,6 +16,8 @@ add_library(robomaster
     src/modules/sdk.c
     src/modules/chassis.c
     src/modules/gimbal.c
+    src/modules/blaster.c
+    src/modules/camera.c
     src/connection.c
     src/robomaster.c
     src/robo.c
@@ -28,14 +30,19 @@ target_include_directories(robomaster
     include
 )
 
-find_package(SDL2)
+include(FetchContent)
+FetchContent_Declare (
+    SDL2
+    GIT_REPOSITORY https://github.com/libsdl-org/SDL
+    GIT_TAG release-2.0.20
+    GIT_SHALLOW TRUE
+)
+FetchContent_MakeAvailable(SDL2)
 
-if(SDL2_FOUND)
-    add_executable(robomasterapp
+add_executable(robomasterapp
     src/sdl.c
-    )
-    target_link_libraries(robomasterapp
+)
+target_link_libraries(robomasterapp
     robomaster
-	SDL2::SDL2-static
-    )
-endif()
+    SDL2-static
+)

include/blaster.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include "message.h"
+
+#include <stdbool.h>
+#include <stdint.h>
+
+static const uint8_t BLASTER_HOST = 23;
+static const uint8_t BLASTER_INDEX = 0;
+
+#define BLASTER_FIRE_CMD 0x513F
+
+enum FIRETYPE {
+    FIRETYPE_WATER = 0,
+    FIRETYPE_INFRARED = 1
+};
+
+enum FIRETIMES {
+    ONE = 1,
+    TWO = 2,
+    THREE = 3,
+    FOUR = 4,
+    FIVE = 5
+};
+
+void
+blaster_fire (
+		union Request* req,
+        uint16_t seq,
+        bool ack,
+		enum FIRETYPE type,
+		enum FIRETIMES times );
+

include/camera.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include "message.h"
+
+#include <stdbool.h>
+#include <stdint.h>
+
+static const uint8_t STREAM_HOST = 1;
+static const uint8_t STREAM_INDEX = 0;
+
+#define STREAM_CTRL_CMD 0xD23F
+
+#define VIDEO_STREAM_PORT 40921
+
+enum STREAMSTATE {
+    STREAMSTATE_OFF = 0,
+    STREAMSTATE_ON = 1
+};
+
+enum STREAMRESOLUTION {
+    RES_720P = 0,
+    RES_360P = 1,
+    RES_540P = 2
+};
+
+enum STREAMCTRL {
+    STREAMCTRL_SDK = 1,
+    STREAMCTRL_VIDEO = 2,
+    STREAMCTRL_AUDIO = 3
+};
+
+void
+stream_ctrl (
+		union Request* req,
+        uint16_t seq,
+        bool ack,
+		enum STREAMSTATE state,
+		enum STREAMRESOLUTION res,
+		enum STREAMCTRL ctrl );
+

include/message.h

@@ -248,6 +248,84 @@ struct PACKED SetSdkConnectionResp {
     struct Footer footer;
 };
 
+struct PACKED BlasterFireReq {
+    struct Header header;
+    struct {
+        uint8_t type : 4;
+        uint8_t times : 4;
+    };
+    struct Footer footer;
+};
+
+struct PACKED BlasterFireResp {
+    struct Header header;
+    uint8_t retcode;
+    struct Footer footer;
+};
+
+struct PACKED StreamCtrlReq {
+    struct Header header;
+    uint8_t ctrl;
+    struct {
+        uint8_t state : 4;
+        uint8_t conn_type : 4;
+    };
+    uint8_t resolution;
+    struct Footer footer;
+};
+
+struct PACKED StreamCtrlResp {
+    struct Header header;
+    uint8_t retcode;
+    struct Footer footer;
+};
+
+struct PACKED AddSubMsgReq {
+    struct Header header;
+    uint8_t node_id;
+    uint8_t msg_id;
+    uint8_t reserved;
+    uint8_t sub_mode;
+    uint8_t subject_count;
+    uint64_t subject_uuid;
+    uint16_t freq;
+    struct Footer footer;
+};
+
+struct PACKED AddSubMsgResp {
+    struct Header header;
+    uint8_t retcode;
+    uint8_t pub_node_id;
+    uint8_t ack_sub_mode;
+    uint8_t ack_msg_id;
+    uint16_t ack_err_uid_data;
+    struct Footer footer;
+};
+
+struct PACKED PushPeriodMsg {
+    struct Header header;
+    uint8_t sub_mode;
+    uint8_t msg_id;
+    union {
+        struct {
+            float x;
+            float y;
+            float z;
+        } position;
+        struct {
+            uint16_t yaw_ground;
+            uint16_t pitch_ground;
+            uint16_t yaw;
+            uint16_t pitch;
+            struct {
+                uint8_t option_mode : 2;
+                uint8_t return_center : 1;
+            };
+        } gimbal;
+    };
+    struct Footer footer;
+};
+
 union Request {
     struct Header header;
     struct SetSdkConnectionReq sdkconn;
@@ -261,6 +339,9 @@ union Request {
     struct SubNodeResetReq subnodereset;
     struct SubscribeAddNodeReq subnodeadd;
     struct GimbalCtrlSpeedReq gimbspeed;
+    struct BlasterFireReq blaster;
+    struct StreamCtrlReq stream;
+    struct AddSubMsgReq sub;
 };
 union Response {
     struct Header header;
@@ -275,6 +356,10 @@ union Response {
     struct SubNodeResetResp subnodereset;
     struct SubscribeAddNodeResp subnodeadd;
     struct GimbalCtrlSpeedResp gimbspeed;
+    struct BlasterFireResp blaster;
+    struct StreamCtrlResp stream;
+    struct AddSubMsgResp sub;
+    struct PushPeriodMsg push;
 };
 union Message {
     struct Header header;

include/roboeasy.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <stdbool.h>
+
 // Handle for the high level robot interface
 struct RobotImp;
 typedef struct RobotImp* Robot;
@@ -65,6 +67,10 @@ int robot_drive(Robot, float x, float y, float r);
  */
 int robot_led(Robot, unsigned char r, unsigned char g, unsigned char b);
 
+int robot_blast(Robot);
+
+int robot_stream(Robot, bool);
+
 /*
  * If the robot is in ready mode, this makes the robot send a heartbeat in
  * the next tick of the work function. The work function will not do anything

include/robomaster.h

@@ -8,6 +8,8 @@ typedef struct Client* Client;
 #include "chassis.h"
 #include "sdk.h"
 #include "gimbal.h"
+#include "blaster.h"
+#include "camera.h"
 
 Client client_new();
 void client_connect(Client client);

include/sdk.h

@@ -108,3 +108,34 @@ subscribe_add_node (
         uint16_t seq,
         bool ack );
 
+#define ADD_SUB_MSG_CMD 0x0348
+
+#define PUSH_PERIOD_MSG_CMD 0x0848
+
+#define DDS_BATTERY 0x000200096862229f
+#define DDS_GIMBAL_BASE 0x00020009f5882874
+#define DDS_VELOCITY 0x0002000949a4009c
+#define DDS_ESC 0x00020009c14cb7c5
+#define DDS_ATTITUDE 0x000200096b986306
+#define DDS_IMU 0x00020009a7985b8d
+#define DDS_POSITION 0x00020009eeb7cece
+#define DDS_SA_STATUS 0x000200094a2c6d55
+#define DDS_CHASSIS_MODE 0x000200094fcb1146
+#define DDS_SBUS 0x0002000988223568
+#define DDS_SERVO 0x000200095f0059e7
+#define DDS_ARM 0x0002000926abd64d
+#define DDS_GRIPPER 0x00020009124d156a
+#define DDS_GIMBAL_POS 0x00020009f79b3c97
+#define DDS_STICK 0x0002000955e9a0fa
+#define DDS_MOVE_MODE 0x00020009784c7bfd
+#define DDS_TOF 0x0002000986e4c05a
+#define DDS_PINBOARD 0x00020009eebb9ffc
+
+void
+add_sub_msg (
+        union Request* req,
+        uint16_t seq,
+        bool ack,
+        uint8_t msg_id,
+        uint8_t freq,
+        uint64_t subject_uuid );

src/connection.c

@@ -7,7 +7,6 @@
 #include <sys/socket.h>
 #include <sys/select.h>
 #include <netinet/in.h>
-#include <arpa/inet.h>
 #include <string.h>
 #include <fcntl.h>
 #include <stdio.h>
@@ -37,6 +36,12 @@ message_length(int cmd) {
             return sizeof(struct ChassisSpeedModeReq);
         case GIMBAL_CTRL_SPEED_CMD:
             return sizeof(struct GimbalCtrlSpeedReq);
+        case BLASTER_FIRE_CMD:
+            return sizeof(struct BlasterFireReq);
+        case STREAM_CTRL_CMD:
+            return sizeof(struct StreamCtrlReq);
+        case ADD_SUB_MSG_CMD:
+            return sizeof(struct AddSubMsgReq);
         default:
             return 0;
     }
@@ -54,12 +59,17 @@ message_module(int cmd) {
         case SET_ROBOT_MODE_CMD:
         case SUBNODE_RESET_CMD:
         case SUBSCRIBE_ADD_NODE_CMD:
+        case ADD_SUB_MSG_CMD:
             return host2byte(SDK_HOST, SDK_INDEX);
         case SET_WHEEL_SPEED_CMD:
         case CHASSIS_SPEED_MODE_CMD:
             return host2byte(CHASSIS_HOST, CHASSIS_INDEX);
         case GIMBAL_CTRL_SPEED_CMD:
             return host2byte(GIMBAL_HOST, GIMBAL_INDEX);
+        case BLASTER_FIRE_CMD:
+            return host2byte(BLASTER_HOST, BLASTER_INDEX);
+        case STREAM_CTRL_CMD:
+            return host2byte(STREAM_HOST, STREAM_INDEX);
         default:
             return 0;
     }
@@ -71,44 +81,49 @@ int max_fd = -1;
 
 // TODO: Close the socket and return NULL on error
 struct Connection*
-connection_new(unsigned int source_port, const char* source_ip, unsigned int dest_port, const char* dest_ip)
+connection_new(uint16_t source_port, uint32_t source_ip, uint16_t dest_port, uint32_t dest_ip)
 {
     struct Connection* conn = malloc(sizeof(struct Connection));
     memset(conn, 0, sizeof(struct Connection));
 
-    // Request a UDP socket
-    conn->sockfd = socket(AF_INET, SOCK_DGRAM, 0);
-
     // Set the source address and port if they are provided
     if(source_port && source_ip) {
-       struct sockaddr_in loc_addr;
-       loc_addr.sin_family = AF_INET;
-       loc_addr.sin_port = htons(source_port);
-       loc_addr.sin_addr.s_addr = inet_addr(source_ip);
-       if(bind(conn->sockfd, (struct sockaddr*)&loc_addr, sizeof(loc_addr)) < 0)
-       {
-           perror("unable to bind local port");
-           exit(EXIT_FAILURE);
+       conn->local_addr.sin_family = AF_INET;
+       conn->local_addr.sin_port = htons(source_port);
+       conn->local_addr.sin_addr.s_addr = source_ip;
     }
-    }
- 
-    // Make the socket non-blocking
-    int flags = fcntl(conn->sockfd, F_GETFL);
-    fcntl(conn->sockfd, F_SETFL, flags | O_NONBLOCK);
 
     // Set the address of the drone
     memset(&conn->remote_addr, 0, sizeof(conn->remote_addr));
     conn->addrlen = sizeof(conn->remote_addr);
     conn->remote_addr.sin_family = AF_INET;
     conn->remote_addr.sin_port = htons(dest_port);
-    conn->remote_addr.sin_addr.s_addr = inet_addr(dest_ip);
+    conn->remote_addr.sin_addr.s_addr = dest_ip;
+
+    return conn;
+}
+
+enum connection_error
+connection_connect(struct Connection* conn) {
+
+    // Request a UDP socket
+    conn->sockfd = socket(AF_INET, SOCK_DGRAM, 0);
+
+    if(conn->local_addr.sin_addr.s_addr
+            && bind(conn->sockfd, (struct sockaddr*)&conn->local_addr, sizeof(conn->local_addr)) < 0)
+        return CONNECTION_LOCAL_BIND;
+ 
+    // Make the socket non-blocking
+    int flags = fcntl(conn->sockfd, F_GETFL);
+    fcntl(conn->sockfd, F_SETFL, flags | O_NONBLOCK);
 
     // File descriptors are numbers that count up sequentially,
     // so save the last one as the greatest file descriptor.
     // This is needed for polling the sockets later.
     max_fd = conn->sockfd;
 
-    return conn;
+    return CONNECTION_NO_ERROR;
+
 }
 
 struct Connection*

src/connection.h

@@ -6,14 +6,25 @@
 #include <stddef.h>
 #include <netinet/in.h>
 
+#define ROBOT_DEFAULT_WIFI_ADDR 0X102A8C0
+
 struct Connection {
     int sockfd;
     socklen_t addrlen;
     struct sockaddr_in remote_addr;
+    struct sockaddr_in local_addr;
 };
 
 struct Connection*
-connection_new(unsigned int source_port, const char* source_ip, unsigned int dest_port, const char* dest_ip);
+connection_new(uint16_t source_port, uint32_t source_ip, uint16_t dest_port, uint32_t dest_ip);
+
+enum connection_error {
+    CONNECTION_NO_ERROR,
+    CONNECTION_LOCAL_BIND
+};
+
+enum connection_error
+connection_connect();
 
 struct Connection*
 connection_poll_ready(struct Client* client);

src/modules/blaster.c

@@ -0,0 +1,16 @@
+#include "message.h"
+#include "connection.h"
+#include "robomaster.h"
+
+void
+blaster_fire (
+		union Request* req,
+        uint16_t seq,
+        bool ack,
+		enum FIRETYPE type,
+		enum FIRETIMES times ) {
+    req->blaster.type = type;
+    req->blaster.times = times;
+    req_finalize(seq, BLASTER_FIRE_CMD, ack, req);
+}
+

src/modules/camera.c

@@ -0,0 +1,20 @@
+#include "message.h"
+#include "connection.h"
+#include "robomaster.h"
+
+void
+stream_ctrl (
+		union Request* req,
+        uint16_t seq,
+        bool ack,
+		enum STREAMSTATE state,
+		enum STREAMRESOLUTION res,
+		enum STREAMCTRL ctrl ) {
+    req->stream.state = state;
+    req->stream.resolution = res;
+    req->stream.ctrl = ctrl;
+    req->stream.conn_type = 0; // Hardcode to WiFi
+    req_finalize(seq, STREAM_CTRL_CMD, ack, req);
+}
+
+

src/modules/sdk.c

@@ -96,3 +96,24 @@ set_system_led (
     req_finalize(seq, SET_SYSTEM_LED_CMD, ack, req);
 
 }
+
+void
+add_sub_msg (
+        union Request* req,
+        uint16_t seq,
+        bool ack,
+        uint8_t msg_id,
+        uint8_t freq,
+        uint64_t subject_uuid ) {
+
+    req->sub.node_id = host2byte(CLIENT_HOST, CLIENT_INDEX);
+    req->sub.msg_id = msg_id;
+    req->sub.reserved = 0; // NOTE: Always 0
+    req->sub.sub_mode = 0; // NOTE: Always 0
+    req->sub.subject_count = 1; // TODO: Add support for multiple
+    req->sub.subject_uuid = subject_uuid; // TODO: Add support for multiple
+    req->sub.freq = freq;
+
+    req_finalize(seq, ADD_SUB_MSG_CMD, ack, req);
+
+}

src/robo.c

@@ -4,6 +4,9 @@
 
 #include <string.h>
 #include <stdlib.h>
+#include <arpa/inet.h>
+
+#include <stdio.h>
 
 struct RobotImp {
 
@@ -19,8 +22,20 @@ struct RobotImp {
     int16_t gimbal[2];
     bool dirty_gimbal;
 
+    bool dirty_blaster;
+
+    bool stream_state;
+    bool dirty_stream;
+
     bool sdk_mode;
 
+    float x, y, z;
+
+    uint16_t yaw_ground;
+    uint16_t pitch_ground;
+    uint16_t yaw;
+    uint16_t pitch;
+
     enum {
         CONNECTING_TO_PROXY_PORT,
         SETTING_SDK_CONNECTION,
@@ -29,6 +44,8 @@ struct RobotImp {
         RESETTING_SUBNODE,
         SUSBCRIBING_SUBNODE,
         SETTING_MOVEMENT_MODE,
+        SUBSCRIBING_POSITION_STATUS,
+        SUBSCRIBING_GIMBAL_STATUS,
         SENDING_HEARTBEAT,
         WAITING,
         READY,
@@ -37,6 +54,19 @@ struct RobotImp {
 
 };
 
+int
+robot_stream(Robot robot, bool state) {
+    robot->stream_state = state;
+    robot->dirty_stream = true;
+    return 1;
+}
+
+int
+robot_blast(Robot robot) {
+    robot->dirty_blaster = true;
+    return 1;
+}
+
 int
 robot_drive(Robot robot, float x, float y, float r) {
     // TODO: move individual wheel speed calculation to work function
@@ -90,7 +120,8 @@ robot_work(Robot robot) {
 
         case CONNECTING_TO_PROXY_PORT:
         {
-            robot->client->sdk_conn = connection_new(0, 0, 30030, "192.168.2.1");
+            robot->client->sdk_conn = connection_new(0, 0, 30030, ROBOT_DEFAULT_WIFI_ADDR);
+            connection_connect(robot->client->sdk_conn);
             robot->state = SETTING_SDK_CONNECTION;
             break;
         }
@@ -105,7 +136,8 @@ robot_work(Robot robot) {
 
         case CONNECTING_TO_DEVICE_PORT:
         {
-            robot->client->dev_conn = connection_new(10010, "192.168.2.24", 20020, "192.168.2.1");
+            if(connection_connect(robot->client->dev_conn))
+                robot->state = STOPPED;
             robot->state = SETTING_SDK_MODE;
             break;
         }
@@ -150,6 +182,22 @@ robot_work(Robot robot) {
             break;
         }
 
+        case SUBSCRIBING_POSITION_STATUS:
+        {
+            add_sub_msg ( &req, robot->seq++, true, 20, 1, DDS_POSITION );
+            req_send(robot->client->dev_conn, &req);
+            robot->state = SUBSCRIBING_GIMBAL_STATUS;
+            break;
+        }
+
+        case SUBSCRIBING_GIMBAL_STATUS:
+        {
+            add_sub_msg ( &req, robot->seq++, true, 21, 1, DDS_GIMBAL_POS );
+            req_send(robot->client->dev_conn, &req);
+            robot->state = WAITING;
+            break;
+        }
+
         case READY:
         {
             if(robot->dirty_wheels) {
@@ -185,6 +233,32 @@ robot_work(Robot robot) {
                 req_send(robot->client->dev_conn, &req);
                 robot->dirty_colors = false;
             }
+            if(robot->dirty_blaster) {
+                blaster_fire (
+                    &req, robot->seq++, false,
+                    FIRETYPE_INFRARED,
+                    ONE
+                );
+                req_send(robot->client->dev_conn, &req);
+                robot->dirty_blaster = false;
+            }
+            if(robot->dirty_stream) {
+                stream_ctrl (
+                    &req, robot->seq++, true,
+                    robot->stream_state ? STREAMSTATE_ON : STREAMSTATE_OFF,
+                    RES_720P,
+                    STREAMCTRL_SDK
+                );
+                req_send(robot->client->dev_conn, &req);
+                stream_ctrl (
+                    &req, robot->seq++, true,
+                    robot->stream_state ? STREAMSTATE_ON : STREAMSTATE_OFF,
+                    RES_720P,
+                    STREAMCTRL_VIDEO
+                );
+                req_send(robot->client->dev_conn, &req);
+                robot->dirty_stream = false;
+            }
             break;
         }
 
@@ -198,12 +272,15 @@ robot_work(Robot robot) {
     switch(resp.header.cmd) {
         case 0:
             break;
+        default:
+            break;
         case SET_SDK_CONNECTION_CMD:
             // TODO: Do more with this
             if(resp.resp.sdkconn.retcode) {
                 robot->state = STOPPED;
                 break;
             }
+            robot->client->dev_conn = connection_new(10010, resp.resp.sdkconn.config_ip, 20020, ROBOT_DEFAULT_WIFI_ADDR);
             robot->state = CONNECTING_TO_DEVICE_PORT;
             break;
         case SET_SDK_MODE_CMD:
@@ -233,6 +310,13 @@ robot_work(Robot robot) {
                 robot->state = STOPPED;
                 break;
             }
+            robot->state = SUBSCRIBING_POSITION_STATUS;
+            break;
+        case ADD_SUB_MSG_CMD:
+            if(resp.resp.sub.retcode) {
+                robot->state = STOPPED;
+                break;
+            }
             robot->state = SENDING_HEARTBEAT;
             break;
         case SDK_HEARTBEAT_CMD:
@@ -242,6 +326,20 @@ robot_work(Robot robot) {
             }
             robot->state = READY;
             break;
+        case PUSH_PERIOD_MSG_CMD:
+            switch(resp.resp.push.msg_id) {
+                case 20:
+                    robot->x = resp.resp.push.position.x;
+                    robot->y = resp.resp.push.position.y;
+                    robot->z = resp.resp.push.position.z;
+                    break;
+                case 21:
+                    robot->yaw_ground = resp.resp.push.gimbal.yaw_ground;
+                    robot->pitch_ground = resp.resp.push.gimbal.pitch_ground;
+                    robot->yaw = resp.resp.push.gimbal.yaw;
+                    robot->pitch = resp.resp.push.gimbal.pitch;
+            }
+            break;
     }
 
     return 1;

src/sdl.c

@@ -51,6 +51,8 @@ int main(int argc, char* argv[]) {
 
     Robot robot = robot_new();
     robot_init(robot);
+    robot_stream(robot, true);
+
     SDL_AddTimer(75, drive_timer_handler, robot);
     SDL_AddTimer(1000, heartbeat_timer_handler, robot);
 
@@ -90,6 +92,9 @@ int main(int argc, char* argv[]) {
                             robot_led(robot, colors[color].r, colors[color].g, colors[color].b);
                             color = (color + 1) % 3;
                             break;
+                        case SDL_SCANCODE_RETURN:
+                            robot_blast(robot);
+                            break;
                         default: break;
 		            }
                     break;