NEW: release DJI Payload-SDK version 3.5

Signed-off-by: DJI-Martin <DJI-Martin@dji.com>

samples/sample_c/platform/linux/common/osal/osal.c

@@ -98,6 +98,10 @@ T_DjiReturnCode Osal_MutexCreate(T_DjiMutexHandle *mutex)
 {
     int result;
 
+    if (!mutex) {
+        return DJI_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
+    }
+
     *mutex = malloc(sizeof(pthread_mutex_t));
     if (*mutex == NULL) {
         return DJI_ERROR_SYSTEM_MODULE_CODE_MEMORY_ALLOC_FAILED;
@@ -118,7 +122,11 @@ T_DjiReturnCode Osal_MutexCreate(T_DjiMutexHandle *mutex)
  */
 T_DjiReturnCode Osal_MutexDestroy(T_DjiMutexHandle mutex)
 {
-    int result;
+    int result = 0;
+
+    if (!mutex) {
+        return DJI_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
+    }
 
     result = pthread_mutex_destroy(mutex);
     if (result != 0) {
@@ -136,8 +144,13 @@ T_DjiReturnCode Osal_MutexDestroy(T_DjiMutexHandle mutex)
  */
 T_DjiReturnCode Osal_MutexLock(T_DjiMutexHandle mutex)
 {
-    int result = pthread_mutex_lock(mutex);
+    int result = 0;
 
+    if (!mutex) {
+        return DJI_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
+    }
+
+    result = pthread_mutex_lock(mutex);
     if (result != 0) {
         return DJI_ERROR_SYSTEM_MODULE_CODE_SYSTEM_ERROR;
     }
@@ -152,8 +165,13 @@ T_DjiReturnCode Osal_MutexLock(T_DjiMutexHandle mutex)
  */
 T_DjiReturnCode Osal_MutexUnlock(T_DjiMutexHandle mutex)
 {
-    int result = pthread_mutex_unlock(mutex);
+    int result = 0;
 
+    if (!mutex) {
+        return DJI_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
+    }
+
+    result = pthread_mutex_unlock(mutex);
     if (result != 0) {
         return DJI_ERROR_SYSTEM_MODULE_CODE_SYSTEM_ERROR;
     }
@@ -308,6 +326,14 @@ T_DjiReturnCode Osal_GetTimeUs(uint64_t *us)
     return DJI_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
 }
 
+T_DjiReturnCode Osal_GetRandomNum(uint16_t *randomNum)
+{
+    srand(time(NULL));
+    *randomNum = random() % 65535;
+
+    return DJI_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
+}
+
 void *Osal_Malloc(uint32_t size)
 {
     return malloc(size);

samples/sample_c/platform/linux/common/osal/osal.h

@@ -63,6 +63,7 @@ T_DjiReturnCode Osal_SemaphorePost(T_DjiSemaHandle semaphore);
 
 T_DjiReturnCode Osal_GetTimeMs(uint32_t *ms);
 T_DjiReturnCode Osal_GetTimeUs(uint64_t *us);
+T_DjiReturnCode Osal_GetRandomNum(uint16_t *randomNum);
 
 void *Osal_Malloc(uint32_t size);
 void Osal_Free(void *ptr);

samples/sample_c/platform/linux/common/osal/osal_socket.c

@@ -46,7 +46,7 @@ typedef struct {
 T_DjiReturnCode Osal_Socket(E_DjiSocketMode mode, T_DjiSocketHandle *socketHandle)
 {
     T_SocketHandleStruct *socketHandleStruct;
-    socklen_t optlen = sizeof(int);
+    socklen_t optlen = sizeof (int);
     int rcvBufSize = SOCKET_RECV_BUF_MAX_SIZE;
     int opt = 1;
 
@@ -72,7 +72,8 @@ T_DjiReturnCode Osal_Socket(E_DjiSocketMode mode, T_DjiSocketHandle *socketHandl
             goto out;
         }
 
-        if (setsockopt(socketHandleStruct->socketFd, SOL_SOCKET, SO_RCVBUF, &rcvBufSize, optlen) < 0) {
+        if (setsockopt(socketHandleStruct->socketFd, SOL_SOCKET, SO_RCVBUF, &rcvBufSize, optlen) < 0)
+        {
             goto out;
         }
     } else if (mode == DJI_SOCKET_MODE_TCP) {

samples/sample_c/platform/linux/manifold2/application/main.c

@@ -81,6 +81,7 @@ static pthread_t s_monitorThread = 0;
 
 /* Private functions declaration ---------------------------------------------*/
 static T_DjiReturnCode DjiUser_PrepareSystemEnvironment(void);
+static T_DjiReturnCode DjiUser_CleanSystemEnvironment(void);
 static T_DjiReturnCode DjiUser_FillInUserInfo(T_DjiUserInfo *userInfo);
 static T_DjiReturnCode DjiUser_PrintConsole(const uint8_t *data, uint16_t dataLen);
 static T_DjiReturnCode DjiUser_LocalWrite(const uint8_t *data, uint16_t dataLen);
@@ -180,7 +181,8 @@ int main(int argc, char **argv)
 #endif
 
     if (aircraftInfoBaseInfo.mountPosition == DJI_MOUNT_POSITION_EXTENSION_PORT &&
-        aircraftInfoBaseInfo.aircraftType == DJI_AIRCRAFT_TYPE_M300_RTK) {
+        (aircraftInfoBaseInfo.aircraftType == DJI_AIRCRAFT_TYPE_M300_RTK ||
+         aircraftInfoBaseInfo.aircraftType == DJI_AIRCRAFT_TYPE_M350_RTK)) {
         returnCode = DjiTest_WidgetInteractionStartService();
         if (returnCode != DJI_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
             USER_LOG_ERROR("widget interaction sample init error");
@@ -190,6 +192,13 @@ int main(int argc, char **argv)
         if (returnCode != DJI_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
             USER_LOG_ERROR("widget speaker test init error");
         }
+
+#ifdef CONFIG_MODULE_SAMPLE_MOP_CHANNEL_ON
+        returnCode = DjiTest_MopChannelStartService();
+        if (returnCode != DJI_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+            USER_LOG_ERROR("mop channel sample init error");
+        }
+#endif
     } else {
 #ifdef CONFIG_MODULE_SAMPLE_CAMERA_EMU_ON
         returnCode = DjiTest_CameraEmuBaseStartService();
@@ -339,6 +348,7 @@ static T_DjiReturnCode DjiUser_PrepareSystemEnvironment(void)
         .Free = Osal_Free,
         .GetTimeMs = Osal_GetTimeMs,
         .GetTimeUs = Osal_GetTimeUs,
+        .GetRandomNum  = Osal_GetRandomNum,
     };
 
     T_DjiLoggerConsole printConsole = {
@@ -466,6 +476,39 @@ static T_DjiReturnCode DjiUser_PrepareSystemEnvironment(void)
     return DJI_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
 }
 
+static T_DjiReturnCode DjiUser_CleanSystemEnvironment(void)
+{
+    T_DjiReturnCode returnCode;
+    T_DjiAircraftInfoBaseInfo aircraftInfoBaseInfo;
+
+    returnCode = DjiAircraftInfo_GetBaseInfo(&aircraftInfoBaseInfo);
+    if (returnCode != DJI_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("get aircraft base info error");
+        return DJI_ERROR_SYSTEM_MODULE_CODE_SYSTEM_ERROR;
+    }
+
+#ifdef CONFIG_MODULE_SAMPLE_POWER_MANAGEMENT_ON
+    returnCode = DjiTest_PowerManagementStopService();
+    if (returnCode != DJI_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        perror("power management deinit error");
+    }
+#endif
+
+#ifdef CONFIG_MODULE_SAMPLE_DATA_TRANSMISSION_ON
+    returnCode = DjiTest_DataTransmissionStopService();
+    if (returnCode != DJI_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        perror("widget sample deinit error");
+    }
+#endif
+
+    returnCode = DjiCore_DeInit();
+    if (returnCode != DJI_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        perror("Core deinit failed.");
+    }
+
+    return returnCode;
+}
+
 static T_DjiReturnCode DjiUser_FillInUserInfo(T_DjiUserInfo *userInfo)
 {
     if (userInfo == NULL) {
@@ -689,7 +732,15 @@ static T_DjiReturnCode DjiTest_WriteHighPowerApplyPin(E_DjiPowerManagementPinSta
 
 static void DjiUser_NormalExitHandler(int signalNum)
 {
+    T_DjiReturnCode returnCode;
+
     USER_UTIL_UNUSED(signalNum);
+
+    returnCode = DjiUser_CleanSystemEnvironment();
+    if (returnCode != DJI_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        perror("Clean up system environment failed.");
+    }
+
     exit(0);
 }
 

samples/sample_c/platform/linux/manifold2/hal/hal_usb_bulk.c

@@ -62,17 +62,19 @@ T_DjiReturnCode HalUsbBulk_Init(T_DjiHalUsbBulkInfo usbBulkInfo, T_DjiUsbBulkHan
 #ifdef LIBUSB_INSTALLED
         ret = libusb_init(NULL);
         if (ret < 0) {
+            USER_LOG_ERROR("init usb bulk failed, errno = %d", ret);
             return DJI_ERROR_SYSTEM_MODULE_CODE_SYSTEM_ERROR;
         }
 
         handle = libusb_open_device_with_vid_pid(NULL, usbBulkInfo.vid, usbBulkInfo.pid);
         if (handle == NULL) {
+            USER_LOG_ERROR("open usb device failed");
             return DJI_ERROR_SYSTEM_MODULE_CODE_SYSTEM_ERROR;
         }
 
         ret = libusb_claim_interface(handle, usbBulkInfo.channelInfo.interfaceNum);
         if (ret != LIBUSB_SUCCESS) {
-            printf("libusb claim interface error");
+            USER_LOG_ERROR("libusb claim interface failed, errno = %d", ret);
             libusb_close(handle);
             return DJI_ERROR_SYSTEM_MODULE_CODE_SYSTEM_ERROR;
         }
@@ -114,6 +116,7 @@ T_DjiReturnCode HalUsbBulk_Init(T_DjiHalUsbBulkInfo usbBulkInfo, T_DjiUsbBulkHan
 T_DjiReturnCode HalUsbBulk_DeInit(T_DjiUsbBulkHandle usbBulkHandle)
 {
     struct libusb_device_handle *handle = NULL;
+    int32_t ret;
     T_DjiOsalHandler *osalHandler = DjiPlatform_GetOsalHandler();
 
     if (usbBulkHandle == NULL) {
@@ -124,7 +127,11 @@ T_DjiReturnCode HalUsbBulk_DeInit(T_DjiUsbBulkHandle usbBulkHandle)
 
     if (((T_HalUsbBulkObj *) usbBulkHandle)->usbBulkInfo.isUsbHost == true) {
 #ifdef LIBUSB_INSTALLED
-        libusb_release_interface(handle, ((T_HalUsbBulkObj *) usbBulkHandle)->usbBulkInfo.channelInfo.interfaceNum);
+        ret = libusb_release_interface(handle, ((T_HalUsbBulkObj *) usbBulkHandle)->usbBulkInfo.channelInfo.interfaceNum);
+        if(ret != 0) {
+            USER_LOG_ERROR("release usb bulk interface failed, errno = %d", ret);
+            return DJI_ERROR_SYSTEM_MODULE_CODE_SYSTEM_ERROR;
+        }
         osalHandler->TaskSleepMs(100);
         libusb_exit(NULL);
 #endif

samples/sample_c/platform/linux/nvidia_jetson/CMakeLists.txt

@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.5)
-project(dji_sdk_demo_on_jeston C)
+project(dji_sdk_demo_on_jetson C)
 
 set(CMAKE_C_FLAGS "-pthread -std=gnu99")
 set(CMAKE_EXE_LINKER_FLAGS "-pthread")

samples/sample_c/platform/linux/nvidia_jetson/application/main.c

@@ -337,6 +337,7 @@ static T_DjiReturnCode DjiUser_PrepareSystemEnvironment(void)
         .SemaphorePost = Osal_SemaphorePost,
         .Malloc = Osal_Malloc,
         .Free = Osal_Free,
+        .GetRandomNum = Osal_GetRandomNum,
         .GetTimeMs = Osal_GetTimeMs,
         .GetTimeUs = Osal_GetTimeUs,
     };

samples/sample_c/platform/rtos_freertos/common/osal/osal.c

@@ -28,6 +28,7 @@
 #include "FreeRTOS.h"
 #include "task.h"
 #include "semphr.h"
+#include "stdlib.h"
 
 /* Private constants ---------------------------------------------------------*/
 #define SEM_MUTEX_WAIT_FOREVER      0xFFFFFFFF
@@ -64,6 +65,10 @@ T_DjiReturnCode Osal_TaskCreate(const char *name, void *(*taskFunc)(void *), uin
 
 T_DjiReturnCode Osal_TaskDestroy(T_DjiTaskHandle task)
 {
+    if (task == NULL) {
+        return DJI_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
+    }
+
     vTaskDelete(task);
 
     return DJI_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
@@ -83,6 +88,10 @@ T_DjiReturnCode Osal_TaskSleepMs(uint32_t timeMs)
 
 T_DjiReturnCode Osal_MutexCreate(T_DjiMutexHandle *mutex)
 {
+    if (mutex == NULL) {
+        return DJI_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
+    }
+
     *mutex = xSemaphoreCreateMutex();
     if (*mutex == NULL) {
         return DJI_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
@@ -93,6 +102,10 @@ T_DjiReturnCode Osal_MutexCreate(T_DjiMutexHandle *mutex)
 
 T_DjiReturnCode Osal_MutexDestroy(T_DjiMutexHandle mutex)
 {
+    if (mutex == NULL) {
+        return DJI_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
+    }
+
     vQueueDelete((SemaphoreHandle_t) mutex);
 
     return DJI_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
@@ -117,6 +130,10 @@ T_DjiReturnCode Osal_MutexLock(T_DjiMutexHandle mutex)
 
 T_DjiReturnCode Osal_MutexUnlock(T_DjiMutexHandle mutex)
 {
+    if (mutex == NULL) {
+        return DJI_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
+    }
+
     if (xSemaphoreGive(mutex) != pdTRUE) {
         return DJI_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
     }
@@ -128,6 +145,10 @@ T_DjiReturnCode Osal_SemaphoreCreate(uint32_t initValue, T_DjiSemaHandle *semaph
 {
     uint32_t maxCount = UINT_MAX;
 
+    if (semaphore == NULL) {
+        return DJI_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
+    }
+
     *semaphore = xSemaphoreCreateCounting(maxCount, initValue);
 
     if (*semaphore == NULL) {
@@ -139,6 +160,10 @@ T_DjiReturnCode Osal_SemaphoreCreate(uint32_t initValue, T_DjiSemaHandle *semaph
 
 T_DjiReturnCode Osal_SemaphoreDestroy(T_DjiSemaHandle semaphore)
 {
+    if (semaphore == NULL) {
+        return DJI_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
+    }
+
     vSemaphoreDelete(semaphore);
 
     return DJI_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
@@ -177,6 +202,10 @@ T_DjiReturnCode Osal_SemaphoreWait(T_DjiSemaHandle semaphore)
 
 T_DjiReturnCode Osal_SemaphorePost(T_DjiSemaHandle semaphore)
 {
+    if (semaphore == NULL) {
+        return DJI_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
+    }
+
     if (xSemaphoreGive(semaphore) != pdTRUE) {
         return DJI_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
     }
@@ -186,6 +215,10 @@ T_DjiReturnCode Osal_SemaphorePost(T_DjiSemaHandle semaphore)
 
 T_DjiReturnCode Osal_GetTimeMs(uint32_t *ms)
 {
+    if (ms == NULL) {
+        return DJI_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
+    }
+
     *ms = xTaskGetTickCount();
 
     return DJI_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
@@ -193,11 +226,22 @@ T_DjiReturnCode Osal_GetTimeMs(uint32_t *ms)
 
 T_DjiReturnCode Osal_GetTimeUs(uint64_t *us)
 {
+    if (us == NULL) {
+        return DJI_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
+    }
+
     *us = xTaskGetTickCount() * 1000;
 
     return DJI_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
 }
 
+T_DjiReturnCode Osal_GetRandomNum(uint16_t *randomNum)
+{
+    *randomNum = rand() % 65535;
+
+    return DJI_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
+}
+
 void *Osal_Malloc(uint32_t size)
 {
     return pvPortMalloc(size);

samples/sample_c/platform/rtos_freertos/common/osal/osal.h

@@ -43,35 +43,21 @@ extern "C" {
 /* Exported functions --------------------------------------------------------*/
 T_DjiReturnCode Osal_TaskCreate(const char *name, void *(*taskFunc)(void *), uint32_t stackSize,
                                 void *arg, T_DjiTaskHandle *task);
-
 T_DjiReturnCode Osal_TaskDestroy(T_DjiTaskHandle task);
-
 T_DjiReturnCode Osal_TaskSleepMs(uint32_t timeMs);
-
 T_DjiReturnCode Osal_MutexCreate(T_DjiMutexHandle *mutex);
-
 T_DjiReturnCode Osal_MutexDestroy(T_DjiMutexHandle mutex);
-
 T_DjiReturnCode Osal_MutexLock(T_DjiMutexHandle mutex);
-
 T_DjiReturnCode Osal_MutexUnlock(T_DjiMutexHandle mutex);
-
 T_DjiReturnCode Osal_SemaphoreCreate(uint32_t initValue, T_DjiSemaHandle *semaphore);
-
 T_DjiReturnCode Osal_SemaphoreDestroy(T_DjiSemaHandle semaphore);
-
 T_DjiReturnCode Osal_SemaphoreTimedWait(T_DjiSemaHandle semaphore, uint32_t waitTimeMs);
-
 T_DjiReturnCode Osal_SemaphoreWait(T_DjiSemaHandle semaphore);
-
 T_DjiReturnCode Osal_SemaphorePost(T_DjiSemaHandle semaphore);
-
 T_DjiReturnCode Osal_GetTimeMs(uint32_t *ms);
-
 T_DjiReturnCode Osal_GetTimeUs(uint64_t *us);
-
+T_DjiReturnCode Osal_GetRandomNum(uint16_t *randomNum);
 void *Osal_Malloc(uint32_t size);
-
 void Osal_Free(void *ptr);
 
 #ifdef __cplusplus

samples/sample_c/platform/rtos_freertos/stm32f4_discovery/application/application.c

@@ -97,6 +97,7 @@ void DjiUser_StartTask(void const *argument)
         .Free = Osal_Free,
         .GetTimeMs = Osal_GetTimeMs,
         .GetTimeUs = Osal_GetTimeUs,
+        .GetRandomNum = Osal_GetRandomNum,
     };
     T_DjiLoggerConsole printConsole = {
         .func = DjiUser_PrintConsole,
@@ -247,7 +248,8 @@ void DjiUser_StartTask(void const *argument)
 #endif
 
 #ifdef CONFIG_MODULE_SAMPLE_GIMBAL_EMU_ON
-    if (aircraftInfoBaseInfo.aircraftType == DJI_AIRCRAFT_TYPE_M300_RTK
+    if ((aircraftInfoBaseInfo.aircraftType == DJI_AIRCRAFT_TYPE_M300_RTK ||
+         aircraftInfoBaseInfo.aircraftType == DJI_AIRCRAFT_TYPE_M350_RTK)
         && aircraftInfoBaseInfo.djiAdapterType == DJI_SDK_ADAPTER_TYPE_NONE) {
         USER_LOG_WARN("Not support gimbal emu sample.");
     } else {
@@ -294,7 +296,8 @@ void DjiUser_StartTask(void const *argument)
 #endif
 
 #ifdef CONFIG_MODULE_SAMPLE_POSITIONING_ON
-    if (aircraftInfoBaseInfo.aircraftType == DJI_AIRCRAFT_TYPE_M300_RTK
+    if ((aircraftInfoBaseInfo.aircraftType == DJI_AIRCRAFT_TYPE_M300_RTK ||
+         aircraftInfoBaseInfo.aircraftType == DJI_AIRCRAFT_TYPE_M350_RTK)
         && aircraftInfoBaseInfo.mountPosition != DJI_MOUNT_POSITION_TYPE_EXTENSION_PORT) {
         if (DjiTest_PositioningStartService() != DJI_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
             USER_LOG_ERROR("psdk positioning init error");

samples/sample_c/platform/rtos_freertos/stm32f4_discovery/drivers/BSP/uart.c

@@ -40,7 +40,7 @@
 #define UART1_WRITE_BUF_SIZE     64
 #define UART2_READ_BUF_SIZE      64
 #define UART2_WRITE_BUF_SIZE     2048
-#define UART3_READ_BUF_SIZE      4096
+#define UART3_READ_BUF_SIZE      8192
 #define UART3_WRITE_BUF_SIZE     2048
 
 /* Private macro -------------------------------------------------------------*/

samples/sample_c/platform/rtos_freertos/stm32f4_discovery/drivers/BSP/upgrade_platform_opt_stm32.c

@@ -81,11 +81,15 @@ T_DjiReturnCode DjiUpgradePlatformStm32_WriteUpgradeProgramFile(uint32_t offset,
 {
     uint32_t result;
 
+    __disable_irq();
+
     result = FLASH_If_Write(APPLICATION_STORE_ADDRESS + offset, (uint8_t *) data, dataLen);
     if (result != FLASHIF_OK) {
         return DJI_ERROR_SYSTEM_MODULE_CODE_SYSTEM_ERROR;
     }
 
+    __enable_irq();
+
     return DJI_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
 }