Use assigned address from SetSdkConnection instead of hard-coded address

The low level API needed to change to accomodate the hight level API,
which is a major revision.

CMakeLists.txt

@@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 3.15)
 
 project (
     RoboMasterSDK
-    VERSION 1.0.0
+    VERSION 2.0.0
     LANGUAGES C
 )
 
@@ -15,8 +15,12 @@ add_library(robomaster
     src/message.c
     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
 )
 
 target_include_directories(robomaster
@@ -26,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
     src/sdl.c
 )
 target_link_libraries(robomasterapp
     robomaster
-	SDL2::SDL2-static
+    SDL2-static
 )
-endif()

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/chassis.h

@@ -8,21 +8,25 @@
 static const uint8_t CHASSIS_HOST = 3;
 static const uint8_t CHASSIS_INDEX = 6;
 
-static const uint16_t SET_WHEEL_SPEED_CMD = 0x203F;
+#define SET_WHEEL_SPEED_CMD 0x203F
 
 void
 set_wheel_speed (
-		Client session,
+		union Request* req,
+        uint16_t seq,
+        bool ack,
 		int16_t w1,
 		int16_t w2,
 		int16_t w3,
 		int16_t w4 );
 
-static const uint16_t CHASSIS_SPEED_MODE_CMD = 0x213F;
+#define CHASSIS_SPEED_MODE_CMD 0x213F
 
 void
 chassis_speed_mode (
-		Client session,
+		union Request* req,
+        uint16_t seq,
+        bool ack,
 		float x,
 		float y,
 		float z );

include/connection.h

@@ -0,0 +1,13 @@
+#pragma once
+
+struct Connection;
+typedef Connection* Connection;
+
+struct Connection*
+conn_new (
+        struct Connection* connection,
+        unsigned int source_port,
+        const char* source_ip,
+        unsigned int dest_port,
+        const char* dest_ip );
+extern const size_t SIZEOF_CONN;

include/gimbal.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "message.h"
+
+#include <stdbool.h>
+#include <stdint.h>
+
+static const uint8_t GIMBAL_HOST = 4;
+static const uint8_t GIMBAL_INDEX = 0;
+
+#define GIMBAL_CTRL_SPEED_CMD 0x0C04
+
+void
+gimbal_ctrl_speed (
+		union Request* req,
+        uint16_t seq,
+        bool ack,
+		int16_t p,
+		int16_t y,
+		int16_t r );

include/message.h

@@ -5,7 +5,10 @@
 
 #define PACKED __attribute__((__packed__))
 
-const uint8_t PREAMBLE = 0x55;
+static const uint8_t CLIENT_HOST = 9;
+static const uint8_t CLIENT_INDEX = 6;
+
+static const uint8_t PREAMBLE = 0x55;
 
 struct PACKED Header {
 
@@ -165,6 +168,30 @@ struct PACKED SetChassisWheelSpeedResp
     struct Footer footer;
 };
 
+struct PACKED GimbalCtrlSpeedReq
+{
+    struct Header header;
+    // Values between -360 and 360
+    union {
+        int16_t yrp[3];
+        struct {
+            int16_t yaw;
+            int16_t roll;
+            int16_t pitch;
+        };
+    };
+    // Always 0xDC
+    uint8_t ctrl;
+    struct Footer footer;
+};
+
+struct PACKED GimbalCtrlSpeedResp
+{
+    struct Header header;
+    int8_t retcode;
+    struct Footer footer;
+};
+
 struct PACKED SetWheelSpeedReq
 {
     struct Header header;
@@ -221,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;
@@ -233,6 +338,10 @@ union Request {
     struct SetRobotModeReq mvmode;
     struct SubNodeResetReq subnodereset;
     struct SubscribeAddNodeReq subnodeadd;
+    struct GimbalCtrlSpeedReq gimbspeed;
+    struct BlasterFireReq blaster;
+    struct StreamCtrlReq stream;
+    struct AddSubMsgReq sub;
 };
 union Response {
     struct Header header;
@@ -246,6 +355,11 @@ union Response {
     struct SetRobotModeResp mvmode;
     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;
@@ -261,61 +375,3 @@ enum MESSAGEERR {
 
 enum MESSAGEERR
 message_validate(const union Message* message);
-
-static inline uint8_t host2byte(uint8_t host, uint8_t index) {
-    return index * 32 + host;
-}
-
-static inline void byte2host(uint8_t b, uint8_t* host, uint8_t* index) {
-    *host = (b & 0x1F);
-    *index = b >> 5;
-}
-
-static
-inline
-size_t
-message_length(uint16_t cmd) {
-    switch(cmd) {
-        case SET_SDK_CONNECTION_CMD:
-            return sizeof(struct SetSdkConnectionReq);
-        case SDK_HEARTBEAT_CMD:
-            return sizeof(struct SdkHeartbeatReq);
-        case SET_SDK_MODE_CMD:
-            return sizeof(struct SetSdkModeReq);
-        case SET_SYSTEM_LED_CMD:
-            return sizeof(struct SetSystemLedReq);
-        case SET_ROBOT_MODE_CMD:
-            return sizeof(struct SetRobotModeReq);
-        case SUBNODE_RESET_CMD:
-            return sizeof(struct SubNodeResetReq);
-        case SUBSCRIBE_ADD_NODE_CMD:
-            return sizeof(struct SubscribeAddNodeReq);
-        case SET_WHEEL_SPEED_CMD:
-            return sizeof(struct SetWheelSpeedReq);
-        case CHASSIS_SPEED_MODE_CMD:
-            return sizeof(struct ChassisSpeedModeReq);
-        default:
-            return 0;
-    }
-}
-
-static
-inline
-uint8_t
-message_module(uint16_t cmd) {
-    switch(cmd) {
-        case SET_SDK_CONNECTION_CMD:
-        case SDK_HEARTBEAT_CMD:
-        case SET_SDK_MODE_CMD:
-        case SET_SYSTEM_LED_CMD:
-        case SET_ROBOT_MODE_CMD:
-        case SUBNODE_RESET_CMD:
-        case SUBSCRIBE_ADD_NODE_CMD:
-            return host2byte(SDK_HOST, SDK_INDEX);
-        case SET_WHEEL_SPEED_CMD:
-        case CHASSIS_SPEED_MODE_CMD:
-            return host2byte(CHASSIS_HOST, CHASSIS_INDEX);
-        default:
-            return 0;
-    }
-}

include/roboeasy.h

@@ -1,8 +1,10 @@
 #pragma once
 
+#include <stdbool.h>
+
 // Handle for the high level robot interface
-struct Robot;
-typedef struct Robot* Robot;
+struct RobotImp;
+typedef struct RobotImp* Robot;
 
 /*
  * Return a handle to the high level robot interface, or NULL on error.
@@ -29,6 +31,17 @@ int robot_init(Robot robot);
  */
 int robot_stop(Robot robot);
 
+/*
+ * Set the gimble speed. A packet will be sent to the robot on
+ * the next ready tick of the work function.
+ *
+ * robot: The robot to set the velocity of
+ * p: pitch speed
+ * y: yaw speed
+ * returns: 0 on success, non-zero on failure
+ */
+int robot_aim(Robot, float p, float y);
+
 /*
  * Set the velocity of the robot chassis. A packet will be sent to the robot on
  * the next ready tick of the work function.
@@ -54,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

@@ -7,8 +7,20 @@ typedef struct Client* Client;
 #include "message.h"
 #include "chassis.h"
 #include "sdk.h"
+#include "gimbal.h"
+#include "blaster.h"
+#include "camera.h"
 
 Client client_new();
 void client_connect(Client client);
 void poll_message(Client client, union Message* message);
 
+static inline uint8_t host2byte(uint8_t host, uint8_t index) {
+    return index * 32 + host;
+}
+
+static inline void byte2host(uint8_t b, uint8_t* host, uint8_t* index) {
+    *host = (b & 0x1F);
+    *index = b >> 5;
+}
+

include/sdk.h

@@ -8,7 +8,7 @@
 static const uint8_t SDK_HOST = 9;
 static const uint8_t SDK_INDEX = 0;
 
-static const uint16_t SET_SDK_CONNECTION_CMD = 0xD43F;
+#define SET_SDK_CONNECTION_CMD 0xD43F
 
 enum CONNECTION {
     CONNECTION_WIFI_AP = 0,
@@ -18,23 +18,31 @@ enum CONNECTION {
 
 void
 set_sdk_connection(
-		Client session,
+		union Request* req,
+        uint16_t seq,
+        bool ack,
 		enum CONNECTION connection_type,
 		uint32_t ip_address,
 		uint16_t port );
 
-static const uint16_t SDK_HEARTBEAT_CMD = 0xD53F;
+#define SDK_HEARTBEAT_CMD 0xD53F
 
 void
 sdk_heartbeat(
-		Client session );
+		union Request* req,
+        uint16_t seq,
+        bool ack );
 
-static const uint16_t SET_SDK_MODE_CMD = 0xD13F;
+#define SET_SDK_MODE_CMD 0xD13F
 
 void
-set_sdk_mode(Client session, bool enable);
+set_sdk_mode(
+		union Request* req,
+        uint16_t seq,
+        bool ack,
+		bool enable );
 
-static const uint16_t SET_SYSTEM_LED_CMD = 0x333F;
+#define SET_SYSTEM_LED_CMD 0x333F
 
 enum LEDCOMP {
     LEDCOMP_BOTTOM_BACK = 0x1,
@@ -57,7 +65,9 @@ enum LEDEFFECT {
 };
 
 void set_system_led (
-		Client session,
+		union Request* req,
+        uint16_t seq,
+        bool ack,
 		uint8_t red,
 		uint8_t green,
 		uint8_t blue,
@@ -67,7 +77,7 @@ void set_system_led (
 		uint16_t t1,
 		uint16_t t2 );
 
-static const uint16_t SET_ROBOT_MODE_CMD = 0x463F;
+#define SET_ROBOT_MODE_CMD 0x463F
 
 enum MOVEMENTMODE {
     MOVEMENTMODE_FREE,
@@ -77,18 +87,55 @@ enum MOVEMENTMODE {
 
 void
 set_robot_mode (
-		Client session,
+		union Request* req,
+        uint16_t seq,
+        bool ack,
 		enum MOVEMENTMODE mode );
 
-static const uint16_t SUBNODE_RESET_CMD = 0x0248;
+#define SUBNODE_RESET_CMD 0x0248
 
 void
 subnode_reset (
-		Client session );
+		union Request* req,
+        uint16_t seq,
+        bool ack );
 
-static const uint16_t SUBSCRIBE_ADD_NODE_CMD = 0x0148;
+#define SUBSCRIBE_ADD_NODE_CMD 0x0148
 
 void
 subscribe_add_node (
-		Client session );
+		union Request* req,
+        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/client.h

@@ -4,9 +4,7 @@
 
 struct Client {
 
-   uint8_t hostbyte;
-
-   int16_t seq;
+    uint16_t seq;
 
    union {
        struct {
@@ -18,6 +16,3 @@ struct Client {
 
 };
 
-static const uint8_t CLIENT_HOST = 9;
-static const uint8_t CLIENT_INDEX = 6;
-

src/connection.c

@@ -1,4 +1,4 @@
-#include "message.h"
+#include "robomaster.h"
 #include "client.h"
 #include "crc.h"
 #include "connection.h"
@@ -7,55 +7,123 @@
 #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>
 
+static
+inline
+size_t
+message_length(int cmd) {
+    switch(cmd) {
+        case SET_SDK_CONNECTION_CMD:
+            return sizeof(struct SetSdkConnectionReq);
+        case SDK_HEARTBEAT_CMD:
+            return sizeof(struct SdkHeartbeatReq);
+        case SET_SDK_MODE_CMD:
+            return sizeof(struct SetSdkModeReq);
+        case SET_SYSTEM_LED_CMD:
+            return sizeof(struct SetSystemLedReq);
+        case SET_ROBOT_MODE_CMD:
+            return sizeof(struct SetRobotModeReq);
+        case SUBNODE_RESET_CMD:
+            return sizeof(struct SubNodeResetReq);
+        case SUBSCRIBE_ADD_NODE_CMD:
+            return sizeof(struct SubscribeAddNodeReq);
+        case SET_WHEEL_SPEED_CMD:
+            return sizeof(struct SetWheelSpeedReq);
+        case CHASSIS_SPEED_MODE_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;
+    }
+}
+
+static
+inline
+uint8_t
+message_module(int cmd) {
+    switch(cmd) {
+        case SET_SDK_CONNECTION_CMD:
+        case SDK_HEARTBEAT_CMD:
+        case SET_SDK_MODE_CMD:
+        case SET_SYSTEM_LED_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;
+    }
+}
+
 // The greated file descriptor is needed for polling the sockets.
 // It needs to be global for the whole process.
 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*
@@ -72,8 +140,8 @@ connection_poll_ready(struct Client* client) {
         if(client->conns[i])
             FD_SET(client->conns[i]->sockfd, &read_fds);
 
-    //struct timeval timeout = {0, 0};
-    int result = select(max_fd + 1, &read_fds, NULL, NULL, NULL);
+    struct timeval timeout = {0, 0};
+    int result = select(max_fd + 1, &read_fds, NULL, NULL, &timeout);
 
     // Check for socket polling errors
     if(result < 0) {
@@ -118,26 +186,24 @@ connection_read(struct Connection* conn, union Message* resp) {
 }
 
 void
-req_send(struct Connection* conn, union Request* req, size_t length) {
+req_send(struct Connection* conn, union Request* req) {
     if(!conn || !req) return;
+    size_t length = message_length(req->header.cmd);
     sendto(conn->sockfd, req, length, 0, (struct sockaddr*)&conn->remote_addr, conn->addrlen);
 }
 
 void
-req_finalize(struct Client* client, uint8_t cmdset, uint8_t cmdid, uint8_t hostbyte, bool need_ack, size_t length, union Request* req) {
+req_finalize(uint16_t seq, uint16_t cmd, bool need_ack, union Request* req) {
 
+    size_t length = message_length(cmd);
     req->header.preamble = 0x55;
-    //req->header.length = length & 0x1FFF | 0x400;
-    req->header.length = length;
+    req->header.length = (length & 0x1FFF) | 0x400;
     req->header.crc = crc8(req, 3);
-    req->header.seq_id = client->seq++;
-    req->header.sender = client->hostbyte;
-    // TODO: Figure out what this is supposed to be
-    //req->header.receiver = host2byte(DEFAULT_CLIENT_HOST, DEFAULT_ROBOT_INDEX);
-    req->header.receiver = hostbyte;
+    req->header.seq_id = seq;
+    req->header.sender = host2byte(CLIENT_HOST, CLIENT_INDEX);
+    req->header.receiver = message_module(cmd);
     req->header.ack_needed = need_ack;
-    req->header.cmdset = cmdset;
-    req->header.cmdid = cmdid;
+    req->header.cmd = cmd;
 
     struct Footer* footer = (void*)req + length - sizeof(struct Footer);
     uint16_t crc = crc16(req, length - sizeof(struct Footer));

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);
@@ -22,8 +33,8 @@ void
 connection_read(struct Connection* connection, union Message* resp);
 
 void
-req_finalize(struct Client* client, uint8_t cmdset, uint8_t cmdid, uint8_t hostbyte, bool need_ack, size_t length, union Request* req);
+req_finalize(uint16_t seq, uint16_t cmd, bool need_ack, union Request* req);
 
 void
-req_send(struct Connection* conn, union Request* req, size_t length);
+req_send(struct Connection* conn, union Request* req);
 

src/message.c

@@ -4,7 +4,7 @@
 enum MESSAGEERR
 message_validate(const union Message* message) {
 
-    uint16_t length = message->header.length;
+    uint16_t length = message->header.length & 0x1FFF & ~0x400;
 
     if(message->header.crc != crc8(message, 3))
         return MESSAGEERR_HEADERCRC;

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/chassis.c

@@ -4,30 +4,30 @@
 
 void
 set_wheel_speed (
-		Client session,
+		union Request* req,
+        uint16_t seq,
+        bool ack,
 		int16_t w1,
 		int16_t w2,
 		int16_t w3,
 		int16_t w4 ) {
-    union Request req = {0};
-    req.wheel.wheel_speed[0] = w1;
-    req.wheel.wheel_speed[1] = w2;
-    req.wheel.wheel_speed[2] = w3;
-    req.wheel.wheel_speed[3] = w4;
-    req_finalize(session, 0x3F, SET_WHEEL_SPEED_CMDID, host2byte(CHASSIS_HOST, CHASSIS_INDEX), false, sizeof(struct SetWheelSpeedReq), &req);
-    req_send(session->dev_conn, &req, sizeof(struct SetWheelSpeedReq));
+    req->wheel.wheel_speed[0] = w1;
+    req->wheel.wheel_speed[1] = w2;
+    req->wheel.wheel_speed[2] = w3;
+    req->wheel.wheel_speed[3] = w4;
+    req_finalize(seq, SET_WHEEL_SPEED_CMD, ack, req);
 }
 
 void
 chassis_speed_mode (
-		Client session,
+		union Request* req,
+        uint16_t seq,
+        bool ack,
 		float x,
 		float y,
 		float z ) {
-    union Request req = {0};
-    req.chsspeed.speed[0] = x;
-    req.chsspeed.speed[1] = y;
-    req.chsspeed.speed[2] = z;
-    req_finalize(session, 0x3F, CHASSIS_SPEED_MODE_CMDID, host2byte(CHASSIS_HOST, CHASSIS_INDEX), false, sizeof(struct ChassisSpeedModeReq), &req);
-    req_send(session->dev_conn, &req, sizeof(struct ChassisSpeedModeReq));
+    req->chsspeed.speed[0] = x;
+    req->chsspeed.speed[1] = y;
+    req->chsspeed.speed[2] = z;
+    req_finalize(seq, CHASSIS_SPEED_MODE_CMD, ack, req);
 }

src/modules/gimbal.c

@@ -0,0 +1,18 @@
+#include "message.h"
+#include "connection.h"
+#include "robomaster.h"
+
+void
+gimbal_ctrl_speed (
+		union Request* req,
+        uint16_t seq,
+        bool ack,
+		int16_t p,
+		int16_t y,
+		int16_t r ) {
+    req->gimbspeed.yaw = y;
+    req->gimbspeed.roll = r;
+    req->gimbspeed.pitch = p;
+    req->gimbspeed.ctrl = 0xDC;
+    req_finalize(seq, GIMBAL_CTRL_SPEED_CMD, ack, req);
+}

src/modules/sdk.c

@@ -4,72 +4,74 @@
 
 void
 set_sdk_connection(
-		Client session,
+		union Request* req,
+        uint16_t seq,
+        bool ack,
 		enum CONNECTION connection_type,
 		uint32_t ip_address,
 		uint16_t port ) {
 
-    union Request req = {0};
-    req.sdkconn.control = 0;
-    req.sdkconn.host = session->hostbyte;
-    req.sdkconn.connection = connection_type;
-    req.sdkconn.protocol = 0;
-    req.sdkconn.ip_address = ip_address;
-    req.sdkconn.port = port;
-    req_finalize(session, 0x3F, SET_SDK_CONNECTION_CMDID, host2byte(SDK_HOST, SDK_INDEX), true, sizeof(struct SetSdkConnectionReq), &req);
-    req_send(session->sdk_conn, &req, sizeof(struct SetSdkConnectionReq));
+    req->sdkconn.control = 0;
+    req->sdkconn.host = host2byte(CLIENT_HOST, CLIENT_INDEX);
+    req->sdkconn.connection = connection_type;
+    req->sdkconn.protocol = 0;
+    req->sdkconn.ip_address = ip_address;
+    req->sdkconn.port = port;
+    req_finalize(seq, SET_SDK_CONNECTION_CMD, ack, req);
 }
 
 void
 set_sdk_mode(
-		Client session,
+		union Request* req,
+        uint16_t seq,
+        bool ack,
 		bool enable ) {
-    union Request req = {0};
-    req.sdkmode.enable = enable;
-    req_finalize(session, 0x3F, SET_SDK_MODE_CMDID, host2byte(SDK_HOST, SDK_INDEX), true, sizeof(struct SetSdkModeReq), &req);
-    req_send(session->dev_conn, &req, sizeof(struct SetSdkModeReq));
+    req->sdkmode.enable = enable;
+    req_finalize(seq, SET_SDK_MODE_CMD, ack, req);
 }
 
 void
 sdk_heartbeat(
-		Client session ) {
-    union Request req = {0};
-    req_finalize(session, 0x3F, SDK_HEARTBEAT_CMDID, host2byte(SDK_HOST, SDK_INDEX), false, sizeof(struct SdkHeartbeatReq), &req);
-    req_send(session->dev_conn, &req, sizeof(struct SdkHeartbeatReq));
+		union Request* req,
+        uint16_t seq,
+        bool ack ) {
+    req_finalize(seq, SDK_HEARTBEAT_CMD, ack, req);
 }
 
 void
 set_robot_mode (
-		Client session,
+		union Request* req,
+        uint16_t seq,
+        bool ack,
 		enum MOVEMENTMODE mode ) {
-    union Request req = {0};
-    req.mvmode.mode = mode;
-    req_finalize(session, 0x3F, SET_ROBOT_MODE_CMDID, host2byte(SDK_HOST, SDK_INDEX), true, sizeof(struct SetRobotModeReq), &req);
-    req_send(session->dev_conn, &req, sizeof(struct SetRobotModeReq));
+    req->mvmode.mode = mode;
+    req_finalize(seq, SET_ROBOT_MODE_CMD, ack, req);
 }
 
 void
 subnode_reset (
-		Client session ) {
-    union Request req = {0};
-    req.subnodereset.hostbyte = session->hostbyte;
-    req_finalize(session, 0x48, SUBNODE_RESET_CMDID, host2byte(SDK_HOST, SDK_INDEX), true, sizeof(struct SubNodeResetReq), &req);
-    req_send(session->dev_conn, &req, sizeof(struct SubNodeResetReq));
+		union Request* req,
+        uint16_t seq,
+        bool ack ) {
+    req->subnodereset.hostbyte = host2byte(CLIENT_HOST, CLIENT_INDEX);
+    req_finalize(seq, SUBNODE_RESET_CMD, ack, req);
 }
 
 void
 subscribe_add_node (
-		Client session ) {
-    union Request req = {0};
-    req.subnodeadd.hostbyte = session->hostbyte;
-    req.subnodeadd.sub_vision = 0x03000000;
-    req_finalize(session, 0x48, SUBSCRIBE_ADD_NODE_CMDID, host2byte(SDK_HOST, SDK_INDEX), true, sizeof(struct SubscribeAddNodeReq), &req);
-    req_send(session->dev_conn, &req, sizeof(struct SubscribeAddNodeReq));
+		union Request* req,
+        uint16_t seq,
+        bool ack ) {
+    req->subnodeadd.hostbyte = host2byte(CLIENT_HOST, CLIENT_INDEX);
+    req->subnodeadd.sub_vision = 0x03000000;
+    req_finalize(seq, SUBSCRIBE_ADD_NODE_CMD, ack, req);
 }
 
 void
 set_system_led (
-		Client session,
+		union Request* req,
+        uint16_t seq,
+        bool ack,
 		uint8_t red,
 		uint8_t green,
 		uint8_t blue,
@@ -79,20 +81,39 @@ set_system_led (
 		uint16_t t1,
 		uint16_t t2 ) {
 
-    union Request req = {0};
 
-    req.led.comp_mask = comp;
-    req.led.led_mask = led_mask;
-    req.led.effect_mode = effect;
-    req.led.control_mode = 7;
-    req.led.red = red;
-    req.led.green = green;
-    req.led.blue = blue;
-    req.led.loop = 0;
-    req.led.t1 = t1;
-    req.led.t2 = t2;
+    req->led.comp_mask = comp;
+    req->led.led_mask = led_mask;
+    req->led.effect_mode = effect;
+    req->led.control_mode = 7;
+    req->led.red = red;
+    req->led.green = green;
+    req->led.blue = blue;
+    req->led.loop = 0;
+    req->led.t1 = t1;
+    req->led.t2 = t2;
 
-    req_finalize(session, 0x3F, SET_SYSTEM_LED_CMDID, host2byte(SDK_HOST, SDK_INDEX), true, sizeof(struct SetSystemLedReq), &req);
-    req_send(session->dev_conn, &req, sizeof(struct SetSystemLedReq));
+    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

@@ -0,0 +1,366 @@
+#include "roboeasy.h"
+#include "robomaster.h"
+#include "connection.h"
+
+#include <string.h>
+#include <stdlib.h>
+#include <arpa/inet.h>
+
+#include <stdio.h>
+
+struct RobotImp {
+
+    struct Client* client;
+    uint16_t seq;
+
+    int16_t wheels[4];
+    bool dirty_wheels;
+
+    uint8_t colors[3];
+    bool dirty_colors;
+
+    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,
+        CONNECTING_TO_DEVICE_PORT,
+        SETTING_SDK_MODE,
+        RESETTING_SUBNODE,
+        SUSBCRIBING_SUBNODE,
+        SETTING_MOVEMENT_MODE,
+        SUBSCRIBING_POSITION_STATUS,
+        SUBSCRIBING_GIMBAL_STATUS,
+        SENDING_HEARTBEAT,
+        WAITING,
+        READY,
+        STOPPED
+    } state;
+
+};
+
+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
+    // This function may be used in a timer handler, so fast as possible
+    robot->wheels[0] = (y + x + r) * 1000;
+    robot->wheels[1] = -(y - x - r) * 1000;
+    robot->wheels[2] = -(y + x - r) * 1000;
+    robot->wheels[3] = (y - x + r) * 1000;
+    robot->dirty_wheels = true;
+    return 1;
+}
+
+int
+robot_aim(Robot robot, float p, float y) {
+    robot->gimbal[0] = p * 360;
+    robot->gimbal[1] = y * 360;
+    robot->dirty_gimbal = true;
+    return 1;
+}
+
+int
+robot_led(Robot robot, unsigned char r, unsigned char g, unsigned char b) {
+    robot->colors[0] = r;
+    robot->colors[1] = g;
+    robot->colors[2] = b;
+    robot->dirty_colors = true;
+    return 1;
+}
+
+int
+robot_heartbeat(Robot robot) {
+
+    if(robot->state != READY)
+        return 0;
+
+    robot->state = SENDING_HEARTBEAT;
+
+    return 1;
+
+}
+
+int
+robot_work(Robot robot) {
+
+    union Request req = {0};
+
+    switch(robot->state) {
+
+        case WAITING:
+            break;
+
+        case CONNECTING_TO_PROXY_PORT:
+        {
+            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;
+        }
+
+        case SETTING_SDK_CONNECTION:
+        {
+            set_sdk_connection(&req, robot->seq++, true, CONNECTION_WIFI_AP, 0, 10010);
+            req_send(robot->client->sdk_conn, &req);
+            robot->state = WAITING;
+            break;
+        }
+
+        case CONNECTING_TO_DEVICE_PORT:
+        {
+            if(connection_connect(robot->client->dev_conn))
+                robot->state = STOPPED;
+            robot->state = SETTING_SDK_MODE;
+            break;
+        }
+
+        case SETTING_SDK_MODE:
+        {
+            set_sdk_mode(&req, robot->seq++, true, robot->sdk_mode);
+            req_send(robot->client->dev_conn, &req);
+            robot->state = WAITING;
+            break;
+        }
+
+        case RESETTING_SUBNODE:
+        {
+            subnode_reset(&req, robot->seq++, true);
+            req_send(robot->client->dev_conn, &req);
+            robot->state = WAITING;
+            break;
+        }
+
+        case SUSBCRIBING_SUBNODE:
+        {
+            subscribe_add_node(&req, robot->seq++, true);
+            req_send(robot->client->dev_conn, &req);
+            robot->state = WAITING;
+            break;
+        }
+
+        case SETTING_MOVEMENT_MODE:
+        {
+            set_robot_mode(&req, robot->seq++, true, MOVEMENTMODE_FREE);
+            req_send(robot->client->dev_conn, &req);
+            robot->state = WAITING;
+            break;
+        }
+
+        case SENDING_HEARTBEAT:
+        {
+            sdk_heartbeat(&req, robot->seq++, true);
+            req_send(robot->client->sdk_conn, &req);
+            robot->state = WAITING;
+            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) {
+                set_wheel_speed (
+                        &req, robot->seq++, false,
+                        robot->wheels[0],
+                        robot->wheels[1],
+                        robot->wheels[2],
+                        robot->wheels[3] );
+                req_send(robot->client->dev_conn, &req);
+                robot->dirty_wheels = false;
+            }
+            if(robot->dirty_gimbal) {
+                gimbal_ctrl_speed (
+                        &req, robot->seq++, false,
+                        robot->gimbal[0],
+                        robot->gimbal[1],
+                        0 );
+                req_send(robot->client->dev_conn, &req);
+                robot->dirty_gimbal = false;
+            }
+            if(robot->dirty_colors) {
+                set_system_led (
+                        &req, robot->seq++, false,
+                        robot->colors[0],
+                        robot->colors[1],
+                        robot->colors[2],
+                        LEDCOMP_ALL,
+                        0xFFFF,
+                        LEDEFFECT_ON,
+                        100,
+                        100 );
+                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;
+        }
+
+        case STOPPED:
+            return 0;
+
+    }
+
+    union Message resp;
+    poll_message(robot->client, &resp);
+    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:
+            // TODO: Do more with this
+            if(resp.resp.sdkmode.retcode) {
+                robot->state = STOPPED;
+                break;
+            }
+            robot->state = robot->sdk_mode ? RESETTING_SUBNODE : STOPPED;
+            break;
+        case SUBNODE_RESET_CMD:
+            if(resp.resp.subnodereset.retcode) {
+                robot->state = STOPPED;
+                break;
+            }
+            robot->state = SUSBCRIBING_SUBNODE;
+            break;
+        case SUBSCRIBE_ADD_NODE_CMD:
+            if(resp.resp.subnodeadd.retcode && resp.resp.subnodeadd.retcode != 0x50) {
+                robot->state = STOPPED;
+                break;
+            }
+            robot->state = SETTING_MOVEMENT_MODE;
+            break;
+        case SET_ROBOT_MODE_CMD:
+            if(resp.resp.mvmode.retcode) {
+                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:
+            if(resp.resp.heartbeat.retcode) {
+                robot->state = STOPPED;
+                break;
+            }
+            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;
+
+}
+
+Robot robot_new() {
+    struct RobotImp* robot = malloc(sizeof(struct RobotImp));
+    memset(robot, 0, sizeof(struct RobotImp));
+    return robot;
+}
+
+int robot_init(Robot robot) {
+    robot->client = client_new();
+    robot->sdk_mode = true;
+    robot->state = CONNECTING_TO_PROXY_PORT;
+    return 0;
+}
+
+int robot_stop(Robot robot) {
+    robot->sdk_mode = false;
+    robot->state = SETTING_SDK_MODE;
+    return 0;
+}

src/robomaster.c

@@ -11,7 +11,6 @@ Client client_new() {
     struct Client* client = malloc(sizeof(struct Client));
     memset(client, 0, sizeof(struct Client));
     // TODO: Make this configurable
-    client->hostbyte = host2byte(CLIENT_HOST, CLIENT_INDEX);
     return client;
 }
 
@@ -19,8 +18,6 @@ void client_connect(Client client) {
     client->sdk_conn = connection_new(0, 0, 30030, "192.168.2.1");
     // TODO: This should probably use the source IP in the response body
     client->dev_conn = connection_new(10010, "192.168.2.24", 20020, "192.168.2.1");
-
-    set_sdk_connection(client, CONNECTION_WIFI_AP, 0, 10010);
 }
 
 void poll_message(Client client, union Message* resp) {
@@ -32,5 +29,7 @@ void poll_message(Client client, union Message* resp) {
 
 void drive(Client client, float x, float y, float r) {
     float w1 = y + x + r, w2 = y - x -r, w3 = y + x -r, w4 = y - x + r;
-    set_wheel_speed(client, w1 * 1000, -w2 * 1000, -w3 * 1000, w4 * 1000);
+    union Request req;
+    set_wheel_speed(&req, client->seq, false, w1 * 1000, -w2 * 1000, -w3 * 1000, w4 * 1000);
+    req_send(client->dev_conn, &req);
 }

src/sdl.c

@@ -1,14 +1,43 @@
-#include "robomaster.h"
+#include "roboeasy.h"
 #include "SDL2/SDL.h"
 
 #include <stdio.h>
 #include <stdlib.h>
+#include <stdbool.h>
+
+struct {
+    unsigned char r;
+    unsigned char g;
+    unsigned char b;
+} const colors[] = {
+    {0xFF, 0x00, 0x00},
+    {0x00, 0xFF, 0x00},
+    {0x00, 0x00, 0xFF}
+};
+int color = 0;
+
+float pitch = 0, yaw = 0;
+float x = 0, y = 0, z = 0;
+static Uint32 drive_timer_handler(Uint32 interval, void* param) {
+    robot_drive((Robot)param, x, y, z);
+    robot_aim((Robot)param, pitch, yaw);
+    return 75;
+}
+static Uint32 heartbeat_timer_handler(Uint32 interval, void* param) {
+    robot_heartbeat((Robot)param);
+    return 1000;
+}
 
 int main(int argc, char* argv[]) {
-    if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_GAMECONTROLLER) < 0) {
+    if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK) < 0) {
         fprintf(stderr, "%s", SDL_GetError());
         return 1;
     }
+    printf("Detected %d joysticks\n", SDL_NumJoysticks());
+    SDL_Joystick* joystick = NULL;
+    if(SDL_NumJoysticks() > 0) {
+        joystick = SDL_JoystickOpen(0);
+    }
     SDL_Window* win = SDL_CreateWindow(
 		    "Robomaster",
 		    SDL_WINDOWPOS_UNDEFINED,
@@ -20,48 +49,17 @@ int main(int argc, char* argv[]) {
         return 1;
     }
 
-    Client client = client_new();
-    client_connect(client);
+    Robot robot = robot_new();
+    robot_init(robot);
+    robot_stream(robot, true);
 
-    union Message msg;
-    poll_message(client, &msg);
-    if(msg.header.cmdid != SET_SDK_CONNECTION_CMDID || msg.resp.sdkconn.retcode) {
-        fprintf(stderr, "Could not set SDK connection\n");
-        return 1;
-    }
+    SDL_AddTimer(75, drive_timer_handler, robot);
+    SDL_AddTimer(1000, heartbeat_timer_handler, robot);
 
-    set_sdk_mode(client, true);
-    poll_message(client, &msg);
-    if(msg.header.cmdid != SET_SDK_MODE_CMDID || msg.resp.sdkmode.retcode) {
-        fprintf(stderr, "Could not set SDK mode\n");
-        return 1;
-    }
+    int h, w;
+    SDL_GetWindowSize(win, &w, &h);
 
-    subnode_reset(client);
-    poll_message(client, &msg);
-    if(msg.header.cmdid != SUBNODE_RESET_CMDID || msg.resp.subnodereset.retcode) {
-        fprintf(stderr, "Could not reset subnode subscription\n");
-        return 1;
-    }
-
-    subscribe_add_node(client);
-    poll_message(client, &msg);
-    if(msg.header.cmdid != SUBSCRIBE_ADD_NODE_CMDID || (msg.resp.subnodeadd.retcode && msg.resp.subnodeadd.retcode != 0x50)) {
-        fprintf(stderr, "Could not subscribe node\n");
-        return 1;
-    }
-
-    set_robot_mode(client, MOVEMENTMODE_FREE);
-    poll_message(client, &msg);
-    if(msg.header.cmdid != SET_ROBOT_MODE_CMDID || msg.resp.mvmode.retcode) {
-        fprintf(stderr, "Could not set move mode\n");
-        return 1;
-    }
-
-    bool quit = false;
-    Uint32 time = SDL_GetTicks();
-    float x = 0, y = 0, z = 0;
-    while(!quit) {
+    while(robot_work(robot)) {
         SDL_Event event;
         while(SDL_PollEvent(&event)) {
             switch(event.type) {
@@ -69,53 +67,73 @@ int main(int argc, char* argv[]) {
                 case SDL_KEYDOWN:
                     switch(event.key.keysym.scancode) {
                         case SDL_SCANCODE_Q:
-                            z = event.type == SDL_KEYUP ? 0 : 250;
+                            z = event.type == SDL_KEYUP ? 0 : 0.25;
                             break;
                         case SDL_SCANCODE_E:
-                            z = event.type == SDL_KEYUP ? 0 : -250;
+                            z = event.type == SDL_KEYUP ? 0 : -0.25;
                             break;
                         case SDL_SCANCODE_LEFT:
                         case SDL_SCANCODE_A:
-                            x = event.type == SDL_KEYUP ? 0 : 250;
+                            x = event.type == SDL_KEYUP ? 0 : 0.25;
                             break;
                         case SDL_SCANCODE_RIGHT:
                         case SDL_SCANCODE_D:
-                            x = event.type == SDL_KEYUP ? 0 : -250;
+                            x = event.type == SDL_KEYUP ? 0 : -0.25;
                             break;
                         case SDL_SCANCODE_UP:
                         case SDL_SCANCODE_W:
-                            y = event.type == SDL_KEYUP ? 0 : 250;
+                            y = event.type == SDL_KEYUP ? 0 : 0.25;
                             break;
                         case SDL_SCANCODE_DOWN:
                         case SDL_SCANCODE_S:
-                            y = event.type == SDL_KEYUP ? 0 : -250;
+                            y = event.type == SDL_KEYUP ? 0 : -0.25;
+                            break;
+                        case SDL_SCANCODE_SPACE:
+                            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;
+                case SDL_MOUSEMOTION:
+                    yaw = (float)event.motion.xrel;
+                    pitch = (float)event.motion.yrel;
+                    break;
+                case SDL_JOYAXISMOTION:
+                    switch(event.jaxis.axis) {
+                        case 0:
+                            x = (float)event.jaxis.value / 32767;
+                            break;
+                        case 1:
+                            y = (float)event.jaxis.value / 32767;
+                            break;
+                        case 4:
+                            z = (float)event.jaxis.value / 32767 / 2;
+                            break;
+                        case 2:
+                            yaw = (float)event.jaxis.value / 32767;
+                            break;
+                        case 3:
+                            pitch = (float)event.jaxis.value / 32767;
+                            break;
+                        default:
+                            printf("axis: %d\n", event.jaxis.axis);
+                            break;
+                    }
+                    break;
                 case SDL_WINDOWEVENT:
                     if(event.window.event != SDL_WINDOWEVENT_CLOSE) break;
                 case SDL_QUIT:
-                    quit = true;
+                    robot_stop(robot);
                 default: break;
 	        }
 	    }
-	Uint32 currtime = SDL_GetTicks();
-	if(currtime - time >= 75)
-	{
-            time = currtime;
-            sdk_heartbeat(client);
-            float w1 = y + x + z, w2 = y - x -z, w3 = y + x -z, w4 = y - x + z;
-            set_wheel_speed(client, w1, -w2, -w3, w4);
-	}
-    }
-
-    set_sdk_mode(client, false);
-    poll_message(client, &msg);
-    if(msg.header.cmdid != SET_SDK_MODE_CMDID || msg.resp.sdkmode.retcode) {
-        fprintf(stderr, "Could not disable SDK mode\n");
-        return 1;
     }
 
+    SDL_JoystickClose(joystick);
     SDL_Quit();
     return 0;
 }