潘浩彬 / JZSDK_Linux · 提交

转到一个项目

作者 ookk303
提交 171219ca2109fe2ab2697f46e6781f5b7e422047 1 个父辈 2a0d2144

更新

内嵌 并排对比
正在显示 70 个修改的文件 包含 10774 行增加 和 0 行删除
# Compiled class file
project_build
ThirdParty
ModuleLib
备份
\ No newline at end of file
... ...
# 编译链的配置
#1、编译链与设备类型的选择
set(DEVICE_NAME JZ_H1T)
#上一行为禁止修改行
if("${DEVICE_NAME}" STREQUAL "JZ_H1E")
set(MAKE_COMPILER ARM_CORTEXA9_LINUX)
set(DEVICE_TYPE MEGAPHONE)
elseif("${DEVICE_NAME}" STREQUAL "JZ_H1T")
set(MAKE_COMPILER ARM_CORTEXA9_LINUX)
set(DEVICE_TYPE MEGAPHONE)
elseif("${DEVICE_NAME}" STREQUAL "JZ_H150S")
set(MAKE_COMPILER ARM_CORTEXA9_LINUX)
set(DEVICE_TYPE MEGAPHONE)
elseif("${DEVICE_NAME}" STREQUAL "JZ_H150T")
set(MAKE_COMPILER ARM_CORTEXA9_LINUX)
set(DEVICE_TYPE MEGAPHONE)
elseif("${DEVICE_NAME}" STREQUAL "JZ_H10")
set(MAKE_COMPILER ARM_CORTEXA9_LINUX)
set(DEVICE_TYPE MEGAPHONE)
elseif("${DEVICE_NAME}" STREQUAL "JZ_H10T")
set(MAKE_COMPILER ARM_CORTEXA9_LINUX)
set(DEVICE_TYPE MEGAPHONE)
elseif("${DEVICE_NAME}" STREQUAL "JZ_U3")
set(MAKE_COMPILER ARM_CORTEXA9_LINUX)
set(DEVICE_TYPE MEGAPHONE)
elseif("${DEVICE_NAME}" STREQUAL "JZ_U3S")
set(MAKE_COMPILER ARM_CORTEXA9_LINUX)
set(DEVICE_TYPE MEGAPHONE)
elseif("${DEVICE_NAME}" STREQUAL "TF_A1")
set(MAKE_COMPILER ARM_CORTEXA9_LINUX)
set(DEVICE_TYPE MEGAPHONE)
elseif("${DEVICE_NAME}" STREQUAL "JZ_C1")
set(MAKE_COMPILER ARM_X86_64_ARRCH64)
endif()
if(${MAKE_COMPILER} STREQUAL "ARM_CORTEXA9_LINUX")
set(TOOLCHAIN_NAME arm-linux-gnueabihf-gcc)
set(CMAKE_C_COMPILER "/usr/local/arm/4.9.3/bin/arm-cortexa9-linux-gnueabihf-gcc")
set(CMAKE_CXX_COMPILER "/usr/local/arm/4.9.3/bin/arm-cortexa9-linux-gnueabihf-g++")
message("使用ARM_CORTEXA9_LINUX编译链")
elseif(${MAKE_COMPILER} STREQUAL "ARM_CORTEX_LINUX")
set(TOOLCHAIN_NAME arm-linux-gnueabihf-gcc)
set(CMAKE_C_COMPILER "/opt/gcc-linaro-6.3.1-2017.05-x86_64_arm-linux-gnueabihf/bin/arm-linux-gnueabihf-gcc")
set(CMAKE_CXX_COMPILER "/opt/gcc-linaro-6.3.1-2017.05-x86_64_arm-linux-gnueabihf/bin/arm-linux-gnueabihf-g++")
message("使用ARM_CORTEX_LINUX编译链")
elseif(${MAKE_COMPILER} STREQUAL "ARM_X86_64_ARRCH64")
# 交叉编译链3
set(TOOLCHAIN_NAME aarch64-linux-gnu-gcc)
set(CMAKE_C_COMPILER "/opt/gcc-arm-10.3-2021.07-x86_64-aarch64-none-linux-gnu/bin/aarch64-none-linux-gnu-gcc")
set(CMAKE_CXX_COMPILER "/opt/gcc-arm-10.3-2021.07-x86_64-aarch64-none-linux-gnu/bin/aarch64-none-linux-gnu-g++")
message("使用ARM_X86_64_ARRCH64编译链")
elseif(${MAKE_COMPILER} STREQUAL "LOCAL")
# 本地测试编译链
set(CMAKE_C_COMPILER "/usr/bin/gcc")
set(CMAKE_CXX_COMPILER "/usr/bin/g++")
message("使用LOCAL编译链")
else()
message(FATAL_ERROR "不支持的编译链")
endif()
message("编译链配置完毕\n")
\ No newline at end of file
... ...
# ModuleConfig.cmake 模组模块的配置文件
###################### 自己的库 ##############################
# AudioDeal 音频处理模块
set(AUDIODEAL_MODULE VERSION_SWITCH_OFF)
# 信息模块
set(DEVICE_INFO_MODULE VERSION_SWITCH_OFF)
# Gimbal 云台处理模块
set(GIMBAL_MODULE VERSION_SWITCH_OFF)
# IRCUT 引脚处理模块
set(IRCUT_MODULE VERSION_SWITCH_OFF)
# LIGHTING 光源处理模块
set(LIGHTING_MODULE VERSION_SWITCH_OFF)
# MediaProc 媒体管理模块
set(MEDIA_PROC_MODULE VERSION_SWITCH_OFF)
# 喊话器模块
set(MEGAPHONE_MODULE VERSION_SWITCH_OFF)
# 电源管理模块
set(POWER_MANAGER_MODULE VERSION_SWITCH_OFF)
# UI管理模块
set(UI_CONTROL_MODULE VERSION_SWITCH_OFF)
# 红外相机模块
set(IRC_MODULE VERSION_SWITCH_OFF)
# 侧面激光模块
set(SIDE_LASER_MODULE VERSION_SWITCH_OFF)
###################### 第三方库 ##############################
# FFMPEG及其附属模块
set(FFMPEG_MODULE VERSION_SWITCH_OFF)
# cedarxLib
set(CedarxLib VERSION_SWITCH_OFF)
########################## 通用库 ###########################################
# 添加信息模块
set(DEVICE_INFO_MODULE VERSION_SWITCH_ON)
# 添加UI管理模块
set(UI_CONTROL_MODULE VERSION_SWITCH_ON)
#####################################################################
if("${DEVICE_NAME}" STREQUAL "JZ_H1E")
elseif("${DEVICE_NAME}" STREQUAL "JZ_H1T")
# 添加AudioDeal 音频处理模块
set(AUDIODEAL_MODULE VERSION_SWITCH_ON)
# 添加Gimbal 云台处理模块
set(GIMBAL_MODULE VERSION_SWITCH_ON)
# 添加IRCUT 引脚处理模块
set(IRCUT_MODULE VERSION_SWITCH_ON)
# 添加LIGHTING 光源处理模块
set(LIGHTING_MODULE VERSION_SWITCH_ON)
# 添加喊话器模块
set(MEGAPHONE_MODULE VERSION_SWITCH_ON)
# 添加电源管理模块
set(POWER_MANAGER_MODULE VERSION_SWITCH_ON)
# 添加FFMPEG及其附属模块
set(FFMPEG_MODULE VERSION_SWITCH_ON)
elseif("${DEVICE_NAME}" STREQUAL "JZ_U3S")
# 添加AudioDeal 音频处理模块
set(AUDIODEAL_MODULE VERSION_SWITCH_ON)
# 添加Gimbal 云台处理模块
set(GIMBAL_MODULE VERSION_SWITCH_ON)
# 添加IRCUT 引脚处理模块
set(IRCUT_MODULE VERSION_SWITCH_ON)
# 添加LIGHTING 光源处理模块
set(LIGHTING_MODULE VERSION_SWITCH_ON)
# 添加喊话器模块
set(MEGAPHONE_MODULE VERSION_SWITCH_ON)
# 添加电源管理模块
set(POWER_MANAGER_MODULE VERSION_SWITCH_ON)
# 添加FFMPEG及其附属模块
set(FFMPEG_MODULE VERSION_SWITCH_ON)
# 添加激光模块
set(SIDE_LASER_MODULE VERSION_SWITCH_ON)
elseif("${DEVICE_NAME}" STREQUAL "JZ_C1")
# 添加Gimbal 云台处理模块
set(GIMBAL_MODULE VERSION_SWITCH_ON)
# 添加IRCUT 引脚处理模块
set(IRCUT_MODULE VERSION_SWITCH_ON)
# 添加LIGHTING 光源处理模块
set(LIGHTING_MODULE VERSION_SWITCH_ON)
# 添加MediaProc 媒体管理模块
set(MEDIA_PROC_MODULE VERSION_SWITCH_ON)
# 添加电源管理模块
set(POWER_MANAGER_MODULE VERSION_SWITCH_ON)
# 添加红外相机模块
set(IRC_MODULE VERSION_SWITCH_ON)
endif()
message("模组模块已加载\n")
\ No newline at end of file
... ...
# ModuleLoading.cmake 模块加载文件
if(${IFLAY_TTS_MODULE} STREQUAL "VERSION_SWITCH_ON")
set(iFLYTEK_TTS_DIRS "${ROOT_DIRS}ThirdParty/iFLYTEK_TTS/lib/arm-cortexa9-linux-gnueabihf")
include_directories(${ROOT_DIRS}ThirdParty/iFLYTEK_TTS/include)
target_link_libraries(
${PROJECT_NAME}
${iFLYTEK_TTS_DIRS}/libmsc.so
)
message("讯飞TTS模块已加载\n")
endif()
if(${ESPEAK_TTS_MODULE} STREQUAL "VERSION_SWITCH_ON")
set(ESPEAK_TTS_DIRS "${ROOT_DIRS}ThirdParty/Espeak/lib/arm-cortexa9-linux-gnueabihf")
include_directories(${ROOT_DIRS}ThirdParty/Espeak/include)
target_link_libraries(
${PROJECT_NAME}
${ESPEAK_TTS_DIRS}/libportaudio.so.2
${ESPEAK_TTS_DIRS}/libTTS_Player.so
)
message("Espeak模块已加载\n")
endif()
if(${ALSALIB_MODULE} STREQUAL "VERSION_SWITCH_ON")
set(ALSALIB_DIRS "${ROOT_DIRS}ThirdParty/AlsaLib/lib/arm-cortexa9-linux-gnueabihf")
include_directories(${ROOT_DIRS}ThirdParty/AlsaLib/include)
target_link_libraries(
${PROJECT_NAME}
${ALSALIB_DIRS}/libasound.so.2.0.0
)
message("alsalib已加载\n")
endif()
if(${OPUS_MODULE} STREQUAL "VERSION_SWITCH_ON")
set(OPUS_DIRS "${ROOT_DIRS}ThirdParty/opus/lib/arm-cortexa9-linux-gnueabihf")
include_directories(${ROOT_DIRS}ThirdParty/opus/include)
target_link_libraries(
${PROJECT_NAME}
${OPUS_DIRS}/libopus.so
)
message("OPUS模块已加载\n")
endif()
if(${CedarxLib} STREQUAL "VERSION_SWITCH_ON")
message("\nCedarX已加载\n")
target_link_libraries(${PROJECT_NAME}
${ROOT_DIRS}ModuleLib/Camera/CedarX/libawh264.so
${ROOT_DIRS}ModuleLib/Camera/CedarX/libMemAdapter.so
${ROOT_DIRS}ModuleLib/Camera/CedarX/libVE.so
${ROOT_DIRS}ModuleLib/Camera/CedarX/libvencoder.so
${ROOT_DIRS}ModuleLib/Camera/CedarX/libvideoengine.so
${ROOT_DIRS}ModuleLib/Camera/CedarX/libvdecoder.so
)
message("\n OpenCV已加载\n")
target_link_libraries(${PROJECT_NAME}
${ROOT_DIRS}ModuleLib/OpenCV/libopencv_calib3d.so
${ROOT_DIRS}ModuleLib/OpenCV/libopencv_core.so
${ROOT_DIRS}ModuleLib/OpenCV/libopencv_dnn.so
${ROOT_DIRS}ModuleLib/OpenCV/libopencv_features2d.so
${ROOT_DIRS}ModuleLib/OpenCV/libopencv_flann.so
${ROOT_DIRS}ModuleLib/OpenCV/libopencv_highgui.so
${ROOT_DIRS}ModuleLib/OpenCV/libopencv_imgcodecs.so
${ROOT_DIRS}ModuleLib/OpenCV/libopencv_imgproc.so
${ROOT_DIRS}ModuleLib/OpenCV/libopencv_ml.so
${ROOT_DIRS}ModuleLib/OpenCV/libopencv_objdetect.so
${ROOT_DIRS}ModuleLib/OpenCV/libopencv_photo.so
${ROOT_DIRS}ModuleLib/OpenCV/libopencv_shape.so
${ROOT_DIRS}ModuleLib/OpenCV/libopencv_stitching.so
${ROOT_DIRS}ModuleLib/OpenCV/libopencv_superres.so
${ROOT_DIRS}ModuleLib/OpenCV/libopencv_videoio.so
${ROOT_DIRS}ModuleLib/OpenCV/libopencv_video.so
${ROOT_DIRS}ModuleLib/OpenCV/libopencv_videostab.so
)
message("\n ffmpeg已加载\n")
target_link_libraries(${PROJECT_NAME}
${ROOT_DIRS}ModuleLib/ffmpeg/libavcodec.so
${ROOT_DIRS}ModuleLib/ffmpeg/libavdevice.so
${ROOT_DIRS}ModuleLib/ffmpeg/libavfilter.so
${ROOT_DIRS}ModuleLib/ffmpeg/libavformat.so
${ROOT_DIRS}ModuleLib/ffmpeg/libavutil.so
${ROOT_DIRS}ModuleLib/ffmpeg/libswresample.so
${ROOT_DIRS}ModuleLib/ffmpeg/libswscale.so
)
message("\n SearchLightCenter已加载\n")
target_link_libraries(${PROJECT_NAME}
${ROOT_DIRS}ModuleLib/SearchLightCenter/libcenter.so
)
endif()
if(${FFMPEG_MODULE} STREQUAL "VERSION_SWITCH_ON")
message("\nffmpeg模块加载\n")
set(FFMPEG_6_0_DIRS "${ROOT_DIRS}ThirdParty/ffmpeg_6_0/lib/arm-cortexa9-linux-gnueabihf")
include_directories(${ROOT_DIRS}ThirdParty/ffmpeg_6_0/include)
target_link_libraries(
${PROJECT_NAME}
${FFMPEG_6_0_DIRS}/libavcodec.so.60
${FFMPEG_6_0_DIRS}/libavdevice.so.60
${FFMPEG_6_0_DIRS}/libavfilter.so.9
${FFMPEG_6_0_DIRS}/libavformat.so.60
${FFMPEG_6_0_DIRS}/libavutil.so.58
${FFMPEG_6_0_DIRS}/libpostproc.so.57
${FFMPEG_6_0_DIRS}/libswresample.so.4
${FFMPEG_6_0_DIRS}/libswscale.so.7
)
message("x264模块已加载\n")
set(X264_DIRS "${ROOT_DIRS}ThirdParty/x264_2245/lib/arm-cortexa9-linux-gnueabihf")
include_directories(${ROOT_DIRS}ThirdParty/x264_2245/include)
target_link_libraries(
${PROJECT_NAME}
${X264_DIRS}/libx264.so.157
)
message("FDK_AAC模块已加载\n")
set(FDK_AAC_DIRS "${ROOT_DIRS}ThirdParty/fdk_aac_2_0_3/lib/arm-cortexa9-linux-gnueabihf")
include_directories(${ROOT_DIRS}ThirdParty/fdk_aac_2_0_3/include)
target_link_libraries(
${PROJECT_NAME}
${FDK_AAC_DIRS}/libfdk-aac.so.2
)
endif()
#rtk_mmp库
if(${LIB_RTK_MMP} STREQUAL "VERSION_SWITCH_ON")
message("RTK_MMP库已加载\n")
add_definitions(-DMACRO_RTK_MPP_MODULE) #加载usb模块
include_directories(${ROOT_DIRS}/ThirdParty/RTK_mmp/aarch64-none-linux-gnu/include)
target_link_libraries(
${PROJECT_NAME}
${ROOT_DIRS}/ThirdParty/RTK_mmp/aarch64-none-linux-gnu/lib/librockchip_mpp.so.0
${ROOT_DIRS}/ThirdParty/RTK_mmp/aarch64-none-linux-gnu/lib/librockchip_vpu.so.0
)
endif()
#usb库
if(${LIB_USB} STREQUAL "VERSION_SWITCH_ON")
add_definitions(-DMACRO_USB_MODULE) #加载usb模块
message("USB库已加载\n")
include_directories(${ROOT_DIRS}/ThirdParty/libusb/aarch64-none-linux-gnu/include)
target_link_libraries(
${PROJECT_NAME}
${ROOT_DIRS}/ThirdParty/libusb/aarch64-none-linux-gnu/lib/libusb-1.0.so.0.4.0
)
message("udev库已加载\n")
include_directories(${ROOT_DIRS}/ThirdParty/udev/aarch64-none-linux-gnu/include)
target_link_libraries(
${PROJECT_NAME}
${ROOT_DIRS}/ThirdParty/udev/aarch64-none-linux-gnu/lib/libudev.so.1.6.3
)
endif()
\ No newline at end of file
... ...
# SubsidiaryThirdPartyConfig.cmake 附属第三方库配置文件
set(IFLAY_TTS_MODULE VERSION_SWITCH_OFF)
set(ESPEAK_TTS_MODULE VERSION_SWITCH_OFF)
set(ALSALIB_MODULE VERSION_SWITCH_OFF)
set(OPUS_MODULE VERSION_SWITCH_OFF)
set(LIB_RTK_MMP VERSION_SWITCH_OFF)
set(LIB_USB VERSION_SWITCH_OFF)
add_definitions(-D COMPILE_MODE_MODULE) #设置代码为编译模式
if(${MEGAPHONE_MODULE} STREQUAL "VERSION_SWITCH_ON")
message("\n喊话器模块已加载")
add_definitions(-DMACRO_MEGAPHONE_MODULE) #加载喊话器模块
message("加载讯飞TTS模块")
set(IFLAY_TTS_MODULE VERSION_SWITCH_ON)
message("加载espeak模块")
set(ESPEAK_TTS_MODULE VERSION_SWITCH_ON)
message("加载alsalib模块")
set(ALSALIB_MODULE VERSION_SWITCH_ON)
message("加载OPUS模块")
set(OPUS_MODULE VERSION_SWITCH_ON)
endif()
if(${IRC_MODULE} STREQUAL "VERSION_SWITCH_ON")
message("\n红外相机模块已加载")
add_definitions(-DMACRO_IRC_MODULE)
message("加载RTK模块")
set(LIB_RTK_MMP VERSION_SWITCH_ON)
message("加载USB模块")
set(LIB_USB VERSION_SWITCH_ON)
message("\n媒体管理模块已加载")
add_definitions(-DMACRO_MEDIA_PROC_MODULE)
endif()
if(${SIDE_LASER_MODULE} STREQUAL "VERSION_SWITCH_ON")
message("加载侧面激光模块")
add_definitions(-DMACRO_SIDE_LASER_MODULE)
endif()
message("附属库已加载\n")
\ No newline at end of file
... ...
#include <stdio.h>
#include "JZsdkLib.h"
#include "./JZsdk_TaskManagement/TaskManagement.h"
//初始化sdk
T_JZsdkReturnCode JZsdk_LibInit()
{
//1、初始化log
JZsdk_LoggerInit();
//2、任务管理系统初始化
TaskManagement_Init();
JZSDK_LOG_INFO("Lib加载已完成");
}
\ No newline at end of file
... ...
/**
********************************************************************
* @file JZsdkLib.h
* JZsdk的头文件
*
*********************************************************************
*/
/* Define to prevent recursive inclusion 避免重定义 -------------------------------------*/
#ifndef JZSDKLIB_H
#define JZSDKLIB_H
/* Includes ------------------------------------------------------------------*/
#ifdef __cplusplus
extern "C" {
#endif
/* Exported constants --------------------------------------------------------*/
/* 常亮定义*/
#include "JZsdk_Base/JZsdkBase.h"
#include "JZsdk_Base/JZsdk_Code/JZsdk_Code.h"
#include "JZsdk_CommonFuntion/JZsdkCommonFuntion.h"
/* Exported types ------------------------------------------------------------*/
/* Exported functions --------------------------------------------------------*/
T_JZsdkReturnCode JZsdk_LibInit();
#ifdef __cplusplus
}
#endif
#endif
/************************ (C) COPYRIGHT DJI Innovations *******END OF FILE******/
... ...
/**
********************************************************************
* @file JZsdkBase.h
* JZsdk基础部件的头文件
*
*********************************************************************
*/
/* Define to prevent recursive inclusion 避免重定义 -------------------------------------*/
#ifndef JZSDKBASE_H
#define JZSDKBASE_H
/* Includes ------------------------------------------------------------------*/
#ifdef __cplusplus
extern "C" {
#endif
/* Exported constants --------------------------------------------------------*/
/* 常亮定义*/
#include "JZsdk_Logger/JZsdk_Logger.h"
#include "JZsdk_Osal/JZsdk_FileSystm.h"
#include "JZsdk_Delay/JZsdk_Delay.h"
#include "JZsdk_Code/JZsdk_FLagCode.h"
#include "JZsdk_Osal/JZsdk_MemoryAdapter.h"
/* Exported types ------------------------------------------------------------*/
/* Exported functions --------------------------------------------------------*/
#ifdef __cplusplus
}
#endif
#endif
... ...
/**
********************************************************************
* @file JZsdk_Code.h
* 用于记录各类码的表
*
*********************************************************************
*/
/* Define to prevent recursive inclusion 避免重定义 -------------------------------------*/
#ifndef JZSDK_CODE_H
#define JZSDK_CODE_H
/* Includes ------------------------------------------------------------------*/
#ifdef __cplusplus
extern "C" {
#endif
/* Exported constants --------------------------------------------------------*/
/* 常亮定义*/
#include "./JZsdk_InsCode.h"
#include "./JZsdk_FLagCode.h"
#include "./JZsdk_ReturnCode.h"
#include "./JZsdk_FileType.h"
/* Exported types ------------------------------------------------------------*/
/* Exported functions --------------------------------------------------------*/
#ifdef __cplusplus
}
#endif
#endif
... ...
/**
********************************************************************
* @file JZsdk_ErrorCode.h
* 用于错误码的表
*
*********************************************************************
*/
/* Define to prevent recursive inclusion 避免重定义 -------------------------------------*/
#ifndef JZSDK_ERRORCODE_H
#define JZSDK_ERRORCODE_H
/* Includes ------------------------------------------------------------------*/
#ifdef __cplusplus
extern "C" {
#endif
/* Exported constants --------------------------------------------------------*/
/* 常亮定义*/
/* Exported types ------------------------------------------------------------*/
typedef enum {
JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS = 0x0000,
JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE = 0x0001,
JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER = 0x0002, //文件指针错误
} JZ_SYSTEM_Code;
typedef enum {
JZ_ERROR_SYSTEM_FRAME_ERROR = 0x0100,
} JZ_Syetem_frame_ErrorCode;
typedef enum {
JZ_ERRORCODE_MUSIC_NOT_FOUND_IN_LIST = 0x1000
} JZ_Megaphone_music_ErrorCode;
typedef enum {
JZ_ERRORCODE_REALTIMEVOICE_HAS_BEEN_ON = 0x1201
} JZ_Megaphone_opus_ErrorCode;
typedef enum {
JZ_ERRORCODE_TTS_INVALID_TONE = 0x1300,
JZ_ERRORCODE_TTS_INVALID_SPEED = 0x1301,
JZ_ERRORCODE_TTS_INVALID_ADDTONE = 0x1302,
} JZ_Megaphone_TTS_ErrorCode;
typedef enum {
JZ_ERRORCODE_GIMBAL_INVALID_PITCH = 0x4000,
JZ_ERRORCODE_GIMBAL_INVALID_YAW = 0x4001,
JZ_ERRORCODE_GIMBAL_INVALID_ROLL = 0x4002,
} JZ_Gimbal_ErrorCode;
/* Exported functions --------------------------------------------------------*/
#ifdef __cplusplus
}
#endif
#endif
... ...
/**
********************************************************************
* @file JZsdk_FLagCode.h
* 用于标识码的表
*
*********************************************************************
*/
/* Define to prevent recursive inclusion 避免重定义 -------------------------------------*/
#ifndef JZSDK_FLAGCODE_H
#define JZSDK_FLAGCODE_H
/* Includes ------------------------------------------------------------------*/
#ifdef __cplusplus
extern "C" {
#endif
/* Exported constants --------------------------------------------------------*/
/* 常亮定义*/
typedef enum JZ_Flag_Code{
JZ_FLAGCODE_OFF = 0x0000,
JZ_FLAGCODE_ON = 0x0001,
JZ_FLAGCODE_GET = 0x0010, //获取指令
JZ_FLAGCODE_SET = 0x0011, //设置指令
JZ_FLAGCODE_NORMAL = 0x00FF, //默认模式
} JZ_Flag_Code;
/* Exported types ------------------------------------------------------------*/
/* Exported functions --------------------------------------------------------*/
#ifdef __cplusplus
}
#endif
#endif
... ...
/**
********************************************************************
* @file JZsdk_FileType.h
* 用于记录文件类型的表
*
*********************************************************************
*/
/* Define to prevent recursive inclusion 避免重定义 -------------------------------------*/
#ifndef JZSDK_FILE_TYPE_H
#define JZSDK_FILE_TYPE_H
/* Includes ------------------------------------------------------------------*/
#ifdef __cplusplus
extern "C" {
#endif
/* Exported constants --------------------------------------------------------*/
/* 常亮定义*/
/* Exported types ------------------------------------------------------------*/
typedef enum {
AUDIO_TYPE_WAV = 0x00000001,
AUDIO_TYPE_MP3 = 0x00000002,
AUDIO_TYPE_OPUS = 0x00000003,
AUDIO_TYPE_PCM = 0x00000004,
} JZ_AUDIO_FILE_TYPE;
/* Exported functions --------------------------------------------------------*/
#ifdef __cplusplus
}
#endif
#endif
... ...
/**
********************************************************************
* @file JZsdk_InsCode.h
* 用于错误码的表
*
*********************************************************************
*/
/* Define to prevent recursive inclusion 避免重定义 -------------------------------------*/
#ifndef JZSDK_INSCODE_H
#define JZSDK_INSCODE_H
/* Includes ------------------------------------------------------------------*/
#ifdef __cplusplus
extern "C" {
#endif
/* Exported constants --------------------------------------------------------*/
/* 常亮定义*/
typedef enum {
//5A类帧
JZ_INSCODE_5AFRAME_FRAME = 0x10000000, //接收类帧
JZ_INSCODE_5AFRAME_ASKFORCONNECT = 0x10000100, //申请连接
JZ_INSCODE_5AFRAME_HEARTBEAT = 0x10000101, //心跳帧
JZ_INSCODE_5AFRAME_TIMESTAMP = 0x10000102, //时间戳帧
JZ_INSCODE_5AFRAME_ALL_VERSION = 0x10000103, //全版本查询
JZ_INSCODE_5AFRAME_ALL_SERIAL_NUMBER = 0x10000104, //全序列号查询
JZ_INSCODE_5AFRAME_LOG_MESSAGE_PRINTF = 0x10000105, //log信息打印
JZ_INSCODE_5AFRAME_DEVICE_MESSAGE = 0x10000106, //设备信息
JZ_INSCODE_5AFRAME_FRAME_POWER_STATUS = 0x10000110, //电源状态设置
JZ_INSCODE_5AFRAME_REALTIMEMP2_START = 0x10000200, //开启实时MP2
JZ_INSCODE_5AFRAME_REALTIMEMP2_UNLIMIT_TRANSMISSION = 0x10000201, //无限制传输实时MP2
JZ_INSCODE_5AFRAME_REALTIMEMP2_STOP = 0x10000202, //结束实时MP2
JZ_INSCODE_5AFRAME_REALTIMEMP2_LIMIT_TRANSMISSION = 0x10000203, //有限制传输MP2
JZ_INSCODE_5AFRAME_AUDIOFILE_TRANS_START = 0x10000300, //打开音频文件上传
JZ_INSCODE_5AFRAME_AUDIOFILE_TRANS_UNLIMIT_TRANSMISSION = 0x10000301, //无限制传输音频文件
JZ_INSCODE_5AFRAME_AUDIOFILE_TRANS_STOP = 0x10000302, //关闭音频文件上传
JZ_INSCODE_5AFRAME_AUDIOFILE_TRANS_LIMIT_TRANSMISSION = 0x10000303, //定长传输音频文件
JZ_INSCODE_5AFRAME_AUDIO_PLAYFILE = 0x10000400, //播放指定音频
JZ_INSCODE_5AFRAME_AUDIO_CONTINUE = 0x10000401, //音频继续播放
JZ_INSCODE_5AFRAME_AUDIO_PAUSE = 0x10000402, //音频暂停播放
JZ_INSCODE_5AFRAME_AUDIO_STOP = 0x10000403, //音频停止播放
JZ_INSCODE_5AFRAME_AUDIO_LASTSONG = 0x10000410, //音频上一曲
JZ_INSCODE_5AFRAME_AUDIO_NEXTSONG = 0x10000411, //音频下一曲
JZ_INSCODE_5AFRAME_AUDIO_GETMUSICLIST = 0x10000420, //获取音频列表
JZ_INSCODE_5AFRAME_AMPLIFIER_STOP = 0x10000500, //强制关闭功放
JZ_INSCODE_5AFRAME_AMPLIFIER_OPEN = 0x10000501, //强制开启功放
JZ_INSCODE_5AFRAME_AMPLIFIER_AUTO = 0x10000502, //恢复自动功放
JZ_INSCODE_5AFRAME_VOLUME = 0x10000600, //调节音量
JZ_INSCODE_5AFRAME_CHECKSTATUS_VOLUME = 0x10000620, //查询音量
JZ_INSCODE_5AFRAME_CHECKSTATUS_PLAY = 0x10000621, //查询播放状态
JZ_INSCODE_5AFRAME_CHECKSTATUS_GIMBAL = 0x10000622, //查询云台角度
JZ_INSCODE_5AFRAME_CHECKSTATUS_GIMBAL_FINETUNING = 0x10000623, //查询云台微调角度
JZ_INSCODE_5AFRAME_CHECKSTATUS_PLAYFILENAME = 0x10000624, //查询播放文件名
JZ_INSCODE_5AFRAME_CHECKSTATUS_SOFTWAREVERSION = 0x10000625, //查询软件版本号
JZ_INSCODE_5AFRAME_CHECKSTATUS_LOOPPLAY = 0x10000626, //查询是否打开循环
JZ_INSCODE_5AFRAME_CHECKSTATUS_TTSTONE = 0x10000627, //查询音色
JZ_INSCODE_5AFRAME_CHECKSTATUS_TTSSPEED = 0x10000628, //查询语速
JZ_INSCODE_5AFRAME_CHECKSTATUS_SEARCHLIGHT_LIGHTATTRIBUTE = 0x10000629, //查询探照灯 灯3个属性
JZ_INSCODE_5AFRAME_CHECKSTATUS_SEARCHLIGHT_LUMEN = 0x10000630, //查询探照灯流明
JZ_INSCODE_5AFRAME_CHECKSTATUS_SEARCHLIGHT_FREQUENCY = 0x10000631, //查询探照灯频率
JZ_INSCODE_5AFRAME_CHECKSTATUS_SEARCHLIGHT_MODE = 0x10000632, //查询探照灯模式
JZ_INSCODE_5AFRAME_CHECKSTATUS_SEARCHLIGHT_TEMPERATURE = 0x10000633, //查询探照灯温度
JZ_INSCODE_5AFRAME_CHECKSTATUS_LASER_STATUS = 0x10000634, //查询激光状态
JZ_INSCODE_5AFRAME_CHECKSTATUS_WARNINGLIGHT_STATUS = 0x10000635, //查询警灯状态
JZ_INSCODE_5AFRAME_CHECKSTATUS_WARNINGLIGHT_COLOR = 0x10000636, //查询警灯颜色
JZ_INSCODE_5AFRAME_CHECKSTATUS_SERIALNUMBER = 0x10000637, //查询序列号
JZ_INSCODE_5AFRAME_PLAY_LOOP = 0x10000690, //开启关闭循环
JZ_INSCODE_5AFRAME_DELETE_AUDIO = 0x10000700, //删除音频
JZ_INSCODE_5AFRAME_DELETE_VOICE_RECORD = 0x10000710, //删除录音
JZ_INSCODE_5AFRAME_DELETE_VIDEO_RECORD = 0x10000720, //删除视频
JZ_INSCODE_5AFRAME_TTS_SET_TONE = 0x10000801, //TTS设置音色
JZ_INSCODE_5AFRAME_TTS_SET_SPEED = 0x10000802, //TTS设置语速
JZ_INSCODE_5AFRAME_TTS_TRANS_START = 0x10000803, //TTS开始发送
JZ_INSCODE_5AFRAME_TTS_TRANS_UNLIMIT_TRANSMISSION = 0x10000804, //TTS正在无限制接收
JZ_INSCODE_5AFRAME_TTS_TRANS_STOP = 0x10000805, //TTS发送完毕
JZ_INSCODE_5AFRAME_TTS_TRANS_LIMIT_TRANSMISSION = 0x10000806, //TTS正在定长接收
JZ_INSCODE_5AFRAME_OPUS_TRANS_START = 0x10000900, //opus传输开始
JZ_INSCODE_5AFRAME_OPUS_TRAN_UNLIMIT_TRANSMISSION = 0x10000901, //opus 无限制传输中
JZ_INSCODE_5AFRAME_OPUS_TRANS_LIMIT_TRANSMISSION = 0x10000903, //opus传输中
JZ_INSCODE_5AFRAME_OPUS_TRANS_STOP = 0x10000902, //opus传输结束
JZ_INSCODE_5AFRAME_OPUS_PLAY = 0x10000910, //opus播放
JZ_INSCODE_5AFRAME_OPUS_REALTIMEVOICE_START = 0x10000A00, //开启opus实时语音
JZ_INSCODE_5AFRAME_OPUS_REALTIMEVOICE_UNLIMIT_TRANSMISSION = 0x10000A01, //无限制传输opus实时语音
JZ_INSCODE_5AFRAME_OPUS_REALTIMEVOICE_STOP = 0x10000A02, //结束opus实时语音
JZ_INSCODE_5AFRAME_OPUS_REALTIMEVOICE_LIMIT_TRANSMISSION = 0x10000A03, //定长传输opus实时语音
JZ_INSCODE_5AFRAME_GIMBAL_PITCH_CONTROL = 0x10000B00, //云台俯仰控制
JZ_INSCODE_5AFRAME_GIMBAL_YAW_CONTROL = 0x10000B01, //云台朝向控制
JZ_INSCODE_5AFRAME_GIMBAL_ROLL_CONTROL = 0x10000B02, //云台旋转控制
JZ_INSCODE_5AFRAME_GIMBAL_PITCH_FINETUNING_CONTROL = 0x10000B04, //云台俯仰微调
JZ_INSCODE_5AFRAME_GIMBAL_YAW_FINETUNING_CONTROL = 0x10000B05, //云台朝向微调
JZ_INSCODE_5AFRAME_GIMBAL_ROLL_FINETUNING_CONTROL = 0x10000B06, //云台旋转微调
JZ_INSCODE_5AFRAME_LASER_CONTROL = 0x10000C00, //激光控制
JZ_INSCODE_5AFRAME_SEARCHLIGHT_CONTROL = 0x10000E00, //探照灯开光
JZ_INSCODE_5AFRAME_SEARCHLIGHT_SET_LUMEN = 0x10000E10, //设置探照灯亮度
JZ_INSCODE_5AFRAME_SEARCHLIGHT_SET_FREQUENCY = 0x10000E20, //设置把爆闪频率
JZ_INSCODE_5AFRAME_SEARCHLIGHT_MESSAGE_SUBSCRIPTION_CONTROL = 0x10000E21,//探照灯消息订阅控制
JZ_INSCODE_5AFRAME_WARNINGLIGHT_CONTROL = 0x10000F00, //警示灯模式控制
JZ_INSCODE_5AFRAME_WARNINGLIGHT_COLOUR = 0x10000F10, //警示灯颜色控制
JZ_INSCODE_5AFRAME_OUTPUTPOWER_CONTROL = 0x10001000, //对外供电开关
JZ_INSCODE_5AFRAME_CHECKSTATUS_OUTPUTPOWER = 0x10001001, //对外供电查询
//5B类帧
JZ_INSCODE_5BFRAME_FRAME = 0x10004000, //发送帧
JZ_INSCODE_5BFRAME_INITIATECONNECT = 0x10004101, //主动连接
JZ_INSCODE_5BFRAME_HEARTBEAT = 0x10004102, //心跳帧回复
JZ_INSCODE_5BFRAME_TIMESTAMP = 0x10004103, //时间戳帧
JZ_INSCODE_5BFRAME_ALL_VERSION = 0x10004104, //全版本查询
JZ_INSCODE_5BFRAME_ALL_SERIAL_NUMBER = 0x10004105, //全序列号查询
JZ_INSCODE_5BFRAME_DEVICE_MESSAGE = 0x10004107, //设备信息
JZ_INSCODE_5BFRAME_SUCESS = 0x10004200, //操作成功
JZ_INSCODE_5BFRAME_DEFEAT = 0x10004201, //操作失败
JZ_INSCODE_5BFRAME_MUSICLIST_START = 0x10004300, //开启发送音乐列表帧
JZ_INSCODE_5BFRAME_MUSICLIST_TRANS = 0x10004301, //发送音乐列表帧
JZ_INSCODE_5BFRAME_MUSICLIST_STOP = 0x10004302, //结束发送音乐列表帧
JZ_INSCODE_5BFRAME_AUDIO_PLAYSTATUS = 0x10004310, //音频播放状态返回帧
JZ_INSCODE_5BFRAME_AUDIO_PLAYSTATUS_END = 0x10004311, //音频播放状态结束帧
JZ_INSCODE_5BFRAME_VOLUME = 0x10004400, //音量返回帧
JZ_INSCODE_5BFRAME_AUDIO_PLAYLOOPSTATUS = 0x10004401, //发送音频循环播放状态
JZ_INSCODE_5BFRAME_TTS_TONE = 0x10004402, //发送tts音色
JZ_INSCODE_5BFRAME_TTS_SPEED = 0x10004403, //发送tts语速
JZ_INSCODE_5BFRAME_AUDIO_PLAYFILENAME = 0x10004404, //当前播放的音频名字
JZ_INSCODE_5BFRAME_GIMBAL_PITCH = 0x10004500, //云台俯仰角度
JZ_INSCODE_5BFRAME_GIMBAL_YAW = 0x10004501, //云台航向角度
JZ_INSCODE_5BFRAME_GIMBAL_ROLL = 0x10004502, //
JZ_INSCODE_5BFRAME_GIMBAL_PITCH_FINETUNING = 0x10004510, //云台俯仰微调值
JZ_INSCODE_5BFRAME_CHECKSTATUS_SEARCHLIGHT_TEMPERATURE = 0x10004600, //查询探照灯温度
JZ_INSCODE_5BFRAME_CHECKSTATUS_LASER_STATUS = 0x10004601, //查询激光状态
JZ_INSCODE_5BFRAME_CHECKSTATUS_SEARCHLIGHT_FREQUENCY = 0x10004602, //查询探照灯频率
JZ_INSCODE_5BFRAME_CHECKSTATUS_SEARCHLIGHT_MODE = 0x10004603, //查询探照灯模式
JZ_INSCODE_5BFRAME_CHECKSTATUS_SEARCHLIGHT_LUMEN = 0x10004604, //查询探照灯流明
JZ_INSCODE_5BFRAME_CHECKSTATUS_WARNINGLIGHT_STATUS = 0x10004700, //警示灯模式控制
JZ_INSCODE_5BFRAME_CHECKSTATUS_WARNINGLIGHT_COLOR = 0x10004701, //警示灯颜色控制
JZ_INSCODE_5BFRAME_SORTWAREVERSION = 0x10004800, //发送软件版本号
JZ_INSCODE_5BFRAME_HARDWAREVERSION = 0x10004801, //发送硬件版本号
JZ_INSCODE_5BFRAME_CHECKSTATUS_SERIALNUMBER = 0x10004802, //回复序列号
JZ_INSCODE_5BFRAME_CHECKSTATUS_OUTPUTPOWER = 0x10004900, //对外供电查询
JZ_INSCODE_5BFRAME_OPUS_DECODE_STATUS = 0x10005000, //opus解码状态
//6A类
JZ_INSCODE_6AFRAME_FRAME = 0x10008000, //发送帧
JZ_INSCODE_6AFRAME_SET_GIMBAL_ORIGIN = 0x10008101, //设置坐标0值
JZ_INSCODE_6AFRAME_SET_GIMBAL_MAXMIN_RANGE = 0x10008102, //设置云台范围最大最小值
JZ_INSCODE_6AFRAME_SET_LUMEN_MAXMIN_RANGE = 0x10008103, //设置灯光范围最大最小值
JZ_INSCODE_6AFRAME_SET_SERIALNUMBER = 0x10008104, //设置序列号
JZ_INSCODE_6AFRAME_SERVO_SELFCHECK = 0x10008105, //舵机自检
JZ_INSCODE_6AFRAME_GIMBAL_LINKAGE_CONTROL = 0x10008106, //开关云台联动
JZ_INSCODE_6AFRAME_CHECKSTATUS_SECONDARY_DEVICE_NAME = 0x10008400, //查询从设备设备名
JZ_INSCODE_6AFRAME_CHECKSTATUS_GIMBAL_LINKAGE = 0x10008401, //查询云台联动
JZ_INSCODE_6AFRAME_UART_BITRATE_CHANGE = 0x10008500, //串口比特率修改
JZ_INSCODE_6AFRAME_SPECIAL_PARAMETERS = 0x10008510, //设置特殊参数
JZ_INSCODE_6AFRAME_CHECK_SPECIAL_PARAMETERS = 0x10008511, //查询特殊参数
//6B类
JZ_INSCODE_6BFRAME_CHECKSTATUS_SECONDARY_DEVICE_NAME = 0x1000C400, //回复从设备名
JZ_INSCODE_6BFRAME_CHECKSTATUS_GIMBAL_LINKAGE = 0x1000C401, //回复云台联动
JZ_INSCODE_6BFRAME_CHECK_SPECIAL_PARAMETERS = 0x1000C511, //回复特殊参数
} JZ_InsCode;
/* Exported types ------------------------------------------------------------*/
/* Exported functions --------------------------------------------------------*/
#ifdef __cplusplus
}
#endif
#endif
... ...
#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "./JZsdk_Code.h"
//获取返回码的信息
const char* JZsdk_GetReturnCodeMessage(T_JZsdkReturnCode ReturnCode)
{
switch (ReturnCode) {
case JZ_ERRORCODE_REALTIMEVOICE_HAS_BEEN_ON:
return "实时语音被开启,该操作失败";
default:
return "未知错误:Unknown error.";
}
}
... ...
/**
********************************************************************
* @file JZsdk_ReturnCode.h
* 用于记录各类码的表
*
*********************************************************************
*/
/* Define to prevent recursive inclusion 避免重定义 -------------------------------------*/
#ifndef JZSDK_RETURNCODE_H
#define JZSDK_RETURNCODE_H
/* Includes ------------------------------------------------------------------*/
#include <stdint.h>
#include "JZsdk_ErrorCode.h"
#ifdef __cplusplus
extern "C" {
#endif
/* Exported constants --------------------------------------------------------*/
/* 常亮定义*/
/* Exported types ------------------------------------------------------------*/
//重定义一个返回码
typedef uint64_t T_JZsdkReturnCode;
typedef uint8_t U8_t;
typedef uint16_t U16_t;
typedef uint32_t U32_t;
typedef uint64_t U64_t;
// typedef unsigned long T_JZsdkReturnCode;
// typedef unsigned char U8_t;
// typedef unsigned short U16_t;
// typedef unsigned int U32_t;
// typedef unsigned long U64_t;
typedef double F64_t;
typedef float F32_t;
/* Exported functions --------------------------------------------------------*/
const char* JZsdk_GetReturnCodeMessage(T_JZsdkReturnCode ReturnCode);
#ifdef __cplusplus
}
#endif
#endif
... ...
/**
********************************************************************
* @file JZsdk_SMT_Code.h
* 用于序列号管理的表
*
*********************************************************************
*/
/* Define to prevent recursive inclusion 避免重定义 -------------------------------------*/
#ifndef JZSDK_SMT_CODE_H
#define JZSDK_SMT_CODE_H
/* Includes ------------------------------------------------------------------*/
#ifdef __cplusplus
extern "C" {
#endif
/* Exported constants --------------------------------------------------------*/
/* 常亮定义*/
typedef enum
{
// 设备序列号类型
UNDEFINED_SNM = 0x0000, //未定义类型序列号
STANDARD_DJI_SNM = 0x0001, // 大疆转接环序列号类型
STANDARD_JZ_1_SNM = 0x0002, // JZ-1型序列号
STANDARD_JZ_2_SNM = 0x0003, // JZ-2型序列号 2023.12.14 制定
} JZSDK_SNM_TPYE;
typedef enum
{
// 设备激活码状态 0 未存在序列号 1 旧版序列号 2新版序列号未激活 3新版序列号已激活
SNM_NOT_EXISTS = 0x0000, // （未存在序列号）
SNM_HAVE_ACTIVATED = 0x0001, // 已激活
SNM_NOT_ACTIVATED = 0x0002, // 未激活
SNM_ERROR_ACTIVATED = 0x0003, //激活错误状态
} JZSDK_SNM_STATUS;
typedef enum
{
STANDARD_DJI_SNM_LENGTH = 14, //dji序列号默认长度14
STANDARD_JZ_1_SUM_LENGTH = 14, //极至标准1长度太多种拉 喊话器最长是14
STANDARD_JZ_2_SUM_LENGTH = 16, //极至标准2 16长度
}JZSDK_SNM_STANDARD_LENGTH;
typedef enum
{
STANDARD_JZ_2_CN = 0x0001, //极至标准2通用码
STANDARD_JZ_2_EN = 0x0002, //极至标准2海外码
}JZSDK_FIREWARM_CODE;
typedef enum
{
STANDARD_JZ_2_F1 = 0x0001, //通用版本固件
}JZSKD_SPECIAL_VERSION;
#ifdef __cplusplus
}
#endif
#endif
\ No newline at end of file
... ...
#include <stdio.h>
#include "JZsdk_Delay.h"
#include <unistd.h>
/*
* 用于延时（粗略）
* 需要优化
*/
int delayUs(unsigned long msec)
{
usleep(msec);
}
/*
* 用于延时（粗略）
* 需要优化
*/
int delayMs(unsigned long msec)
{
usleep(msec * 1000);
}
/*
* 用于延时（粗略）
* 需要优化
*/
int delayS(unsigned long sec)
{
delayMs(sec * 1000);
}
\ No newline at end of file
... ...
/**
********************************************************************
* @file JZsdk_FileSystem.h
* 用于文件系统操作
*
*********************************************************************
*/
/* Define to prevent recursive inclusion 避免重定义 -------------------------------------*/
#ifndef JZSDK_DELAY_H
#define JZSDK_DELAY_H
/* Includes ------------------------------------------------------------------*/
#ifdef __cplusplus
extern "C" {
#endif
/* Exported constants --------------------------------------------------------*/
/* 常亮定义*/
/* Exported types ------------------------------------------------------------*/
/* Exported functions --------------------------------------------------------*/
int delayMs(unsigned long msec);
int delayS(unsigned long sec);
int delayUs(unsigned long msec);
#ifdef __cplusplus
}
#endif
#endif
/************************ (C) COPYRIGHT DJI Innovations *******END OF FILE******/
... ...
#include <stdio.h>
#include "./JZsdk_FrameComparsion.h"
#include "../JZsdk_Code/JZsdk_Code.h"
/*************************
*
* 获取帧的序列号
*
* ***************************/
int JZsdk_Get_FrameSequence(char *DealBuf)
{
return DealBuf[6];
}
/***************************
* 、
*
* 帧校对 获取功能
*
*
* ***********************/
int JZsdk_FrameComparsion(char *getdata, int len)
{
//1、判断是否是5A帧
if (getdata[0] == 0x5A && getdata[1] == 0x5A && getdata[2] == 0x77)
{
printf("JZsdk_FrameComparsion:5A帧\n");
return JZsdk_5AFrameComparsion(getdata, len);
}
//2、判断是否是5B帧
if (getdata[0] == 0x5b && getdata[1] == 0x5b && getdata[2] == 0x77)
{
printf("JZsdk_FrameComparsion:5B帧\n");
return JZsdk_5BFrameComparsion(getdata, len);
}
//3、判断是否是6A帧
if (getdata[0] == 0x6A && getdata[1] == 0x6A && getdata[2] == 0x77)
{
printf("JZsdk_FrameComparsion:6A帧\n");
return JZsdk_6AFrameComparsion(getdata, len);
}
//4、判断是否是6B帧
if (getdata[0] == 0x6b && getdata[1] == 0x6b && getdata[2] == 0x77)
{
printf("JZsdk_FrameComparsion:6B帧\n");
return JZsdk_6BFrameComparsion(getdata, len);
}
printf("接受到的帧,没有帧头或者帧尾,退出recv帧判断函数\n");
return JZ_ERROR_SYSTEM_FRAME_ERROR;
}
\ No newline at end of file
... ...
/**
********************************************************************
* @file JZsdk_FrameComparsion.h
* 用于帧对比的头文件
*
*********************************************************************
*/
/* Define to prevent recursive inclusion 避免重定义 -------------------------------------*/
#ifndef JZSDK_FRAMECOMPARSION_H
#define JZSDK_FRAMECOMPARSION_H
/* Includes ------------------------------------------------------------------*/
#ifdef __cplusplus
extern "C" {
#endif
/* Exported constants --------------------------------------------------------*/
/* 常亮定义*/
#include "JZsdk_FrameComparsion_5Aframe.h"
#include "JZsdk_FrameComparsion_5Bframe.h"
#include "JZsdk_FrameComparsion_6Aframe.h"
#include "JZsdk_FrameComparsion_6Bframe.h"
#include "JZsdk_GetFrameTemplate.h"
/* Exported types ------------------------------------------------------------*/
/* Exported functions --------------------------------------------------------*/
int JZsdk_Get_FrameSequence(char *DealBuf);
int JZsdk_FrameComparsion(char *getdata, int len);
#ifdef __cplusplus
}
#endif
#endif
... ...
#include <stdio.h>
#include "../JZsdk_Code/JZsdk_Code.h"
/******************************************************
接收一级功能码区
/******************************************************/
//一级功能码是连接功能
static int Comparison_5AFRAME_FirstLevelCode_0x50(char *getdata)
{
//二级功能位
switch (getdata[8])
{
//开启连接
case 0x51:
return JZ_INSCODE_5AFRAME_ASKFORCONNECT;
break;
//设备电源状态
case 0x52:
return JZ_INSCODE_5AFRAME_FRAME_POWER_STATUS;
break;
//心跳帧
case 0x53:
return JZ_INSCODE_5AFRAME_HEARTBEAT;
break;
//时间戳帧
case 0x54:
return JZ_INSCODE_5AFRAME_TIMESTAMP;
break;
//所有版本号帧
case 0x55:
return JZ_INSCODE_5AFRAME_ALL_VERSION;
break;
//所有序列号帧
case 0x56:
return JZ_INSCODE_5AFRAME_ALL_SERIAL_NUMBER;
break;
//log信息打印
case 0x57:
return JZ_INSCODE_5AFRAME_LOG_MESSAGE_PRINTF;
break;
//获取设备信息帧
case 0x58:
return JZ_INSCODE_5AFRAME_DEVICE_MESSAGE;
break;
default:
return JZ_ERROR_SYSTEM_FRAME_ERROR;
break;
}
}
//一级功能码是语音 或是 文件功能
static int Comparison_5AFRAME_FirstLevelCode_0x51(char *getdata)
{
//二级功能位
switch (getdata[8])
{
//开启语音
case 0xb1:
return JZ_INSCODE_5AFRAME_REALTIMEMP2_START;
break;
//结束语音
case 0xb2:
return JZ_INSCODE_5AFRAME_REALTIMEMP2_STOP;
break;
//有限制传输mp2语言
case 0xb3:
return JZ_INSCODE_5AFRAME_REALTIMEMP2_LIMIT_TRANSMISSION;
break;
//打开音频文件上传
case 0x01:
return JZ_INSCODE_5AFRAME_AUDIOFILE_TRANS_START;
break;
//有限制传输音频文件
case 0x02:
return JZ_INSCODE_5AFRAME_AUDIOFILE_TRANS_LIMIT_TRANSMISSION;
break;
//关闭音频文件上传
case 0x03:
return JZ_INSCODE_5AFRAME_AUDIOFILE_TRANS_STOP;
break;
default:
return JZ_ERROR_SYSTEM_FRAME_ERROR;
break;
}
}
//一级功能码是音频/功放/音量调节
static int Comparison_5AFRAME_FirstLevelCode_0x52(char *getdata)
{
//二级功能位
switch (getdata[8])
{
//播放指定音频
case 0x02:
return JZ_INSCODE_5AFRAME_AUDIO_PLAYFILE;
break;
//音频继续播放
case 0x04:
return JZ_INSCODE_5AFRAME_AUDIO_CONTINUE;
break;
//音频暂停播放
case 0x05:
return JZ_INSCODE_5AFRAME_AUDIO_PAUSE;
break;
//音频停止播放
case 0x06:
return JZ_INSCODE_5AFRAME_AUDIO_STOP;
break;
//音频上一曲
case 0x07:
return JZ_INSCODE_5AFRAME_AUDIO_LASTSONG;
break;
//音频下一曲
case 0x08:
return JZ_INSCODE_5AFRAME_AUDIO_NEXTSONG;
break;
//强制关闭功放
case 0x20:
return JZ_INSCODE_5AFRAME_AMPLIFIER_STOP;
break;
//强制开启功放
case 0x21:
return JZ_INSCODE_5AFRAME_AMPLIFIER_OPEN;
break;
//恢复自动功放
case 0x22:
return JZ_INSCODE_5AFRAME_AMPLIFIER_AUTO;
break;
//调节音量
case 0x10:
return JZ_INSCODE_5AFRAME_VOLUME;
break;
default:
return JZ_ERROR_SYSTEM_FRAME_ERROR;
break;
}
}
//一级功能码是查询状态
static int Comparison_5AFRAME_FirstLevelCode_0x53(char *getdata)
{
//二级功能位
switch (getdata[8])
{
//查询音量
case 0x01:
return JZ_INSCODE_5AFRAME_CHECKSTATUS_VOLUME;
break;
//查询播放状态
case 0x02:
return JZ_INSCODE_5AFRAME_CHECKSTATUS_PLAY;
break;
//查询云台角度(已舍弃)
case 0x03:
return JZ_INSCODE_5AFRAME_CHECKSTATUS_GIMBAL;
break;
//查询播放文件名
case 0x04:
return JZ_INSCODE_5AFRAME_CHECKSTATUS_PLAYFILENAME;
break;
//查询是否打开循环
case 0x05:
return JZ_INSCODE_5AFRAME_CHECKSTATUS_LOOPPLAY;
break;
//查询音色
case 0x06:
return JZ_INSCODE_5AFRAME_CHECKSTATUS_TTSTONE;
break;
//查询语速
case 0x07:
return JZ_INSCODE_5AFRAME_CHECKSTATUS_TTSSPEED;
break;
//查询软件版本号
case 0xf1:
return JZ_INSCODE_5AFRAME_CHECKSTATUS_SOFTWAREVERSION;
break;
default:
return JZ_ERROR_SYSTEM_FRAME_ERROR;
break;
}
}
//一级功能码是删除
static int Comparison_5AFRAME_FirstLevelCode_0x54(char *getdata)
{
//二级功能位
switch (getdata[8])
{
//删除音频
case 0x02:
return JZ_INSCODE_5AFRAME_DELETE_AUDIO;
break;
//删除录音
case 0x03:
return JZ_INSCODE_5AFRAME_DELETE_VOICE_RECORD;
break;
// //删除视频
// case 0x02:
// return JZ_INSCODE_DELETE_VIDEO_RECORD;
// break;
default:
return JZ_ERROR_SYSTEM_FRAME_ERROR;
break;
}
}
//一级功能码开启关闭循环
static int Comparison_5AFRAME_FirstLevelCode_0x55(char *getdata)
{
//二级功能位
switch (getdata[8])
{
//开启关闭循环
case 0x00:
return JZ_INSCODE_5AFRAME_PLAY_LOOP;
break;
default:
return JZ_ERROR_SYSTEM_FRAME_ERROR;
break;
}
}
//一级功能码
static int Comparison_5AFRAME_FirstLevelCode_0x56(char *getdata)
{
//二级功能位
switch (getdata[8])
{
default:
return JZ_ERROR_SYSTEM_FRAME_ERROR;
break;
}
}
//一级功能码是 文本播放
static int Comparison_5AFRAME_FirstLevelCode_0x57(char *getdata)
{
//二级功能位
switch (getdata[8])
{
//设置音色
case 0x01:
return JZ_INSCODE_5AFRAME_TTS_SET_TONE;
break;
//设置语速
case 0x02:
return JZ_INSCODE_5AFRAME_TTS_SET_SPEED;
break;
//开始发送TTS
case 0x03:
return JZ_INSCODE_5AFRAME_TTS_TRANS_START;
break;
case 0x04:
return JZ_INSCODE_5AFRAME_TTS_TRANS_STOP;
break;
//定长传输文本
case 0x05:
return JZ_INSCODE_5AFRAME_TTS_TRANS_LIMIT_TRANSMISSION;
break;
default:
break;
}
}
//一级功能 查询列表
static int Comparison_5AFRAME_FirstLevelCode_0x58(char *getdata)
{
//二级功能位
switch (getdata[8])
{
//设置音色
case 0x01:
return JZ_INSCODE_5AFRAME_AUDIO_GETMUSICLIST;
break;
default:
break;
}
}
//一级功能码opus功能
static int Comparison_5AFRAME_FirstLevelCode_0x59(char *getdata)
{
//二级功能位
switch (getdata[8])
{
//opus录音传输
//opus传输开始
case 0xF1:
return JZ_INSCODE_5AFRAME_OPUS_TRANS_START;
break;
//opus传输结束
case 0xF2:
return JZ_INSCODE_5AFRAME_OPUS_TRANS_STOP;
break;
//opus定长传输
case 0xF3:
return JZ_INSCODE_5AFRAME_OPUS_TRANS_LIMIT_TRANSMISSION;
break;
//opus播放
case 0x01:
return JZ_INSCODE_5AFRAME_OPUS_PLAY;
break;
//opus实时语音开始
case 0xE1:
return JZ_INSCODE_5AFRAME_OPUS_REALTIMEVOICE_START;
break;
case 0xE2:
return JZ_INSCODE_5AFRAME_OPUS_REALTIMEVOICE_STOP;
break;
//opus定长传输文件
case 0xE3:
return JZ_INSCODE_5AFRAME_OPUS_REALTIMEVOICE_LIMIT_TRANSMISSION;
break;
default:
return JZ_ERROR_SYSTEM_FRAME_ERROR;
break;
}
}
//一级功能码，硬件引脚控制
static int Comparison_5AFRAME_FirstLevelCode_0x5A(char *getdata)
{
//二级功能位
switch (getdata[8])
{
//对外供电开关
case 0x01:
return JZ_INSCODE_5AFRAME_OUTPUTPOWER_CONTROL;
break;
//对外供电查询
case 0x02:
return JZ_INSCODE_5AFRAME_CHECKSTATUS_OUTPUTPOWER;
break;
default:
return JZ_ERROR_SYSTEM_FRAME_ERROR;
break;
}
}
//一级功能码 激光控制
static int Comparison_5AFRAME_FirstLevelCode_0x60(char *getdata)
{
//二级功能位
switch (getdata[8])
{
//激光控制
case 0x51:
return JZ_INSCODE_5AFRAME_LASER_CONTROL;
break;
default:
return JZ_ERROR_SYSTEM_FRAME_ERROR;
break;
}
}
//一级功能码 爆闪频率
static int Comparison_5AFRAME_FirstLevelCode_0x61(char *getdata)
{
//二级功能位
switch (getdata[8])
{
//爆闪频率
case 0x51:
return JZ_INSCODE_5AFRAME_SEARCHLIGHT_SET_FREQUENCY;
break;
default:
return JZ_ERROR_SYSTEM_FRAME_ERROR;
break;
}
}
//一级功能码 灯光控制
static int Comparison_5AFRAME_FirstLevelCode_0x62(char *getdata)
{
//二级功能位
switch (getdata[8])
{
//灯光模式
case 0x51:
return JZ_INSCODE_5AFRAME_SEARCHLIGHT_CONTROL;
break;
default:
return JZ_ERROR_SYSTEM_FRAME_ERROR;
break;
}
}
//一级功能码 灯光亮度
static int Comparison_5AFRAME_FirstLevelCode_0x63(char *getdata)
{
//二级功能位
switch (getdata[8])
{
//灯光亮度
case 0x51:
return JZ_INSCODE_5AFRAME_SEARCHLIGHT_SET_LUMEN;
break;
default:
return JZ_ERROR_SYSTEM_FRAME_ERROR;
break;
}
}
//一级功能码云台功能
static int Comparison_5AFRAME_FirstLevelCode_0x64(char *getdata)
{
//二级功能位
switch (getdata[8])
{
//云台俯仰控制
case 0x51:
return JZ_INSCODE_5AFRAME_GIMBAL_PITCH_CONTROL;
break;
//云台俯仰微调控制
case 0x52:
return JZ_INSCODE_5AFRAME_GIMBAL_PITCH_FINETUNING_CONTROL;
break;
default:
return JZ_ERROR_SYSTEM_FRAME_ERROR;
break;
}
}
//一级功能码 云台航向
static int Comparison_5AFRAME_FirstLevelCode_0x65(char *getdata)
{
}
//一级功能码 警灯模式控制
static int Comparison_5AFRAME_FirstLevelCode_0x66(char *getdata)
{
switch (getdata[8])
{
//警灯模式控制
case 0x51:
return JZ_INSCODE_5AFRAME_WARNINGLIGHT_CONTROL;
break;
default:
return JZ_ERROR_SYSTEM_FRAME_ERROR;
break;
}
}
//一级功能码 警灯眼色选择
static int Comparison_5AFRAME_FirstLevelCode_0x67(char *getdata)
{
switch (getdata[8])
{
//警灯颜色选择
case 0x51:
return JZ_INSCODE_5AFRAME_WARNINGLIGHT_COLOUR;
break;
default:
return JZ_ERROR_SYSTEM_FRAME_ERROR;
break;
}
}
//一级功能码 探照灯消息订阅
static int Comparison_5AFRAME_FirstLevelCode_0x68(char *getdata)
{
switch (getdata[8])
{
//探照灯消息订阅
case 0x51:
return JZ_INSCODE_5AFRAME_SEARCHLIGHT_MESSAGE_SUBSCRIPTION_CONTROL;
break;
default:
return JZ_ERROR_SYSTEM_FRAME_ERROR;
break;
}
}
//一级功能码 私有协议
static int Comparison_5AFRAME_FirstLevelCode_0x69(char *getdata)
{
}
//一级功能码 6F查询帧
static int Comparison_5AFRAME_FirstLevelCode_0x6F(char *getdata)
{
//二级功能位
switch (getdata[8])
{
//灯光查询
case 0x51:
return JZ_INSCODE_5AFRAME_CHECKSTATUS_SEARCHLIGHT_LIGHTATTRIBUTE;
break;
//温度查询
case 0x52:
return JZ_INSCODE_5AFRAME_CHECKSTATUS_SEARCHLIGHT_TEMPERATURE;
break;
//激光查询
case 0x53:
return JZ_ERROR_SYSTEM_FRAME_ERROR;
break;
//云台角度查询
case 0x54:
return JZ_INSCODE_5AFRAME_CHECKSTATUS_GIMBAL;
break;
//警灯状态查询
case 0x55:
return JZ_INSCODE_5AFRAME_CHECKSTATUS_WARNINGLIGHT_STATUS;
break;
//警灯颜色查询
case 0x56:
return JZ_INSCODE_5AFRAME_CHECKSTATUS_WARNINGLIGHT_COLOR;
break;
//产品序列号查询
case 0x57:
return JZ_INSCODE_5AFRAME_CHECKSTATUS_SERIALNUMBER;
break;
//云台微调值查询
case 0x58:
return JZ_INSCODE_5AFRAME_CHECKSTATUS_GIMBAL_FINETUNING;
break;
default:
return JZ_ERROR_SYSTEM_FRAME_ERROR;
break;
}
}
/******************************************************************
回复帧对比
成功返回帧类型 无对比数据返回 JZ_ERROR_SYSTEM_FRAME_ERROR
******************************************************************/
int JZsdk_5AFrameComparsion(char *getdata, int len)
{
//1、判断帧头帧尾
if (
( (getdata[0]!= 0x5a) && (getdata[1] != 0x5a) && (getdata[2]!=0x77) )
|| ( (getdata[len -2]!= 0x00) && (getdata[ len -1] != 0x23) )
)
{
printf("接受到的帧,没有帧头或者帧尾,退出JZsdk_5AFrameComparsion函数\n");
return JZ_ERROR_SYSTEM_FRAME_ERROR;
}
//一级功能码
switch (getdata[7])
{
/*********************************************************************************************************************************************************
*
* 连接请求码
*
*********************************************************************************************************************************************************/
//一级功能码是连接请求
case 0x50:
return Comparison_5AFRAME_FirstLevelCode_0x50(getdata);
break;
/*********************************************************************************************************************************************************
*
* 喊话器功能码
*
*********************************************************************************************************************************************************/
//一级功能码 语音 / 音频文件功能
case 0x51:
return Comparison_5AFRAME_FirstLevelCode_0x51(getdata);
break;
//一级功能码 音频/ 功放/ 音量调节
case 0x52:
return Comparison_5AFRAME_FirstLevelCode_0x52(getdata);
break;
//一级功能码 查询状态
case 0x53:
return Comparison_5AFRAME_FirstLevelCode_0x53(getdata);
break;
//一级功能码 删除
case 0x54:
return Comparison_5AFRAME_FirstLevelCode_0x54(getdata);
break;
//一级功能码 开启关闭循环
case 0x55:
return Comparison_5AFRAME_FirstLevelCode_0x55(getdata);
break;
//一级功能码
case 0x56:
return Comparison_5AFRAME_FirstLevelCode_0x56(getdata);
break;
//一级功能码 TTS
case 0x57:
return Comparison_5AFRAME_FirstLevelCode_0x57(getdata);
break;
//一级功能码 查询列表功能
case 0x58:
return Comparison_5AFRAME_FirstLevelCode_0x58(getdata);
break;
//一级功能码 opus
case 0x59:
return Comparison_5AFRAME_FirstLevelCode_0x59(getdata);
break;
//一级功能码，硬件引脚控制
case 0x5A:
return Comparison_5AFRAME_FirstLevelCode_0x5A(getdata);
break;
//一级功能码 激光控制
case 0x60:
return Comparison_5AFRAME_FirstLevelCode_0x60(getdata);
break;
//一级功能码 爆闪控制
case 0x61:
return Comparison_5AFRAME_FirstLevelCode_0x61(getdata);
break;
//一级功能码 灯光控制
case 0x62:
return Comparison_5AFRAME_FirstLevelCode_0x62(getdata);
break;
//一级功能码 灯光亮度
case 0x63:
return Comparison_5AFRAME_FirstLevelCode_0x63(getdata);
break;
//一级功能码 云台俯仰
case 0x64:
return Comparison_5AFRAME_FirstLevelCode_0x64(getdata);
break;
//一级功能码 云台航向
case 0x65:
return Comparison_5AFRAME_FirstLevelCode_0x65(getdata);
break;
//一级功能码 警灯模式控制
case 0x66:
return Comparison_5AFRAME_FirstLevelCode_0x66(getdata);
break;
//一级功能码 警灯眼色选择
case 0x67:
return Comparison_5AFRAME_FirstLevelCode_0x67(getdata);
break;
//一级功能码 探照灯消息订阅
case 0x68:
return Comparison_5AFRAME_FirstLevelCode_0x68(getdata);
break;
//一级功能码 私有协议
case 0x69:
return Comparison_5AFRAME_FirstLevelCode_0x69(getdata);
break;
//一级功能码 6f查询帧
case 0x6F:
return Comparison_5AFRAME_FirstLevelCode_0x6F(getdata);
break;
break;
//一级功能码
/*********************************************************************************************************************************************************
*
*
*
*********************************************************************************************************************************************************/
default:
return JZ_ERROR_SYSTEM_FRAME_ERROR;
break;
}
}
... ...
/**********************************************************************
* @file
*
*
*********************************************************************
*/
/* Define to prevent recursive inclusion 避免重定义 -------------------------------------*/
#ifndef JZSDK_FRAMECOMPARSION_5AFRAME_H
#define JZSDK_FRAMECOMPARSION_5AFRAME_H
/* Includes ------------------------------------------------------------------*/
#ifdef __cplusplus
extern "C" {
#endif
/* Exported constants --------------------------------------------------------*/
/* 常亮定义*/
/* Exported types ------------------------------------------------------------*/
/* Exported functions --------------------------------------------------------*/
int JZsdk_5AFrameComparsion(char *getdata, int len);
#ifdef __cplusplus
}
#endif
#endif
... ...
#include <stdio.h>
#include "../JZsdk_Code/JZsdk_Code.h"
/******************************************************
接收一级功能码区
/******************************************************/
//一级功能码是连接功能
static int Comparison_5BFRAME_FirstLevelCode_0x50(char *getdata)
{
//二级功能位
switch (getdata[8])
{
//回复连接
case 0x51:
return JZ_INSCODE_5BFRAME_INITIATECONNECT;
break;
//心跳帧回复
case 0x53:
return JZ_INSCODE_5BFRAME_HEARTBEAT;
break;
//时间戳回复
case 0x54:
return JZ_INSCODE_5BFRAME_TIMESTAMP;
break;
//版本号回复
case 0x55:
return JZ_INSCODE_5BFRAME_ALL_VERSION;
break;
//序列号回复
case 0x56:
return JZ_INSCODE_5BFRAME_ALL_SERIAL_NUMBER;
break;
//log信息打印
case 0x58:
return JZ_INSCODE_5BFRAME_DEVICE_MESSAGE;
break;
default:
return JZ_ERROR_SYSTEM_FRAME_ERROR;
break;
}
}
//一级功能码是操作功能
static int Comparison_5BFRAME_FirstLevelCode_0x51(char *getdata)
{
//二级功能位
switch (getdata[8])
{
//回复操作成功
case 0x01:
return JZ_INSCODE_5BFRAME_SUCESS;
break;
//回复操作失败
case 0xff:
return JZ_INSCODE_5BFRAME_DEFEAT;
break;
default:
return JZ_ERROR_SYSTEM_FRAME_ERROR;
break;
}
}
//一级功能码是音频列表功能
static int Comparison_5BFRAME_FirstLevelCode_0x53(char *getdata)
{
//二级功能位
switch (getdata[8])
{
//音量返回
case 0x01:
return JZ_INSCODE_5BFRAME_VOLUME;
break;
//播放状态返回
case 0x02:
return JZ_INSCODE_5BFRAME_AUDIO_PLAYSTATUS;
break;
//当前播放文件名返回
case 0x04:
return JZ_INSCODE_5BFRAME_AUDIO_PLAYFILENAME;
break;
//查询是否开启循环
case 0x05:
return JZ_INSCODE_5BFRAME_AUDIO_PLAYLOOPSTATUS;
break;
//查询音色
case 0x06:
return JZ_INSCODE_5BFRAME_TTS_TONE;
break;
//查询语速
case 0x07:
return JZ_INSCODE_5BFRAME_TTS_SPEED;
break;
//版本返回
case 0xf1:
return JZ_INSCODE_5BFRAME_SORTWAREVERSION;
break;
//播放结束（主动返回）
case 0xff:
return JZ_INSCODE_5BFRAME_AUDIO_PLAYSTATUS_END;
break;
default:
return JZ_ERROR_SYSTEM_FRAME_ERROR;
break;
}
}
//一级功能码是音频列表功能
static int Comparison_5BFRAME_FirstLevelCode_0x58(char *getdata)
{
//二级功能位
switch (getdata[8])
{
//查询列表开始
case 0x00:
return JZ_INSCODE_5BFRAME_MUSICLIST_START;
break;
//文件列表帧
case 0x02:
return JZ_INSCODE_5BFRAME_MUSICLIST_TRANS;
break;
//结束列表返回
case 0xff:
return JZ_INSCODE_5BFRAME_MUSICLIST_STOP;
break;
default:
return JZ_ERROR_SYSTEM_FRAME_ERROR;
break;
}
}
//一级功能码是opus功能
static int Comparison_5BFRAME_FirstLevelCode_0x59(char *getdata)
{
//二级功能位
switch (getdata[8])
{
//opus解码状态
case 0xF2:
return JZ_INSCODE_5BFRAME_OPUS_DECODE_STATUS;
break;
default:
return JZ_ERROR_SYSTEM_FRAME_ERROR;
break;
}
}
//一级功能码是硬件引脚控制
static int Comparison_5BFRAME_FirstLevelCode_0x5A(char *getdata)
{
//二级功能位
switch (getdata[8])
{
//回复对供电开关状态返回
case 0x02:
return JZ_INSCODE_5BFRAME_CHECKSTATUS_OUTPUTPOWER;
break;
default:
return JZ_ERROR_SYSTEM_FRAME_ERROR;
break;
}
}
//一级功能码是激光
static int Comparison_5BFRAME_FirstLevelCode_0x60(char *getdata)
{
//二级功能位
switch (getdata[8])
{
//回复激光查询
case 0x51:
return JZ_INSCODE_5BFRAME_CHECKSTATUS_LASER_STATUS;
break;
default:
return JZ_ERROR_SYSTEM_FRAME_ERROR;
break;
}
}
//一级功能码是回复灯光频率
static int Comparison_5BFRAME_FirstLevelCode_0x61(char *getdata)
{
//二级功能位
switch (getdata[8])
{
//回复灯光频率
case 0x51:
return JZ_INSCODE_5BFRAME_CHECKSTATUS_SEARCHLIGHT_FREQUENCY;
break;
default:
return JZ_ERROR_SYSTEM_FRAME_ERROR;
break;
}
}
//一级功能码是回复灯光模式
static int Comparison_5BFRAME_FirstLevelCode_0x62(char *getdata)
{
//二级功能位
switch (getdata[8])
{
//回复灯光模式
case 0x51:
return JZ_INSCODE_5BFRAME_CHECKSTATUS_SEARCHLIGHT_MODE;
break;
default:
return JZ_ERROR_SYSTEM_FRAME_ERROR;
break;
}
}
//一级功能码是回复灯光亮度
static int Comparison_5BFRAME_FirstLevelCode_0x63(char *getdata)
{
//二级功能位
switch (getdata[8])
{
//回复灯光亮度
case 0x51:
return JZ_INSCODE_5BFRAME_CHECKSTATUS_SEARCHLIGHT_LUMEN;
break;
default:
return JZ_ERROR_SYSTEM_FRAME_ERROR;
break;
}
}
//一级功能码是云台俯仰
static int Comparison_5BFRAME_FirstLevelCode_0x64(char *getdata)
{
//二级功能位
switch (getdata[8])
{
//回复云台俯仰
case 0x51:
return JZ_INSCODE_5BFRAME_GIMBAL_PITCH;
break;
//回复云台俯仰微调值
case 0x52:
return JZ_INSCODE_5BFRAME_GIMBAL_PITCH_FINETUNING;
break;
default:
return JZ_ERROR_SYSTEM_FRAME_ERROR;
break;
}
}
//一级功能码是云台航向
static int Comparison_5BFRAME_FirstLevelCode_0x65(char *getdata)
{
//二级功能位
switch (getdata[8])
{
//回复云台航向
case 0x51:
return JZ_INSCODE_5BFRAME_GIMBAL_YAW;
break;
default:
return JZ_ERROR_SYSTEM_FRAME_ERROR;
break;
}
}
//一级功能码是回复警灯状态
static int Comparison_5BFRAME_FirstLevelCode_0x66(char *getdata)
{
//二级功能位
switch (getdata[8])
{
//回复警灯状态
case 0x51:
return JZ_INSCODE_5BFRAME_CHECKSTATUS_WARNINGLIGHT_STATUS;
break;
default:
return JZ_ERROR_SYSTEM_FRAME_ERROR;
break;
}
}//一级功能码是回复警灯颜色
static int Comparison_5BFRAME_FirstLevelCode_0x67(char *getdata)
{
//二级功能位
switch (getdata[8])
{
//回复回复警灯颜色
case 0x51:
return JZ_INSCODE_5BFRAME_CHECKSTATUS_WARNINGLIGHT_COLOR;
break;
default:
return JZ_ERROR_SYSTEM_FRAME_ERROR;
break;
}
}//一级功能码是回复温度/序列号查询
static int Comparison_5BFRAME_FirstLevelCode_0x69(char *getdata)
{
//二级功能位
switch (getdata[8])
{
//回复温度查询
case 0x51:
return JZ_INSCODE_5BFRAME_CHECKSTATUS_SEARCHLIGHT_TEMPERATURE;
break;
//回复产品序列号
case 0x54:
return JZ_INSCODE_5BFRAME_CHECKSTATUS_SERIALNUMBER;
break;
default:
return JZ_ERROR_SYSTEM_FRAME_ERROR;
break;
}
}
/******************************************************************
回复帧对比
成功返回帧类型 无对比数据返回 JZ_ERROR_SYSTEM_FRAME_ERROR
******************************************************************/
int JZsdk_5BFrameComparsion(char *getdata, int len)
{
//1、判断帧头帧尾
if (
( (getdata[0]!= 0x5B) && (getdata[1] != 0x5B) && (getdata[2]!=0x77) )
|| ( (getdata[len -2]!= 0x00) && (getdata[ len -1] != 0x23) )
)
{
printf("接受到的帧,没有帧头或者帧尾,退出JZsdk_5BFrameComparsion函数\n");
return JZ_ERROR_SYSTEM_FRAME_ERROR;
}
//一级功能码
switch (getdata[7])
{
case 0x50:
return Comparison_5BFRAME_FirstLevelCode_0x50(getdata);
break;
case 0x51:
return Comparison_5BFRAME_FirstLevelCode_0x51(getdata);
break;
case 0x53:
return Comparison_5BFRAME_FirstLevelCode_0x53(getdata);
break;
case 0x58:
return Comparison_5BFRAME_FirstLevelCode_0x58(getdata);
break;
case 0x59:
return Comparison_5BFRAME_FirstLevelCode_0x58(getdata);
break;
case 0x5A:
return Comparison_5BFRAME_FirstLevelCode_0x5A(getdata);
break;
case 0x60:
return Comparison_5BFRAME_FirstLevelCode_0x60(getdata);
break;
case 0x61:
return Comparison_5BFRAME_FirstLevelCode_0x61(getdata);
break;
case 0x62:
return Comparison_5BFRAME_FirstLevelCode_0x62(getdata);
break;
case 0x63:
return Comparison_5BFRAME_FirstLevelCode_0x63(getdata);
break;
case 0x64:
return Comparison_5BFRAME_FirstLevelCode_0x64(getdata);
break;
case 0x65:
return Comparison_5BFRAME_FirstLevelCode_0x65(getdata);
break;
case 0x66:
return Comparison_5BFRAME_FirstLevelCode_0x66(getdata);
break;
case 0x67:
return Comparison_5BFRAME_FirstLevelCode_0x67(getdata);
break;
case 0x69:
return Comparison_5BFRAME_FirstLevelCode_0x69(getdata);
break;
default:
return JZ_ERROR_SYSTEM_FRAME_ERROR;
break;
}
}
\ No newline at end of file
... ...
/**
********************************************************************
* @file
*
*
*********************************************************************
*/
/* Define to prevent recursive inclusion 避免重定义 -------------------------------------*/
#ifndef JZSDK_FRAMECOMPARSION_5BFRAME_H
#define JZSDK_FRAMECOMPARSION_5BFRAME_H
/* Includes ------------------------------------------------------------------*/
#ifdef __cplusplus
extern "C" {
#endif
/* Exported constants --------------------------------------------------------*/
/* 常亮定义*/
/* Exported types ------------------------------------------------------------*/
/* Exported functions --------------------------------------------------------*/
int JZsdk_5BFrameComparsion(char *getdata, int len);
#ifdef __cplusplus
}
#endif
#endif
... ...
#include <stdio.h>
#include "../JZsdk_Code/JZsdk_Code.h"
//一级功能码是私有协议
static int Comparison_6AFRAME_FirstLevelCode_0x69(char *getdata)
{
//二级功能位
switch (getdata[8])
{
//设置当前为云台零值
case 0x51:
return JZ_INSCODE_6AFRAME_SET_GIMBAL_ORIGIN;
break;
//设置云台当前为最大最小值
case 0x52:
return JZ_INSCODE_6AFRAME_SET_GIMBAL_MAXMIN_RANGE;
break;
//设置灯光当前亮度为最大最小值
case 0x53:
return JZ_INSCODE_6AFRAME_SET_LUMEN_MAXMIN_RANGE;
break;
//设置产品序列号
case 0x54:
return JZ_INSCODE_6AFRAME_SET_SERIALNUMBER;
break;
//舵机自检
case 0x55:
return JZ_INSCODE_6AFRAME_SERVO_SELFCHECK;
break;
//开启关闭云台联动
case 0x56:
return JZ_INSCODE_6AFRAME_GIMBAL_LINKAGE_CONTROL;
break;
default:
return JZ_ERROR_SYSTEM_FRAME_ERROR;
break;
}
}
//一级功能码是私有协议
static int Comparison_6AFRAME_FirstLevelCode_0x6F(char *getdata)
{
//二级功能位
switch (getdata[8])
{
//设置当前为云台零值
case 0x50:
return JZ_INSCODE_6AFRAME_CHECKSTATUS_SECONDARY_DEVICE_NAME;
break;
//设置当前为云台零值
case 0x51:
return JZ_INSCODE_6AFRAME_CHECKSTATUS_GIMBAL_LINKAGE;
break;
//串口比特率修改
case 0x52:
return JZ_INSCODE_6AFRAME_UART_BITRATE_CHANGE;
break;
//设置特殊变量
case 0x53:
return JZ_INSCODE_6AFRAME_SPECIAL_PARAMETERS;
break;
//查询特殊变量
case 0x54:
return JZ_INSCODE_6AFRAME_CHECK_SPECIAL_PARAMETERS;
break;
default:
return JZ_ERROR_SYSTEM_FRAME_ERROR;
break;
}
}
/******************************************************************
回复帧对比
成功返回帧类型 无对比数据返回 JZ_ERROR_SYSTEM_FRAME_ERROR
******************************************************************/
int JZsdk_6AFrameComparsion(char *getdata, int len)
{
//1、判断帧头帧尾
if (
( (getdata[0]!= 0x6A) && (getdata[1] != 0x6A) && (getdata[2]!=0x77) )
|| ( (getdata[len -2]!= 0x00) && (getdata[ len -1] != 0x23) )
)
{
printf("接受到的帧,没有帧头或者帧尾,退出JZsdk_6AFrameComparsion函数\n");
return JZ_ERROR_SYSTEM_FRAME_ERROR;
}
//一级功能码
switch (getdata[7])
{
case 0x69:
return Comparison_6AFRAME_FirstLevelCode_0x69(getdata);
break;
case 0x6F:
return Comparison_6AFRAME_FirstLevelCode_0x6F(getdata);
break;
default:
return JZ_ERROR_SYSTEM_FRAME_ERROR;
break;
}
}
\ No newline at end of file
... ...
/**
********************************************************************
* @file
*
*
*********************************************************************
*/
/* Define to prevent recursive inclusion 避免重定义 -------------------------------------*/
#ifndef JZSDK_FRAMECOMPARSION_6AFRAME_H
#define JZSDK_FRAMECOMPARSION_6AFRAME_H
/* Includes ------------------------------------------------------------------*/
#ifdef __cplusplus
extern "C" {
#endif
/* Exported constants --------------------------------------------------------*/
/* 常亮定义*/
/* Exported types ------------------------------------------------------------*/
/* Exported functions --------------------------------------------------------*/
int JZsdk_6AFrameComparsion(char *getdata, int len);
#ifdef __cplusplus
}
#endif
#endif
... ...
#include <stdio.h>
#include "../JZsdk_Code/JZsdk_Code.h"
//一级功能码是私有协议
static int Comparison_6BFRAME_FirstLevelCode_0x6F(char *getdata)
{
//二级功能位
switch (getdata[8])
{
//从设备名返回
case 0x50:
return JZ_INSCODE_6BFRAME_CHECKSTATUS_SECONDARY_DEVICE_NAME;
break;
//查询云台联动返回
case 0x51:
return JZ_INSCODE_6BFRAME_CHECKSTATUS_GIMBAL_LINKAGE;
break;
//查询特殊变量
case 0x54:
return JZ_INSCODE_6BFRAME_CHECKSTATUS_SECONDARY_DEVICE_NAME;
break;
default:
return JZ_ERROR_SYSTEM_FRAME_ERROR;
break;
}
}
/******************************************************************
回复帧对比
成功返回帧类型 无对比数据返回 JZ_ERROR_SYSTEM_FRAME_ERROR
******************************************************************/
int JZsdk_6BFrameComparsion(char *getdata, int len)
{
//1、判断帧头帧尾
if (
( (getdata[0]!= 0x6B) && (getdata[1] != 0x6B) && (getdata[2]!=0x77) )
|| ( (getdata[len -2]!= 0x00) && (getdata[ len -1] != 0x23) )
)
{
printf("接受到的帧,没有帧头或者帧尾,退出JZsdk_6BFrameComparsion函数\n");
return JZ_ERROR_SYSTEM_FRAME_ERROR;
}
//一级功能码
switch (getdata[7])
{
case 0x6F:
return Comparison_6BFRAME_FirstLevelCode_0x6F(getdata);
break;
default:
return JZ_ERROR_SYSTEM_FRAME_ERROR;
break;
}
}
\ No newline at end of file
... ...
/**
********************************************************************
* @file
*
*
*********************************************************************
*/
/* Define to prevent recursive inclusion 避免重定义 -------------------------------------*/
#ifndef JZSDK_FRAMECOMPARSION_6BFRAME_H
#define JZSDK_FRAMECOMPARSION_6BFRAME_H
/* Includes ------------------------------------------------------------------*/
#ifdef __cplusplus
extern "C" {
#endif
/* Exported constants --------------------------------------------------------*/
/* 常亮定义*/
/* Exported types ------------------------------------------------------------*/
/* Exported functions --------------------------------------------------------*/
int JZsdk_6BFrameComparsion(char *getdata, int len);
#ifdef __cplusplus
}
#endif
#endif
... ...
#include <stdio.h>
#include <string.h>
#include "../JZsdk_Code/JZsdk_Code.h"
/******************************************************
用于获取帧模板
/******************************************************/
int JZsdk_GetFrameTemplate(int InsCode ,char *str, int *str_len)
{
//printf("JZsdk_GetFrameTemplate:获取0x%x帧模板\n",InsCode); //该打印可能会对 要求快速控制的地方变慢，请不要随意开启
switch (InsCode)
{
/********************************************************************************************************************************************************
*
* 5A帧
*
********************************************************************************************************************************************************/
case JZ_INSCODE_5AFRAME_ASKFORCONNECT:
{
char sendbuf[12] = {0x5A ,0x5A ,0x77 ,0x00 ,0x0C ,0x00 ,0x00 ,0x50 ,0x51 ,0x00 ,0x00 ,0x23};
memcpy(str, sendbuf, 12);
*str_len = 12;
}
break;
case JZ_INSCODE_5AFRAME_FRAME_POWER_STATUS:
{
unsigned char sendbuf[12] = {0x5A ,0x5A ,0x77 ,0x00 ,0x0C ,0x00 ,0x00 ,0x50 ,0x52 ,0x00 ,0x00 ,0x23};
memcpy(str, sendbuf, 12);
*str_len = 12;
}
break;
case JZ_INSCODE_5AFRAME_HEARTBEAT:
{
unsigned char sendbuf[12] = {0x5A ,0x5A ,0x77 ,0x00 ,0x0C ,0x00 ,0x00 ,0x50 ,0x53 ,0x00 ,0x00 ,0x23};
memcpy(str, sendbuf, 12);
*str_len = 12;
}
break;
case JZ_INSCODE_5AFRAME_TIMESTAMP:
{
unsigned char sendbuf[12] = {0x5A ,0x5A ,0x77 ,0x00 ,0x0C ,0x00 ,0x00 ,0x50 ,0x54 ,0x00 ,0x00 ,0x23};
memcpy(str, sendbuf, 12);
*str_len = 12;
}
break;
case JZ_INSCODE_5AFRAME_AUDIO_STOP:
{
char sendbuf[12] = {0x5A ,0x5A ,0x77 ,0x00 ,0x0C ,0x00 ,0x00 ,0x52 ,0x06 ,0x00 ,0x00 ,0x23};
memcpy(str, sendbuf, 12);
*str_len = 12;
}
break;
case JZ_INSCODE_5AFRAME_AUDIO_LASTSONG:
{
char sendbuf[12] = {0x5A ,0x5A ,0x77 ,0x00 ,0x0C ,0x00 ,0x00 ,0x52 ,0x07 ,0x00 ,0x00 ,0x23};
memcpy(str, sendbuf, 12);
*str_len = 12;
}
break;
case JZ_INSCODE_5AFRAME_AUDIO_NEXTSONG:
{
char sendbuf[12] = {0x5A ,0x5A ,0x77 ,0x00 ,0x0C ,0x00 ,0x00 ,0x52 ,0x08 ,0x00 ,0x00 ,0x23};
memcpy(str, sendbuf, 12);
*str_len = 12;
}
break;
case JZ_INSCODE_5AFRAME_VOLUME:
{
char sendbuf[12] = {0x5A ,0x5A ,0x77 ,0x00 ,0x0C ,0x00 ,0x00 ,0x52 ,0x10 ,0x00 ,0x00 ,0x23};
memcpy(str, sendbuf, 12);
*str_len = 12;
}
break;
case JZ_INSCODE_5AFRAME_PLAY_LOOP:
{
char sendbuf[12] = {0x5A ,0x5A ,0x77 ,0x00 ,0x0C ,0x00 ,0x00 ,0x55 ,0x00 ,0x00 ,0x00 ,0x23};
memcpy(str, sendbuf, 12);
*str_len = 12;
}
break;
case JZ_INSCODE_5AFRAME_TTS_SET_TONE:
{
char sendbuf[12] = {0x5A ,0x5A ,0x77 ,0x00 ,0x0C ,0x00 ,0x00 ,0x57 ,0x01 ,0x00 ,0x00 ,0x23};
memcpy(str, sendbuf, 12);
*str_len = 12;
}
break;
case JZ_INSCODE_5AFRAME_TTS_TRANS_START:
{
char sendbuf[12] = {0x5A ,0x5A ,0x77 ,0x00 ,0x0C ,0x00 ,0x00 ,0x57 ,0x03 ,0x00 ,0x00 ,0x23};
memcpy(str, sendbuf, 12);
*str_len = 12;
}
break;
case JZ_INSCODE_5AFRAME_TTS_TRANS_STOP:
{
char sendbuf[12] = {0x5A ,0x5A ,0x77 ,0x00 ,0x0C ,0x00 ,0x00 ,0x57 ,0x04 ,0x00 ,0x00 ,0x23};
memcpy(str, sendbuf, 12);
*str_len = 12;
}
break;
case JZ_INSCODE_5AFRAME_SEARCHLIGHT_SET_FREQUENCY:
{
char sendbuf[13] = {0x5A ,0x5A ,0x77 ,0x00 ,0x0D ,0x00 ,0x00 ,0x61 ,0x51 ,0x00 ,0x00 ,0x00 ,0x23};
memcpy(str, sendbuf, 13);
*str_len = 13;
}
break;
case JZ_INSCODE_5AFRAME_SEARCHLIGHT_CONTROL:
{
char sendbuf[13] = {0x5A ,0x5A ,0x77 ,0x00 ,0x0D ,0x00 ,0x00 ,0x62 ,0x51 ,0x00 ,0x00 ,0x00 ,0x23};
memcpy(str, sendbuf, 13);
*str_len = 13;
}
break;
case JZ_INSCODE_5AFRAME_SEARCHLIGHT_SET_LUMEN:
{
char sendbuf[13] = {0x5A ,0x5A ,0x77 ,0x00 ,0x0D ,0x00 ,0x00 ,0x63 ,0x51 ,0x00 ,0x00 ,0x00 ,0x23};
memcpy(str, sendbuf, 13);
*str_len = 13;
}
break;
case JZ_INSCODE_5AFRAME_GIMBAL_PITCH_CONTROL:
{
char sendbuf[14] = {0x5A ,0x5A ,0x77 ,0x00 ,0x0E ,0x00 ,0x00 ,0x64 ,0x51 ,0x00 ,0x00 ,0x00 ,0x00 ,0x23};
memcpy(str, sendbuf, 14);
*str_len = 14;
}
break;
case JZ_INSCODE_5AFRAME_GIMBAL_PITCH_FINETUNING_CONTROL:
{
char sendbuf[14] = {0x5A ,0x5A ,0x77 ,0x00 ,0x0E ,0x00 ,0x00 ,0x64 ,0x52 ,0x00 ,0x00 ,0x00 ,0x00 ,0x23};
memcpy(str, sendbuf, 14);
*str_len = 14;
}
break;
case JZ_INSCODE_5AFRAME_WARNINGLIGHT_CONTROL:
{
char sendbuf[13] = {0x5A ,0x5A ,0x77 ,0x00 ,0x0D ,0x00 ,0x00 ,0x66 ,0x51 ,0x00 ,0x00 ,0x00 ,0x23};
memcpy(str, sendbuf, 13);
*str_len = 13;
}
break;
case JZ_INSCODE_5AFRAME_WARNINGLIGHT_COLOUR:
{
char sendbuf[13] = {0x5A ,0x5A ,0x77 ,0x00 ,0x0D ,0x00 ,0x00 ,0x67 ,0x51 ,0x00 ,0x00 ,0x00 ,0x23};
memcpy(str, sendbuf, 13);
*str_len = 13;
}
break;
case JZ_INSCODE_5AFRAME_SEARCHLIGHT_MESSAGE_SUBSCRIPTION_CONTROL:
{
char sendbuf[13] = {0x5A ,0x5A ,0x77 ,0x00 ,0x0D ,0x00 ,0x00 ,0x68 ,0x51 ,0x00 ,0x00 ,0x00 ,0x23};
memcpy(str, sendbuf, 13);
*str_len = 13;
}
break;
case JZ_INSCODE_5AFRAME_CHECKSTATUS_SEARCHLIGHT_LIGHTATTRIBUTE:
{
char sendbuf[13] = {0x5A ,0x5A ,0x77 ,0x00 ,0x0D ,0x00 ,0x00 ,0x6F ,0x51 ,0x00 ,0x00 ,0x00 ,0x23};
memcpy(str, sendbuf, 13);
*str_len = 13;
}
break;
case JZ_INSCODE_5AFRAME_CHECKSTATUS_SEARCHLIGHT_TEMPERATURE:
{
char sendbuf[13] = {0x5A ,0x5A ,0x77 ,0x00 ,0x0D ,0x00 ,0x00 ,0x6F ,0x52 ,0x00 ,0x00 ,0x00 ,0x23};
memcpy(str, sendbuf, 13);
*str_len = 13;
}
break;
case JZ_INSCODE_5AFRAME_CHECKSTATUS_GIMBAL:
{
char sendbuf[13] = {0x5A ,0x5A ,0x77 ,0x00 ,0x0D ,0x00 ,0x00 ,0x6F ,0x54 ,0x00 ,0x00 ,0x00 ,0x23};
memcpy(str, sendbuf, 13);
*str_len = 13;
}
break;
case JZ_INSCODE_5AFRAME_CHECKSTATUS_WARNINGLIGHT_STATUS:
{
char sendbuf[13] = {0x5A ,0x5A ,0x77 ,0x00 ,0x0D ,0x00 ,0x00 ,0x6F ,0x55 ,0x00 ,0x00 ,0x00 ,0x23};
memcpy(str, sendbuf, 13);
*str_len = 13;
}
break;
case JZ_INSCODE_5AFRAME_CHECKSTATUS_WARNINGLIGHT_COLOR:
{
char sendbuf[13] = {0x5A ,0x5A ,0x77 ,0x00 ,0x0D ,0x00 ,0x00 ,0x6F ,0x56 ,0x00 ,0x00 ,0x00 ,0x23};
memcpy(str, sendbuf, 13);
*str_len = 13;
}
break;
case JZ_INSCODE_5AFRAME_CHECKSTATUS_SERIALNUMBER:
{
char sendbuf[13] = {0x5A ,0x5A ,0x77 ,0x00 ,0x0D ,0x00 ,0x00 ,0x6F ,0x57 ,0x00 ,0x00 ,0x00 ,0x23};
memcpy(str, sendbuf, 13);
*str_len = 13;
}
break;
case JZ_INSCODE_5AFRAME_CHECKSTATUS_GIMBAL_FINETUNING:
{
char sendbuf[13] = {0x5A ,0x5A ,0x77 ,0x00 ,0x0D ,0x00 ,0x00 ,0x6F ,0x58 ,0x00 ,0x00 ,0x00 ,0x23};
memcpy(str, sendbuf, 13);
*str_len = 13;
}
break;
/********************************************************************************************************************************************************
*
* 5B帧
*
********************************************************************************************************************************************************/
case JZ_INSCODE_5BFRAME_INITIATECONNECT:
{
char sendbuf[12] = {0x5B ,0x5B ,0x77 ,0x00 ,0x0c ,0x00 ,0x00 ,0x50 ,0x51 ,0x00 ,0x00 ,0x23};
memcpy(str, sendbuf, 12);
*str_len = 12;
}
break;
case JZ_INSCODE_5BFRAME_HEARTBEAT:
{
char sendbuf[12] = {0x5B ,0x5B ,0x77 ,0x00 ,0x0c ,0x00 ,0x00 ,0x50 ,0x53 ,0x00 ,0x00 ,0x23};
memcpy(str, sendbuf, 12);
*str_len = 12;
}
break;
case JZ_INSCODE_5BFRAME_ALL_VERSION:
{
unsigned char sendbuf[16] = {0x5B ,0x5B ,0x77 ,0x00 ,0x10 ,0x00 ,0x00 ,0x50 ,0x55, 0x00, 0x00, 0x00, 0x00 ,0x00 ,0x00 ,0x23};
memcpy(str, sendbuf, 16);
*str_len = 16;
}
break;
case JZ_INSCODE_5BFRAME_ALL_SERIAL_NUMBER:
{
unsigned char sendbuf[13] = {0x5B ,0x5B ,0x77 ,0x00 ,0x10 ,0x00 ,0x00 ,0x50 ,0x56, 0x00, 0x00 , 0x00 ,0x23};
memcpy(str, sendbuf, 13);
*str_len = 13;
}
break;
case JZ_INSCODE_5BFRAME_DEVICE_MESSAGE:
{
unsigned char sendbuf[12] = {0x5B ,0x5B ,0x77 ,0x00 ,0x0c ,0x00 ,0x00 ,0x50 ,0x58, 0x00 , 0x00 ,0x23};
memcpy(str, sendbuf, 12);
*str_len = 12;
}
break;
case JZ_INSCODE_5BFRAME_SUCESS:
{
char sendbuf[12] = {0x5B, 0x5B, 0x77, 0x00, 0x0c, 0x00, 0x00, 0x51, 0x01, 0x00, 0x00, 0x23};
memcpy(str, sendbuf, 12);
*str_len = 12;
}
break;
case JZ_INSCODE_5BFRAME_DEFEAT:
{
char sendbuf[12] = {0x5B, 0x5B, 0x77, 0x00, 0x0c, 0x00, 0x00, 0x51, 0xff, 0x00, 0x00, 0x23};
memcpy(str, sendbuf, 12);
*str_len = 12;
}
break;
case JZ_INSCODE_5BFRAME_AUDIO_PLAYSTATUS_END:
{
char sendbuf[12] = { 0x5b, 0x5b, 0x77, 0x00, 0x0c, 0x00, 0x00, 0x53, 0xff, 0x00, 0x00, 0x23};
memcpy(str, sendbuf, 12);
*str_len = 12;
}
break;
case JZ_INSCODE_5BFRAME_AUDIO_PLAYSTATUS:
{
char sendbuf[12] = { 0x5b, 0x5b, 0x77, 0x00, 0x0c, 0x00, 0x00, 0x53, 0x02, 0x00, 0x00, 0x23};
memcpy(str, sendbuf, 12);
*str_len = 12;
}
break;
case JZ_INSCODE_5BFRAME_AUDIO_PLAYFILENAME:
{
char sendbuf[12] = {0x5B, 0x5B, 0x77, 0x00, 0x0c, 0x00, 0x00, 0x53, 0x04, 0x00, 0x00, 0x23};
memcpy(str, sendbuf, 12);
*str_len = 12;
}
break;
case JZ_INSCODE_5BFRAME_VOLUME:
{
char sendbuf[12] = { 0x5b, 0x5b, 0x77, 0x00, 0x0c, 0x00, 0x00, 0x53, 0x01, 0x00, 0x00, 0x23};
memcpy(str, sendbuf, 12);
*str_len = 12;
}
break;
case JZ_INSCODE_5BFRAME_SORTWAREVERSION:
{
char sendbuf[15] = { 0x5b, 0x5b, 0x77, 0x00, 0x0f, 0x00, 0x00, 0x53, 0xf1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x23};
memcpy(str, sendbuf, 15);
*str_len = 15;
}
break;
case JZ_INSCODE_5BFRAME_AUDIO_PLAYLOOPSTATUS:
{
char sendbuf[12] = { 0x5b, 0x5b, 0x77, 0x00, 0x0c, 0x00, 0x00, 0x53, 0x05, 0x00, 0x00, 0x23};
memcpy(str, sendbuf, 12);
*str_len = 12;
}
break;
case JZ_INSCODE_5BFRAME_TTS_TONE:
{
char sendbuf[12] = { 0x5b, 0x5b, 0x77, 0x00, 0x0c, 0x00, 0x00, 0x53, 0x06, 0x00, 0x00, 0x23};
memcpy(str, sendbuf, 12);
*str_len = 12;
}
break;
case JZ_INSCODE_5BFRAME_TTS_SPEED:
{
char sendbuf[12] = { 0x5b, 0x5b, 0x77, 0x00, 0x0c, 0x00, 0x00, 0x53, 0x07, 0x00, 0x00, 0x23};
memcpy(str, sendbuf, 12);
*str_len = 12;
}
break;
case JZ_INSCODE_5BFRAME_MUSICLIST_START:
{
char sendbuf[12] = { 0x5b, 0x5b, 0x77, 0x00, 0x0c, 0x00, 0x00, 0x58, 0x00, 0x00, 0x00, 0x23};
memcpy(str, sendbuf, 12);
*str_len = 12;
}
break;
case JZ_INSCODE_5BFRAME_MUSICLIST_TRANS:
{
char sendbuf[12] = {0x5B, 0x5B, 0x77, 0x00, 0x0c, 0x00, 0x00, 0x58, 0x02, 0x00, 0x00, 0x23};
memcpy(str, sendbuf, 12);
*str_len = 12;
}
break;
case JZ_INSCODE_5BFRAME_MUSICLIST_STOP:
{
char sendbuf[12] = { 0x5b, 0x5b, 0x77, 0x00, 0x0c, 0x00, 0x00, 0x58, 0xff, 0x00, 0x00, 0x23};
memcpy(str, sendbuf, 12);
*str_len = 12;
}
break;
case JZ_INSCODE_5BFRAME_OPUS_DECODE_STATUS:
{
char sendbuf[12] = { 0x5b, 0x5b, 0x77, 0x00, 0x0c, 0x00, 0x00, 0x59, 0xf2, 0x00, 0x00, 0x23};
memcpy(str, sendbuf, 12);
*str_len = 12;
}
break;
case JZ_INSCODE_5BFRAME_CHECKSTATUS_OUTPUTPOWER:
{
char sendbuf[12] = { 0x5b, 0x5b, 0x77, 0x00, 0x0C, 0x00, 0x00, 0x5A, 0x02, 0x00, 0x00, 0x23};
memcpy(str, sendbuf, 12);
*str_len = 12;
}
break;
case JZ_INSCODE_5BFRAME_CHECKSTATUS_SEARCHLIGHT_FREQUENCY:
{
char sendbuf[13] = { 0x5b, 0x5b, 0x77, 0x00, 0x0D, 0x00, 0x00, 0x61, 0x51, 0x00, 0x00, 0x00, 0x23};
memcpy(str, sendbuf, 13);
*str_len = 13;
}
break;
case JZ_INSCODE_5BFRAME_CHECKSTATUS_SEARCHLIGHT_MODE:
{
char sendbuf[13] = { 0x5b, 0x5b, 0x77, 0x00, 0x0D, 0x00, 0x00, 0x62, 0x51, 0x00, 0x00, 0x00, 0x23};
memcpy(str, sendbuf, 13);
*str_len = 13;
}
break;
case JZ_INSCODE_5BFRAME_CHECKSTATUS_SEARCHLIGHT_LUMEN:
{
char sendbuf[13] = { 0x5b, 0x5b, 0x77, 0x00, 0x0D, 0x00, 0x00, 0x63, 0x51, 0x00, 0x00, 0x00, 0x23};
memcpy(str, sendbuf, 13);
*str_len = 13;
}
break;
case JZ_INSCODE_5BFRAME_GIMBAL_PITCH:
{
char sendbuf[14] = { 0x5b, 0x5b, 0x77, 0x00, 0x0e, 0x00, 0x00, 0x64, 0x51, 0x00, 0x00, 0x00, 0x00, 0x23};
memcpy(str, sendbuf, 14);
*str_len = 14;
}
break;
case JZ_INSCODE_5BFRAME_GIMBAL_PITCH_FINETUNING:
{
char sendbuf[14] = { 0x5b, 0x5b, 0x77, 0x00, 0x0e, 0x00, 0x00, 0x64, 0x52, 0x00, 0x00, 0x00, 0x00, 0x23};
memcpy(str, sendbuf, 14);
*str_len = 14;
}
break;
case JZ_INSCODE_5BFRAME_GIMBAL_YAW:
{
char sendbuf[14] = { 0x5b, 0x5b, 0x77, 0x00, 0x0e, 0x00, 0x00, 0x65, 0x51, 0x00, 0x00, 0x00, 0x00, 0x23};
memcpy(str, sendbuf, 14);
*str_len = 14;
}
break;
case JZ_INSCODE_5BFRAME_CHECKSTATUS_WARNINGLIGHT_STATUS:
{
char sendbuf[13] = { 0x5b, 0x5b, 0x77, 0x00, 0x0D, 0x00, 0x00, 0x66, 0x51, 0x00, 0x00, 0x00, 0x23};
memcpy(str, sendbuf, 13);
*str_len = 13;
}
break;
case JZ_INSCODE_5BFRAME_CHECKSTATUS_WARNINGLIGHT_COLOR:
{
char sendbuf[13] = { 0x5b, 0x5b, 0x77, 0x00, 0x0D, 0x00, 0x00, 0x67, 0x51, 0x00, 0x00, 0x00, 0x23};
memcpy(str, sendbuf, 13);
*str_len = 13;
}
break;
case JZ_INSCODE_5BFRAME_CHECKSTATUS_SEARCHLIGHT_TEMPERATURE:
{
char sendbuf[13] = { 0x5b, 0x5b, 0x77, 0x00, 0x0D, 0x00, 0x00, 0x69, 0x51, 0x00, 0x00, 0x00, 0x23};
memcpy(str, sendbuf, 13);
*str_len = 13;
}
break;
case JZ_INSCODE_5BFRAME_CHECKSTATUS_SERIALNUMBER:
{
char sendbuf[13] = { 0x5b, 0x5b, 0x77, 0x00, 0x0D, 0x00, 0x00, 0x6F, 0x57, 0x00, 0x00, 0x00, 0x23};
memcpy(str, sendbuf, 13);
*str_len = 13;
}
break;
/********************************************************************************************************************************************************
*
* 6A帧
*
********************************************************************************************************************************************************/
case JZ_INSCODE_6AFRAME_SET_GIMBAL_MAXMIN_RANGE:
{
char sendbuf[13] = {0x6A ,0x6A ,0x77 ,0x00 ,0x0D ,0x00 ,0x00 ,0x69 ,0x52 ,0x00 ,0x00 ,0x00 ,0x23};
memcpy(str, sendbuf, 13);
*str_len = 13;
}
break;
case JZ_INSCODE_6AFRAME_GIMBAL_LINKAGE_CONTROL:
{
char sendbuf[13] = {0x6A ,0x6A ,0x77 ,0x00 ,0x0D ,0x00 ,0x00 ,0x69 ,0x56 ,0x00 ,0x00 ,0x00 ,0x23};
memcpy(str, sendbuf, 13);
*str_len = 13;
}
break;
case JZ_INSCODE_6AFRAME_CHECKSTATUS_SECONDARY_DEVICE_NAME:
{
char sendbuf[13] = {0x6A ,0x6A ,0x77 ,0x00 ,0x0D ,0x00 ,0x00 ,0x6F ,0x50 ,0x00 ,0x00 ,0x00 ,0x23};
memcpy(str, sendbuf, 13);
*str_len = 13;
}
break;
case JZ_INSCODE_6AFRAME_CHECKSTATUS_GIMBAL_LINKAGE:
{
char sendbuf[13] = {0x6A ,0x6A ,0x77 ,0x00 ,0x0D ,0x00 ,0x00 ,0x6F ,0x51 ,0x00 ,0x00 ,0x00 ,0x23};
memcpy(str, sendbuf, 13);
*str_len = 13;
}
break;
/********************************************************************************************************************************************************
*
* 6B帧
*
********************************************************************************************************************************************************/
case JZ_INSCODE_6BFRAME_CHECKSTATUS_SECONDARY_DEVICE_NAME:
{
char sendbuf[13] = {0x6B ,0x6B ,0x77 ,0x00 ,0x0D ,0x00 ,0x00 ,0x6F ,0x50 ,0x00 ,0x00 ,0x00 ,0x23};
memcpy(str, sendbuf, 13);
*str_len = 13;
}
break;
case JZ_INSCODE_6BFRAME_CHECKSTATUS_GIMBAL_LINKAGE:
{
char sendbuf[13] = {0x6B ,0x6B ,0x77 ,0x00 ,0x0D ,0x00 ,0x00 ,0x6F ,0x51 ,0x00 ,0x00 ,0x00 ,0x23};
memcpy(str, sendbuf, 13);
*str_len = 13;
}
break;
case JZ_INSCODE_6BFRAME_CHECK_SPECIAL_PARAMETERS:
{
char sendbuf[13] = {0x6B ,0x6B ,0x77 ,0x00 ,0x0D ,0x00 ,0x00 ,0x6F ,0x54 ,0x00 ,0x00 ,0x00 ,0x23};
memcpy(str, sendbuf, 13);
*str_len = 13;
}
break;
default:
printf("JZsdk_GetFrameTemplate:没有对应的帧模板\n");
break;
}
}
\ No newline at end of file
... ...
/**
********************************************************************
* @file
*
*
*********************************************************************
*/
/* Define to prevent recursive inclusion 避免重定义 -------------------------------------*/
#ifndef JZSDK_GET_FRAME_TEMPLATE_H
#define JZSDK_GET_FRAME_TEMPLATE_H
/* Includes ------------------------------------------------------------------*/
#ifdef __cplusplus
extern "C" {
#endif
/* Exported constants --------------------------------------------------------*/
/* 常亮定义*/
/* Exported types ------------------------------------------------------------*/
/* Exported functions --------------------------------------------------------*/
int JZsdk_GetFrameTemplate(int InsCode ,char *str, int *str_len);
#ifdef __cplusplus
}
#endif
#endif
... ...
/* 头文件 ------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <stdio.h>
#include "JZsdk_Logger.h"
#include <time.h>
#include "JZsdkLib.h"
#include <pthread.h>
#include <sys/time.h>
#include <sys/resource.h>
#include <unistd.h>
#include <sys/types.h>
#define LOG_GRADE JZSDK_LOGGER_CONSOLE_LOG_LEVEL_INFO
// 定义全局互斥锁
static pthread_mutex_t LogWriteMutex = PTHREAD_MUTEX_INITIALIZER;
/* 全局变量 ------------------------------------------------------------------*/
static struct timeval g_start_time;
static FILE *logFile = NULL;
static char LogFileName[JZSDK_FILENAME_SIZE];
static int Logger_init_flag = JZ_FLAGCODE_OFF;
/* 函数声明 ------------------------------------------------------------------*/
long long get_total_ram() {
FILE *file;
char line[128];
long long total_ram = 0;
file = fopen("/proc/meminfo", "r");
if (!file) {
perror("Error opening /proc/meminfo");
return 0;
}
while (fgets(line, sizeof(line), file)) {
if (strncmp(line, "MemTotal:", 9) == 0) {
sscanf(line, "MemTotal: %lld kB", &total_ram);
break;
}
}
fclose(file);
return total_ram;
}
long long get_current_rss(pid_t pid) {
FILE *file;
char line[128];
long long vmrss = 0;
char path[64];
snprintf(path, sizeof(path), "/proc/%d/status", pid);
file = fopen(path, "r");
if (!file) {
perror("Error opening /proc/[pid]/status");
return 0;
}
while (fgets(line, sizeof(line), file)) {
if (strncmp(line, "VmRSS:", 6) == 0) {
sscanf(line, "VmRSS: %lld kB", &vmrss);
break;
}
}
fclose(file);
return vmrss;
}
static void *MonitorTask(void *arg)
{
//获取程序的pid号
pid_t pid = getpid(); // 获取当前进程的 PID
long long total_ram; //最大ram内存
long long current_rss; //RSS内存
double memory_percentage; //内存百分比
// 获取系统总 RAM
total_ram = get_total_ram();
while (1)
{
printf("当前进程pid号%d\n",pid);
// 获取当前进程的内存使用量
current_rss = get_current_rss(pid);
// 计算内存百分比
if (total_ram > 0)
{
memory_percentage = (double)current_rss / total_ram * 100;
} else {
memory_percentage = 0;
}
// 打印结果
printf("Program current memory usage: %lld KB\n", current_rss);
JZSDK_LOG_INFO("Monitor:(%.2f%% of total RAM)", memory_percentage);
delayS(10);
}
}
static int Log_Monitor()
{
pthread_t work_mode_task;
pthread_attr_t task_attribute; //线程属性
pthread_attr_init(&task_attribute); //初始化线程属性
pthread_attr_setdetachstate(&task_attribute, PTHREAD_CREATE_DETACHED); //设置线程属性
int timer = pthread_create(&work_mode_task,&task_attribute,MonitorTask,NULL); //线程
if(timer != 0)
{
printf("创建计时线程失败！\n");
}
}
T_JZsdkReturnCode createJZLOGFolder()
{
const char *path = "/root/sdcard/JZLOG";
// 使用系统命令检测路径是否存在
if(JZsdk_check_directory_exists_posix(path) == JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
{
return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}
else
{
JZsdk_Osal_Mkdir(path);
return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}
}
int ReadLogNumFromFile()
{
const char *path = "/root/sdcard/JZLOG/thelast";
int logNum = 0;
FILE *file = fopen(path, "r");
if (file == NULL)
{
// 如果文件不存在，则创建并设置LogNum为0
file = fopen(path, "w");
fprintf(file, "%d", logNum);
}
else
{
// 从文件中读取LogNum，并自增1
fscanf(file, "%d", &logNum);
logNum++;
fclose(file);
// 将新的LogNum写回文件中
file = fopen(path, "w");
fprintf(file, "%d", logNum);
}
fclose(file);
return logNum;
}
T_JZsdkReturnCode JZsdk_LoggerInit()
{
//1、记录启动时间
gettimeofday(&g_start_time, 0);
//2、检查是否存在log文件,不在则创建
createJZLOGFolder();
//3、获取本地log个数
int LogNum = ReadLogNumFromFile();
//4、获取本地时间，拼接出log文件名
time_t current_time;
struct tm *info;
char timeString[80];
time(&current_time);
info = localtime(&current_time);
strftime(timeString, sizeof(timeString), "%Y%m%d_%H-%M-%S", info);
snprintf(LogFileName, sizeof(LogFileName), "/root/sdcard/JZLOG/%d_%s", LogNum, timeString);
printf("LogFileName:%s\n",LogFileName);
// 在主函数或初始化阶段初始化互斥锁
pthread_mutex_init(&LogWriteMutex, NULL);
//5、打开记录文件
logFile = fopen(LogFileName, "w");
if (logFile == NULL) {
// 文件打开失败，输出错误消息
printf("Failed to open file: %s", LogFileName);
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}
//6、写入开始时间
char logMessage[256];
snprintf(logMessage,256,"LOG_FILE:%s\n",LogFileName);
fprintf(logFile, "%s", logMessage);
//dfclose(logFile);
//打开初始化完成的flag
Logger_init_flag = JZ_FLAGCODE_ON;
//设立监控
Log_Monitor();
JZSDK_LOG_INFO("log初始化完成");
}
T_JZsdkReturnCode JZsdk_LoggerDeInit()
{
if (logFile != NULL)
{
fclose(logFile);
}
}
T_JZsdkReturnCode writeToLogFile(const char *data)
{
// 加锁
pthread_mutex_lock(&LogWriteMutex);
//logFile = fopen(LogFileName, "a"); // 使用"a"模式打开文件，以在末尾追加数据
// if (logFile == NULL) {
// // 文件打开失败，输出错误消息
// printf("Failed to open file: %s", LogFileName);
// pthread_mutex_unlock(&LogWriteMutex);
// return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
// }
if (logFile == NULL)
{
printf("Failed to open file: %s", LogFileName);
pthread_mutex_unlock(&LogWriteMutex);
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}
fprintf(logFile, "%s", data); // 写入新的数据
//fclose(logFile);
// 解锁
pthread_mutex_unlock(&LogWriteMutex);
}
T_JZsdkReturnCode HexToLogFile(const char *data)
{
// 加锁
pthread_mutex_lock(&LogWriteMutex);
// logFile = fopen(LogFileName, "a"); // 使用"a"模式打开文件，以在末尾追加数据
// if (logFile == NULL) {
// // 文件打开失败，输出错误消息
// printf("Failed to open file: %s", LogFileName);
// pthread_mutex_unlock(&LogWriteMutex);
// return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
// }
if (logFile == NULL)
{
printf("Failed to open file: %s", LogFileName);
pthread_mutex_unlock(&LogWriteMutex);
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}
fprintf(logFile, "%x ", data[0]); // 写入新的数据
//fclose(logFile);
// 解锁
pthread_mutex_unlock(&LogWriteMutex);
}
void JZsdk_UserLogOutput(E_JZsdkConsoleLogLevel level, const char *fmt, ...)
{
// 将日志级别转换为相应的字符串
const char *JZSDK_LOGGER_CONSOLE_LOG_LEVEL = "";
switch (level) {
case JZSDK_LOGGER_CONSOLE_LOG_LEVEL_DEBUG:
JZSDK_LOGGER_CONSOLE_LOG_LEVEL = "DEBUG";
break;
case JZSDK_LOGGER_CONSOLE_LOG_LEVEL_INFO:
JZSDK_LOGGER_CONSOLE_LOG_LEVEL = "INFO";
break;
case JZSDK_LOGGER_CONSOLE_LOG_LEVEL_WARN:
JZSDK_LOGGER_CONSOLE_LOG_LEVEL = "WARNING";
break;
case JZSDK_LOGGER_CONSOLE_LOG_LEVEL_ERROR:
JZSDK_LOGGER_CONSOLE_LOG_LEVEL = "ERROR";
break;
default:
break;
}
// 使用可变参数处理传入的格式化字符串和可变参数
va_list args;
va_start(args, fmt);
//格式化日志消息
char logMessage[512];
memset(logMessage, 0, sizeof(logMessage));
vsnprintf(logMessage, sizeof(logMessage), fmt, args);
va_end(args);
struct timeval current_time;
gettimeofday(&current_time, 0);
long seconds = current_time.tv_sec - g_start_time.tv_sec;
long microseconds = current_time.tv_usec - g_start_time.tv_usec;
double elapsed = seconds + microseconds*1e-6;
// 执行具体的日志输出操作
char finalLogMessage[612];
memset(finalLogMessage, 0, sizeof(finalLogMessage));
snprintf(finalLogMessage, 612, "[%s][%.4f]%s\n", JZSDK_LOGGER_CONSOLE_LOG_LEVEL, elapsed, logMessage);
printf("%s",finalLogMessage);
//写入日志
if (Logger_init_flag == JZ_FLAGCODE_ON && level <= LOG_GRADE)
{
writeToLogFile(finalLogMessage);
}
}
void JZsdk_User_OutputHex(E_JZsdkConsoleLogLevel level, const char *fmt, ...)
{
// 将日志级别转换为相应的字符串
const char *JZSDK_LOGGER_CONSOLE_LOG_LEVEL = "";
switch (level) {
case JZSDK_LOGGER_CONSOLE_LOG_LEVEL_DEBUG:
JZSDK_LOGGER_CONSOLE_LOG_LEVEL = "DEBUG";
break;
case JZSDK_LOGGER_CONSOLE_LOG_LEVEL_INFO:
JZSDK_LOGGER_CONSOLE_LOG_LEVEL = "INFO";
break;
case JZSDK_LOGGER_CONSOLE_LOG_LEVEL_WARN:
JZSDK_LOGGER_CONSOLE_LOG_LEVEL = "WARNING";
break;
case JZSDK_LOGGER_CONSOLE_LOG_LEVEL_ERROR:
JZSDK_LOGGER_CONSOLE_LOG_LEVEL = "ERROR";
break;
default:
break;
}
// 使用可变参数处理传入的格式化字符串和可变参数
va_list args;
va_start(args, fmt);
//格式化日志消息
char logMessage[10];
memset(logMessage, 0, sizeof(logMessage));
vsnprintf(logMessage, sizeof(logMessage), fmt, args);
va_end(args);
// 执行具体的日志输出操作
char finalLogMessage[512];
memset(finalLogMessage, 0, sizeof(finalLogMessage));
snprintf(finalLogMessage, 612, "%s", logMessage);
printf("%x ",finalLogMessage[0]);
//写入日志
HexToLogFile(finalLogMessage);
}
\ No newline at end of file
... ...
/**
********************************************************************
* @file JZsdk_Logger.h
* 用于给h150s logger显示文件
*
*********************************************************************
*/
/* Define to prevent recursive inclusion 避免重定义 -------------------------------------*/
#ifndef JZSDK_LOGGER_H
#define JZSDK_LOGGER_H
/* Includes ------------------------------------------------------------------*/
#include "JZsdk_Base/JZsdk_Code/JZsdk_Code.h"
#ifdef __cplusplus
extern "C" {
#endif
/* Exported constants --------------------------------------------------------*/
/* 常亮定义*/
typedef enum {
JZSDK_LOGGER_CONSOLE_LOG_LEVEL_ERROR = 0, /*!< Logger console error level. The method and level of the console are
associated with each other. If the level of the registered console
method is lower than this level, the level interface will not be
printed successfully. */
JZSDK_LOGGER_CONSOLE_LOG_LEVEL_WARN = 1, /*!< Logger console warning level.The method and level of the console are
associated with each other. If the level of the registered console
method is lower than this level, the level interface will not be
printed successfully. */
JZSDK_LOGGER_CONSOLE_LOG_LEVEL_INFO = 2, /*!< Logger console info level. The method and level of the console are
associated with each other. If the level of the registered console
method is lower than this level, the level interface will not be
printed successfully. */
JZSDK_LOGGER_CONSOLE_LOG_LEVEL_DEBUG = 3, /*!< Logger console debug level. The method and level of the console are
associated with each other. If the level of the registered console
method is lower than this level, the level interface will not be
printed successfully. */
} E_JZsdkConsoleLogLevel;
/* Exported types ------------------------------------------------------------*/
/* Exported functions --------------------------------------------------------*/
void JZsdk_UserLogOutput(E_JZsdkConsoleLogLevel level, const char *fmt, ...);
T_JZsdkReturnCode JZsdk_LoggerInit();
void JZsdk_User_OutputHex(E_JZsdkConsoleLogLevel level, const char *fmt, ...);
/* Exported constants --------------------------------------------------------*/
#define JZSDK_LOG_DEBUG(fmt, ...) \
JZsdk_UserLogOutput(JZSDK_LOGGER_CONSOLE_LOG_LEVEL_DEBUG, "[%s:%d) " fmt, __FUNCTION__, __LINE__ , ##__VA_ARGS__)
#define JZSDK_LOG_INFO(fmt, ...) \
JZsdk_UserLogOutput(JZSDK_LOGGER_CONSOLE_LOG_LEVEL_INFO, "[%s:%d) " fmt, __FUNCTION__, __LINE__ , ##__VA_ARGS__)
#define JZSDK_LOG_WARN(fmt, ...) \
JZsdk_UserLogOutput(JZSDK_LOGGER_CONSOLE_LOG_LEVEL_WARN, "[%s:%d) " fmt, __FUNCTION__, __LINE__ , ##__VA_ARGS__)
#define JZSDK_LOG_ERROR(fmt, ...) \
JZsdk_UserLogOutput(JZSDK_LOGGER_CONSOLE_LOG_LEVEL_ERROR, "[%s:%d) " fmt, __FUNCTION__, __LINE__ , ##__VA_ARGS__)
#define JZSDK_LOG_OUTPUTHEX(fmt, ...) \
JZsdk_User_OutputHex(JZSDK_LOGGER_CONSOLE_LOG_LEVEL_INFO, "" fmt , ##__VA_ARGS__)
#ifdef __cplusplus
}
#endif
#endif
/************************ (C) COPYRIGHT JZSDK Innovations *******END OF FILE******/
... ...
/**
********************************************************************
* @file JZsdk_FS_Standards.h
* 用于规范文件名及长度
*
*********************************************************************
*/
/* Define to prevent recursive inclusion 避免重定义 -------------------------------------*/
#ifndef JZSDK_FS_STANDARDS_H
#define JZSDK_FS_STANDARDS_H
#define JZSDK_FILENAME_SIZE (128) //文件名最大长度128
#define JZSDK_CMD_SIZE (256) //cmd指令最大长度
#endif
\ No newline at end of file
... ...
#include <stdio.h>
#include "JZsdk_FileSystm.h"
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include "JZsdkLib.h"
#include <dirent.h>
#include <errno.h>
/*
* 用于运行指令
*
*/
T_JZsdkReturnCode JZsdk_RunSystemCmd(char *systemCmd)
{
//FILE *fp;
//printf("JZsdk_RunSystemCmd:%s\n",systemCmd);
// fp = popen(systemCmd, "r");
// if (fp == NULL) {
// return -1;
// }
int status = system(systemCmd);
if (status == -1 || WIFEXITED(status) == false) {
printf("Call %s error, status = %d\n", systemCmd, status);
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}
if (WEXITSTATUS(status) == 0) {
JZSDK_LOG_DEBUG("指令执行成功%s\n",systemCmd);
return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}
else {
JZSDK_LOG_ERROR("指令执行失败Exit status is = %d", WEXITSTATUS(status));
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}
//pclose(fp);
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}
/*
运行命令 并读取返回值
*/
// FILE* JZsdk_RunSystemCmd_ReturnFilePointer(char *systemCmd)
// {
// FILE *fp;
// fp = popen(systemCmd, "r");
// pclose(fp);
// return fp;
// }
/**********************************
*
* 创建一个文件夹
函数名：JZsdk_check_file_exists
参数：文件路径
返回值：JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS表示文件存在，
JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE表示文件不存在
* *******************************/
T_JZsdkReturnCode JZsdk_Osal_Mkdir(const char *filePath)
{
int32_t ret;
if (filePath == NULL) {
return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
}
ret = mkdir(filePath, S_IRWXU);
if (ret < 0) {
switch (errno) {
case EACCES:
JZSDK_LOG_ERROR("Permission denied\n");
break;
case EEXIST:
JZSDK_LOG_ERROR("Directory already exists\n");
break;
case ENOENT:
JZSDK_LOG_ERROR("A component of the path does not exist or is a dangling symbolic link\n");
break;
case ENOMEM:
JZSDK_LOG_ERROR("Not enough memory\n");
break;
case ENOTDIR:
JZSDK_LOG_ERROR("A component of the path prefix is not a directory\n");
break;
case EROFS:
JZSDK_LOG_ERROR("The named file resides on a read-only file system\n");
break;
default:
JZSDK_LOG_ERROR("Unknown error %d\n", errno);
}
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}
return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}
/**********************************
*
* 文件是否存在判断函数
* 判断文件是否存在
函数名：JZsdk_check_file_exists
参数：文件路径
返回值：JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS表示文件存在，
JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE表示文件不存在
* *******************************/
T_JZsdkReturnCode JZsdk_check_file_exists(const char* file_path)
{
if (access(file_path, F_OK) == 0)
{
return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}
/**********************************
*
* 文件夹是否存在判断函数
* 判断文件是否存在
函数名：JZsdk_check_file_exists
参数：文件路径
返回值：JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS表示文件存在，
JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE表示文件不存在
* *******************************/
T_JZsdkReturnCode JZsdk_check_directory_exists_posix(const char* directory_path)
{
struct stat st;
if (stat(directory_path, &st) == 0 && S_ISDIR(st.st_mode))
{
return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}
/**********************************
*
* 创建新的文件
函数名：JZsdk_check_file_exists
参数：文件路径
返回值：JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS表示文件存在，
JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE表示文件不存在
* *******************************/
T_JZsdkReturnCode JZsdk_create_file(const char* file_path)
{
FILE* file = fopen(file_path, "w");
if (file != NULL)
{
fclose(file);
return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}
/**********************************
*
* 删除文件
函数名：JZsdk_delete_file
参数：文件路径
返回值：JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS表示文件已经不存在
JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE表示文件仍然存在
* *******************************/
T_JZsdkReturnCode JZsdk_delete_file(const char* file_path)
{
int remove_result = remove(file_path);
if (remove_result != 0) {
// 删除失败，返回错误
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}
return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS; // 删除成功
}
/**********************************
*
* 复制文件
函数名：JZsdk_copy_file
参数：文件路径
返回值：JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS表示文件已经不存在
JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE表示文件仍然存在
* *******************************/
T_JZsdkReturnCode JZsdk_copy_file_byC(const char* source_path, const char* dest_path)
{
FILE *source_file = fopen(source_path, "rb"); // 以二进制读模式打开源文件
if (source_file == NULL) {
// 无法打开源文件
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}
FILE *dest_file = fopen(dest_path, "wb"); // 以二进制写模式打开目标文件
if (dest_file == NULL) {
// 无法创建或打开目标文件
fclose(source_file); // 关闭已打开的源文件
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}
// 分配缓冲区用于读取和写入文件
char buffer[4096]; // 缓冲区大小可以根据需要调整
size_t bytes_read;
// 复制文件内容
while ((bytes_read = fread(buffer, 1, sizeof(buffer), source_file)) > 0) {
if (fwrite(buffer, 1, bytes_read, dest_file) != bytes_read) {
// 写入目标文件失败
fclose(source_file); // 关闭已打开的源文件
fclose(dest_file); // 关闭已打开的目标文件
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}
}
// 关闭文件
fclose(source_file);
fclose(dest_file);
return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS; // 复制成功
}
// 删除指定路径下的所有文件（不包括子文件夹）
// 注意：这个函数不会删除子文件夹，如果您需要删除子文件夹，请添加递归逻辑。
T_JZsdkReturnCode JZsdk_delete_files_in_directory(const char* directory_path)
{
DIR* dir;
struct dirent* ent;
char file_path[1024]; // 假设文件路径不会超过这个长度
T_JZsdkReturnCode ret = JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
if ((dir = opendir(directory_path)) != NULL) {
while ((ent = readdir(dir)) != NULL) {
// 跳过目录条目 '.' 和 '..'
if (strcmp(ent->d_name, ".") == 0 || strcmp(ent->d_name, "..") == 0) {
continue;
}
// 构建文件的完整路径
snprintf(file_path, sizeof(file_path), "%s/%s", directory_path, ent->d_name);
// 如果是文件，则删除它
if (remove(file_path) != 0) {
perror("remove"); // 打印错误信息
ret = JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
break; // 或者您可以继续并尝试删除其他文件
}
}
closedir(dir);
} else {
perror("opendir"); // 打印错误信息
ret = JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}
return ret;
}
/**********************************
*
* 创建硬链接的函数
函数名：JZsdk_create_hardlink
参数：文件路径 链接路径
返回值：JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS表示成功
JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE表示失败
* *******************************/
T_JZsdkReturnCode JZsdk_create_hardlink(const char* target_path, const char* link_path)
{
int result = link(target_path, link_path);
if (result == -1) {
JZSDK_LOG_ERROR("hardlink"); // 打印错误信息
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE; // 返回错误代码
}
return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS; // 返回成功代码
}
/**********************************
*
* 字符串后缀对比
函数名：JZsdk_strings_suffix_comparison
参数：字符串,后缀名
返回值：
JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS表示后缀正确
JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE表示后缀错误，或是长度不对
* *******************************/
T_JZsdkReturnCode JZsdk_strings_suffix_comparison_onlyStr(const unsigned char* Strings, const unsigned char *suffix)
{
if (Strings == NULL || suffix == NULL)
{
JZSDK_LOG_ERROR("字符串后缀对比输入错误");
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE; // 如果指针为NULL，返回失败
}
int suffix_len = (int)strlen((const char*)suffix); // 强制转换为const char*以确保兼容性
int Strings_len = (int)strlen((const char*)Strings); // 强制转换为const char*以确保兼容性
if (Strings_len <= suffix_len)
{
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE; // 如果字符串长度小于后缀长度，返回失败
}
// 确保不会越界，并且字符串是以空字符结尾的
if (memcmp(Strings + Strings_len - suffix_len, suffix, suffix_len) == 0)
{
return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}
else
{
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}
}
/**********************************
*
* 字符串后缀对比
函数名：JZsdk_strings_suffix_comparison
参数：字符串, 字符串长度，后缀名
返回值：
JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS表示后缀正确
JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE表示后缀错误，或是长度不对
* *******************************/
T_JZsdkReturnCode JZsdk_strings_suffix_comparison_withLen(const unsigned char* Strings, int Strings_len, const unsigned char *suffix)
{
if (Strings == NULL || suffix == NULL)
{
JZSDK_LOG_ERROR("字符串后缀对比输入错误");
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE; // 如果指针为NULL，返回失败
}
int suffix_len = (int)strlen((const char*)suffix); // 强制转换为const char*以确保兼容性
if (Strings_len <= suffix_len)
{
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE; // 如果字符串长度小于后缀长度，返回失败
}
// 确保不会越界，并且字符串是以空字符结尾的
if (memcmp(Strings + Strings_len - suffix_len, suffix, suffix_len) == 0)
{
return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}
else
{
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}
}
/**********************************
*
* 读取文件大小
函数名：JZsdk_Fs_ReadFileSize
参数：字符串, 字符串长度，后缀名
返回值：
JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS读取正确
JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE读取错误
* *******************************/
T_JZsdkReturnCode JZsdk_Fs_ReadFileSize(const unsigned char* FilePath, int *FileSize)
{
struct stat statbuf;
int result = stat(FilePath, &statbuf);
if (result == -1) {
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}
*FileSize = statbuf.st_size;
if (*FileSize == 0)
{
// 文件大小为0，可能是空文件
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}
return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}
\ No newline at end of file
... ...
/**
********************************************************************
* @file JZsdk_FileSystem.h
* 用于文件系统操作
*
*********************************************************************
*/
/* Define to prevent recursive inclusion 避免重定义 -------------------------------------*/
#ifndef JZSDK_FILESYSTEM_H
#define JZSDK_FILESYSTEM_H
/* Includes ------------------------------------------------------------------*/
#include "../JZsdk_Code/JZsdk_Code.h"
#include "./JZsdk_FS_Standards.h"
#ifdef __cplusplus
extern "C" {
#endif
/* Exported constants --------------------------------------------------------*/
/* 常亮定义*/
/* Exported types ------------------------------------------------------------*/
/* Exported functions --------------------------------------------------------*/
T_JZsdkReturnCode JZsdk_RunSystemCmd(char *systemCmd);
T_JZsdkReturnCode JZsdk_check_file_exists(const char* file_path) ;
T_JZsdkReturnCode JZsdk_create_file(const char* file_path) ;
T_JZsdkReturnCode JZsdk_delete_file(const char* file_path) ;
T_JZsdkReturnCode JZsdk_strings_suffix_comparison_onlyStr(const unsigned char* Strings, const unsigned char *suffix) ;
T_JZsdkReturnCode JZsdk_strings_suffix_comparison_withLen(const unsigned char* Strings, int Strings_len, const unsigned char *suffix) ;
T_JZsdkReturnCode JZsdk_Osal_Mkdir(const char *filePath);
T_JZsdkReturnCode JZsdk_delete_files_in_directory(const char* directory_path);
T_JZsdkReturnCode JZsdk_create_hardlink(const char* target_path, const char* link_path);
T_JZsdkReturnCode JZsdk_check_directory_exists_posix(const char* directory_path);
T_JZsdkReturnCode JZsdk_Fs_ReadFileSize(const unsigned char* FilePath, int *FileSize);
T_JZsdkReturnCode JZsdk_copy_file_byC(const char* source_path, const char* dest_path);
#ifdef __cplusplus
}
#endif
#endif
/************************ (C) COPYRIGHT DJI Innovations *******END OF FILE******/
... ...
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include "JZsdkLib.h"
/**********************************
*
* 注册内存
函数名：JZsdk_Malloc
参数：指针，注册大小
返回值：
JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS正确
JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER 错误
* *******************************/
T_JZsdkReturnCode JZsdk_Malloc(void **ptr, unsigned int size)
{
if (size == 0)
{
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}
*ptr = malloc(size);
if (*ptr == NULL)
{
return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
}
return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}
/**********************************
*
* 释放内存
函数名：JZsdk_Free
参数：指针，注册大小
返回值：
JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS正确
JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER 错误
* *******************************/
T_JZsdkReturnCode JZsdk_Free(void *ptr)
{
if (ptr == NULL)
{
return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
}
free(ptr);
ptr = NULL;
return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}
\ No newline at end of file
... ...
/**
********************************************************************
* @file JZsdk_MemoryAdapter.h
* 用于内存管理
*
*********************************************************************
*/
/* Define to prevent recursive inclusion 避免重定义 -------------------------------------*/
#ifndef JZSDK_MEMORY_ADAPTER_H
#define JZSDK_MEMORY_ADAPTER_H
/* Includes ------------------------------------------------------------------*/
#include "../JZsdk_Code/JZsdk_Code.h"
#ifdef __cplusplus
extern "C" {
#endif
/* Exported constants --------------------------------------------------------*/
/* 常亮定义*/
/* Exported types ------------------------------------------------------------*/
/* Exported functions --------------------------------------------------------*/
T_JZsdkReturnCode JZsdk_Malloc(void **ptr, unsigned int size);
T_JZsdkReturnCode JZsdk_Free(void *ptr);
#ifdef __cplusplus
}
#endif
#endif
/************************ (C) COPYRIGHT DJI Innovations *******END OF FILE******/
... ...
/**
* \file lwrb.c
* \brief Lightweight ring buffer
*/
/*
* Copyright (c) 2024 Tilen MAJERLE
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without restriction,
* including without limitation the rights to use, copy, modify, merge,
* publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
* AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*
* This file is part of LwRB - Lightweight ring buffer library.
*
* Author: Tilen MAJERLE <tilen@majerle.eu>
* Version: v3.1.0
*/
#include "./lwrb.h"
/* Memory set and copy functions */
#define BUF_MEMSET memset
#define BUF_MEMCPY memcpy
#define BUF_IS_VALID(b) ((b) != NULL && (b)->buff != NULL && (b)->size > 0)
#define BUF_MIN(x, y) ((x) < (y) ? (x) : (y))
#define BUF_MAX(x, y) ((x) > (y) ? (x) : (y))
#define BUF_SEND_EVT(b, type, bp) \
do { \
if ((b)->evt_fn != NULL) { \
(b)->evt_fn((void*)(b), (type), (bp)); \
} \
} while (0)
/* Optional atomic opeartions */
#ifdef LWRB_DISABLE_ATOMIC
#define LWRB_INIT(var, val) (var) = (val)
#define LWRB_LOAD(var, type) (var)
#define LWRB_STORE(var, val, type) (var) = (val)
#else
#define LWRB_INIT(var, val) atomic_init(&(var), (val))
#define LWRB_LOAD(var, type) atomic_load_explicit(&(var), (type))
#define LWRB_STORE(var, val, type) atomic_store_explicit(&(var), (val), (type))
#endif
/**
* \brief Initialize buffer handle to default values with size and buffer data array
* \param[in] buff: Ring buffer instance
* \param[in] buffdata: Pointer to memory to use as buffer data
* \param[in] size: Size of `buffdata` in units of bytes
* Maximum number of bytes buffer can hold is `size - 1`
* \return `1` on success, `0` otherwise
* * \brief 初始化环形缓冲区
*
* @param buff 环形缓冲区指针
* @param buffdata 缓冲区数据内存
* @param size 缓冲区大小
* @return 初始化成功返回非零值，失败返回0
*/
uint8_t
lwrb_init(lwrb_t* buff, void* buffdata, lwrb_sz_t size) {
if (buff == NULL || buffdata == NULL || size == 0) {
return 0;
}
buff->evt_fn = NULL;
buff->size = size;
buff->buff = buffdata;
LWRB_INIT(buff->w, 0);
LWRB_INIT(buff->r, 0);
return 1;
}
/**
* \brief Check if buff is initialized and ready to use
* \param[in] buff: Ring buffer instance
* \return `1` if ready, `0` otherwise
*/
uint8_t
lwrb_is_ready(lwrb_t* buff) {
return BUF_IS_VALID(buff);
}
/**
* \brief Free buffer memory
* \note Since implementation does not use dynamic allocation,
* it just sets buffer handle to `NULL`
* \param[in] buff: Ring buffer instance
*/
void
lwrb_free(lwrb_t* buff) {
if (BUF_IS_VALID(buff)) {
buff->buff = NULL;
}
}
/**
* \brief Set event function callback for different buffer operations
* \param[in] buff: Ring buffer instance
* \param[in] evt_fn: Callback function
*/
void
lwrb_set_evt_fn(lwrb_t* buff, lwrb_evt_fn evt_fn) {
if (BUF_IS_VALID(buff)) {
buff->evt_fn = evt_fn;
}
}
/**
* \brief Set custom buffer argument, that can be retrieved in the event function
* \param[in] buff: Ring buffer instance
* \param[in] arg: Custom user argument
*/
void
lwrb_set_arg(lwrb_t* buff, void* arg) {
if (BUF_IS_VALID(buff)) {
buff->arg = arg;
}
}
/**
* \brief Get custom buffer argument, previously set with \ref lwrb_set_arg
* \param[in] buff: Ring buffer instance
* \return User argument, previously set with \ref lwrb_set_arg
*/
void*
lwrb_get_arg(lwrb_t* buff) {
return buff != NULL ? buff->arg : NULL;
}
/**
* \brief Write data to buffer.
* Copies data from `data` array to buffer and marks buffer as full for maximum `btw` number of bytes
*
* \param[in] buff: Ring buffer instance
* \param[in] data: Pointer to data to write into buffer
* \param[in] btw: Number of bytes to write
* \return Number of bytes written to buffer.
* When returned value is less than `btw`, there was no enough memory available
* to copy full data array.
*/
lwrb_sz_t
lwrb_write(lwrb_t* buff, const void* data, lwrb_sz_t btw) {
lwrb_sz_t written = 0;
if (lwrb_write_ex(buff, data, btw, &written, 0)) {
return written;
}
return 0;
}
/**
* \brief Write extended functionality
*
* \param buff: Ring buffer instance
* \param data: Pointer to data to write into buffer
* \param btw: Number of bytes to write
* \param bw: Output pointer to write number of bytes written
* \param flags: Optional flags.
* \ref LWRB_FLAG_WRITE_ALL: Request to write all data (up to btw).
* Will early return if no memory available
* \return `1` if write operation OK, `0` otherwise
*/
uint8_t
lwrb_write_ex(lwrb_t* buff, const void* data, lwrb_sz_t btw, lwrb_sz_t* bw, uint16_t flags) {
lwrb_sz_t tocopy, free, buff_w_ptr;
const uint8_t* d = data;
if (!BUF_IS_VALID(buff) || data == NULL || btw == 0) {
return 0;
}
/* Calculate maximum number of bytes available to write */
free = lwrb_get_free(buff);
/* If no memory, or if user wants to write ALL data but no enough space, exit early */
if (free == 0 || (free < btw && flags & LWRB_FLAG_WRITE_ALL)) {
return 0;
}
btw = BUF_MIN(free, btw);
buff_w_ptr = LWRB_LOAD(buff->w, memory_order_acquire);
/* Step 1: Write data to linear part of buffer */
tocopy = BUF_MIN(buff->size - buff_w_ptr, btw);
BUF_MEMCPY(&buff->buff[buff_w_ptr], d, tocopy);
buff_w_ptr += tocopy;
btw -= tocopy;
/* Step 2: Write data to beginning of buffer (overflow part) */
if (btw > 0) {
BUF_MEMCPY(buff->buff, &d[tocopy], btw);
buff_w_ptr = btw;
}
/* Step 3: Check end of buffer */
if (buff_w_ptr >= buff->size) {
buff_w_ptr = 0;
}
/*
* Write final value to the actual running variable.
* This is to ensure no read operation can access intermediate data
*/
LWRB_STORE(buff->w, buff_w_ptr, memory_order_release);
BUF_SEND_EVT(buff, LWRB_EVT_WRITE, tocopy + btw);
if (bw != NULL) {
*bw = tocopy + btw;
}
return 1;
}
/**
* \brief Read data from buffer.
* Copies data from buffer to `data` array and marks buffer as free for maximum `btr` number of bytes
*
* \param[in] buff: Ring buffer instance
* \param[out] data: Pointer to output memory to copy buffer data to
* \param[in] btr: Number of bytes to read
* \return Number of bytes read and copied to data array
*/
lwrb_sz_t
lwrb_read(lwrb_t* buff, void* data, lwrb_sz_t btr) {
lwrb_sz_t read = 0;
if (lwrb_read_ex(buff, data, btr, &read, 0)) {
return read;
}
return 0;
}
/**
* \brief Write extended functionality
*
* \param buff: Ring buffer instance
* \param data: Pointer to memory to write read data from buffer
* \param btr: Number of bytes to read
* \param br: Output pointer to write number of bytes read
* \param flags: Optional flags
* \ref LWRB_FLAG_READ_ALL: Request to read all data (up to btr).
* Will early return if no enough bytes in the buffer
* \return `1` if read operation OK, `0` otherwise
*/
uint8_t
lwrb_read_ex(lwrb_t* buff, void* data, lwrb_sz_t btr, lwrb_sz_t* br, uint16_t flags) {
lwrb_sz_t tocopy, full, buff_r_ptr;
uint8_t* d = data;
if (!BUF_IS_VALID(buff) || data == NULL || btr == 0) {
return 0;
}
/* Calculate maximum number of bytes available to read */
full = lwrb_get_full(buff);
if (full == 0 || (full < btr && (flags & LWRB_FLAG_READ_ALL))) {
return 0;
}
btr = BUF_MIN(full, btr);
buff_r_ptr = LWRB_LOAD(buff->r, memory_order_acquire);
/* Step 1: Read data from linear part of buffer */
tocopy = BUF_MIN(buff->size - buff_r_ptr, btr);
BUF_MEMCPY(d, &buff->buff[buff_r_ptr], tocopy);
buff_r_ptr += tocopy;
btr -= tocopy;
/* Step 2: Read data from beginning of buffer (overflow part) */
if (btr > 0) {
BUF_MEMCPY(&d[tocopy], buff->buff, btr);
buff_r_ptr = btr;
}
/* Step 3: Check end of buffer */
if (buff_r_ptr >= buff->size) {
buff_r_ptr = 0;
}
/*
* Write final value to the actual running variable.
* This is to ensure no write operation can access intermediate data
*/
LWRB_STORE(buff->r, buff_r_ptr, memory_order_release);
BUF_SEND_EVT(buff, LWRB_EVT_READ, tocopy + btr);
if (br != NULL) {
*br = tocopy + btr;
}
return 1;
}
/**
* \brief Read from buffer without changing read pointer (peek only)
* \param[in] buff: Ring buffer instance
* \param[in] skip_count: Number of bytes to skip before reading data
* \param[out] data: Pointer to output memory to copy buffer data to
* \param[in] btp: Number of bytes to peek
* \return Number of bytes peeked and written to output array
*/
lwrb_sz_t
lwrb_peek(const lwrb_t* buff, lwrb_sz_t skip_count, void* data, lwrb_sz_t btp) {
lwrb_sz_t full, tocopy, r;
uint8_t* d = data;
if (!BUF_IS_VALID(buff) || data == NULL || btp == 0) {
return 0;
}
/*
* Calculate maximum number of bytes available to read
* and check if we can even fit to it
*/
full = lwrb_get_full(buff);
if (skip_count >= full) {
return 0;
}
r = LWRB_LOAD(buff->r, memory_order_relaxed);
r += skip_count;
full -= skip_count;
if (r >= buff->size) {
r -= buff->size;
}
/* Check maximum number of bytes available to read after skip */
btp = BUF_MIN(full, btp);
if (btp == 0) {
return 0;
}
/* Step 1: Read data from linear part of buffer */
tocopy = BUF_MIN(buff->size - r, btp);
BUF_MEMCPY(d, &buff->buff[r], tocopy);
btp -= tocopy;
/* Step 2: Read data from beginning of buffer (overflow part) */
if (btp > 0) {
BUF_MEMCPY(&d[tocopy], buff->buff, btp);
}
return tocopy + btp;
}
/**
* \brief Get available size in buffer for write operation
* \param[in] buff: Ring buffer instance
* \return Number of free bytes in memory
*/
lwrb_sz_t
lwrb_get_free(const lwrb_t* buff) {
lwrb_sz_t size, w, r;
if (!BUF_IS_VALID(buff)) {
return 0;
}
/*
* Copy buffer pointers to local variables with atomic access.
*
* To ensure thread safety (only when in single-entry, single-exit FIFO mode use case),
* it is important to write buffer r and w values to local w and r variables.
*
* Local variables will ensure below if statements will always use the same value,
* even if buff->w or buff->r get changed during interrupt processing.
*
* They may change during load operation, important is that
* they do not change during if-else operations following these assignments.
*
* lwrb_get_free is only called for write purpose, and when in FIFO mode, then:
* - buff->w pointer will not change by another process/interrupt because we are in write mode just now
* - buff->r pointer may change by another process. If it gets changed after buff->r has been loaded to local variable,
* buffer will see "free size" less than it actually is. This is not a problem, application can
* always try again to write more data to remaining free memory that was read just during copy operation
*/
w = LWRB_LOAD(buff->w, memory_order_relaxed);
r = LWRB_LOAD(buff->r, memory_order_relaxed);
if (w >= r) {
size = buff->size - (w - r);
} else {
size = r - w;
}
/* Buffer free size is always 1 less than actual size */
return size - 1;
}
/**
* \brief Get number of bytes currently available in buffer
* \param[in] buff: Ring buffer instance
* \return Number of bytes ready to be read
*/
lwrb_sz_t
lwrb_get_full(const lwrb_t* buff) {
lwrb_sz_t size, w, r;
if (!BUF_IS_VALID(buff)) {
return 0;
}
/*
* Copy buffer pointers to local variables.
*
* To ensure thread safety (only when in single-entry, single-exit FIFO mode use case),
* it is important to write buffer r and w values to local w and r variables.
*
* Local variables will ensure below if statements will always use the same value,
* even if buff->w or buff->r get changed during interrupt processing.
*
* They may change during load operation, important is that
* they do not change during if-else operations following these assignments.
*
* lwrb_get_full is only called for read purpose, and when in FIFO mode, then:
* - buff->r pointer will not change by another process/interrupt because we are in read mode just now
* - buff->w pointer may change by another process. If it gets changed after buff->w has been loaded to local variable,
* buffer will see "full size" less than it really is. This is not a problem, application can
* always try again to read more data from remaining full memory that was written just during copy operation
*/
w = LWRB_LOAD(buff->w, memory_order_relaxed);
r = LWRB_LOAD(buff->r, memory_order_relaxed);
if (w >= r) {
size = w - r;
} else {
size = buff->size - (r - w);
}
return size;
}
/**
* \brief Resets buffer to default values. Buffer size is not modified
* \note This function is not thread safe.
* When used, application must ensure there is no active read/write operation
* \param[in] buff: Ring buffer instance
*/
void
lwrb_reset(lwrb_t* buff) {
if (BUF_IS_VALID(buff)) {
LWRB_STORE(buff->w, 0, memory_order_release);
LWRB_STORE(buff->r, 0, memory_order_release);
BUF_SEND_EVT(buff, LWRB_EVT_RESET, 0);
}
}
/**
* \brief Get linear address for buffer for fast read
* \param[in] buff: Ring buffer instance
* \return Linear buffer start address
*/
void*
lwrb_get_linear_block_read_address(const lwrb_t* buff) {
if (!BUF_IS_VALID(buff)) {
return NULL;
}
return &buff->buff[buff->r];
}
/**
* \brief Get length of linear block address before it overflows for read operation
* \param[in] buff: Ring buffer instance
* \return Linear buffer size in units of bytes for read operation
*/
lwrb_sz_t
lwrb_get_linear_block_read_length(const lwrb_t* buff) {
lwrb_sz_t len, w, r;
if (!BUF_IS_VALID(buff)) {
return 0;
}
/*
* Use temporary values in case they are changed during operations.
* See lwrb_buff_free or lwrb_buff_full functions for more information why this is OK.
*/
w = LWRB_LOAD(buff->w, memory_order_relaxed);
r = LWRB_LOAD(buff->r, memory_order_relaxed);
if (w > r) {
len = w - r;
} else if (r > w) {
len = buff->size - r;
} else {
len = 0;
}
return len;
}
/**
* \brief Skip (ignore; advance read pointer) buffer data
* Marks data as read in the buffer and increases free memory for up to `len` bytes
*
* \note Useful at the end of streaming transfer such as DMA
* \param[in] buff: Ring buffer instance
* \param[in] len: Number of bytes to skip and mark as read
* \return Number of bytes skipped
*/
lwrb_sz_t
lwrb_skip(lwrb_t* buff, lwrb_sz_t len) {
lwrb_sz_t full, r;
if (!BUF_IS_VALID(buff) || len == 0) {
return 0;
}
full = lwrb_get_full(buff);
len = BUF_MIN(len, full);
r = LWRB_LOAD(buff->r, memory_order_acquire);
r += len;
if (r >= buff->size) {
r -= buff->size;
}
LWRB_STORE(buff->r, r, memory_order_release);
BUF_SEND_EVT(buff, LWRB_EVT_READ, len);
return len;
}
/**
* \brief Get linear address for buffer for fast read
* \param[in] buff: Ring buffer instance
* \return Linear buffer start address
*/
void*
lwrb_get_linear_block_write_address(const lwrb_t* buff) {
if (!BUF_IS_VALID(buff)) {
return NULL;
}
return &buff->buff[buff->w];
}
/**
* \brief Get length of linear block address before it overflows for write operation
* \param[in] buff: Ring buffer instance
* \return Linear buffer size in units of bytes for write operation
*/
lwrb_sz_t
lwrb_get_linear_block_write_length(const lwrb_t* buff) {
lwrb_sz_t len, w, r;
if (!BUF_IS_VALID(buff)) {
return 0;
}
/*
* Use temporary values in case they are changed during operations.
* See lwrb_buff_free or lwrb_buff_full functions for more information why this is OK.
*/
w = LWRB_LOAD(buff->w, memory_order_relaxed);
r = LWRB_LOAD(buff->r, memory_order_relaxed);
if (w >= r) {
len = buff->size - w;
/*
* When read pointer is 0,
* maximal length is one less as if too many bytes
* are written, buffer would be considered empty again (r == w)
*/
if (r == 0) {
/*
* Cannot overflow:
* - If r is not 0, statement does not get called
* - buff->size cannot be 0 and if r is 0, len is greater 0
*/
--len;
}
} else {
len = r - w - 1;
}
return len;
}
/**
* \brief Advance write pointer in the buffer.
* Similar to skip function but modifies write pointer instead of read
*
* \note Useful when hardware is writing to buffer and application needs to increase number
* of bytes written to buffer by hardware
* \param[in] buff: Ring buffer instance
* \param[in] len: Number of bytes to advance
* \return Number of bytes advanced for write operation
*/
lwrb_sz_t
lwrb_advance(lwrb_t* buff, lwrb_sz_t len) {
lwrb_sz_t free, w;
if (!BUF_IS_VALID(buff) || len == 0) {
return 0;
}
/* Use local variables before writing back to main structure */
free = lwrb_get_free(buff);
len = BUF_MIN(len, free);
w = LWRB_LOAD(buff->w, memory_order_acquire);
w += len;
if (w >= buff->size) {
w -= buff->size;
}
LWRB_STORE(buff->w, w, memory_order_release);
BUF_SEND_EVT(buff, LWRB_EVT_WRITE, len);
return len;
}
/**
* \brief Searches for a *needle* in an array, starting from given offset.
*
* \note This function is not thread-safe.
*
* \param buff: Ring buffer to search for needle in
* \param bts: Constant byte array sequence to search for in a buffer
* \param len: Length of the \arg bts array
* \param start_offset: Start offset in the buffer
* \param found_idx: Pointer to variable to write index in array where bts has been found
* Must not be set to `NULL`
* \return `1` if \arg bts found, `0` otherwise
*/
uint8_t
lwrb_find(const lwrb_t* buff, const void* bts, lwrb_sz_t len, lwrb_sz_t start_offset, lwrb_sz_t* found_idx) {
lwrb_sz_t full, r, max_x;
uint8_t found = 0;
const uint8_t* needle = bts;
if (!BUF_IS_VALID(buff) || needle == NULL || len == 0 || found_idx == NULL) {
return 0;
}
*found_idx = 0;
full = lwrb_get_full(buff);
/* Verify initial conditions */
if (full < (len + start_offset)) {
return 0;
}
/* Max number of for loops is buff_full - input_len - start_offset of buffer length */
max_x = full - len;
for (lwrb_sz_t skip_x = start_offset; !found && skip_x <= max_x; ++skip_x) {
found = 1; /* Found by default */
/* Prepare the starting point for reading */
r = buff->r + skip_x;
if (r >= buff->size) {
r -= buff->size;
}
/* Search in the buffer */
for (lwrb_sz_t i = 0; i < len; ++i) {
if (buff->buff[r] != needle[i]) {
found = 0;
break;
}
if (++r >= buff->size) {
r = 0;
}
}
if (found) {
*found_idx = skip_x;
}
}
return found;
}
... ...
/**
* \file lwrb.h
* \brief LwRB - Lightweight ring buffer
*/
/*
* Copyright (c) 2024 Tilen MAJERLE
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without restriction,
* including without limitation the rights to use, copy, modify, merge,
* publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
* AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*
* This file is part of LwRB - Lightweight ring buffer library.
*
* Author: Tilen MAJERLE <tilen@majerle.eu>
* Version: v3.1.0
*/
#ifndef LWRB_HDR_H
#define LWRB_HDR_H
#include <stddef.h>
#include <stdint.h>
#include <string.h>
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
/**
* \defgroup LWRB Lightweight ring buffer manager
* \brief Lightweight ring buffer manager
* \{
*/
#if !defined(LWRB_DISABLE_ATOMIC) || __DOXYGEN__
#include <stdatomic.h>
/**
* \brief Atomic type for size variable.
* Default value is set to be `unsigned 32-bits` type
* * \brief 原子类型，用于大小变量。
* 默认值被设置为`无符号32位`类型
*/
typedef atomic_ulong lwrb_sz_atomic_t;
/**
* \brief Size variable for all library operations.
* Default value is set to be `unsigned 32-bits` type
* * \brief 所有库操作的大小变量。
* 默认值被设置为`无符号32位`类型
*/
typedef unsigned long lwrb_sz_t;
#else
typedef unsigned long lwrb_sz_atomic_t;
typedef unsigned long lwrb_sz_t;
#endif
/**
* \brief Event type for buffer operations
* 用于缓冲区操作的事件类型
*/
typedef enum {
LWRB_EVT_READ, /*!< Read event */
LWRB_EVT_WRITE, /*!< Write event */
LWRB_EVT_RESET, /*!< Reset event */
} lwrb_evt_type_t;
/**
* \brief Buffer structure forward declaration环形缓冲区结构的前置声明
*/
struct lwrb;
/**
* \brief Event callback function type 事件回调函数类型
* \param[in] buff: Buffer handle for event 事件的缓冲区句柄
* \param[in] evt: Event type 事件类型
* \param[in] bp: Number of bytes written or read (when used), depends on event type 写入或读取的字节数（当使用时），取决于事件类型
*/
typedef void (*lwrb_evt_fn)(struct lwrb* buff, lwrb_evt_type_t evt, lwrb_sz_t bp);
/* List of flags */
#define LWRB_FLAG_READ_ALL ((uint16_t)0x0001)
#define LWRB_FLAG_WRITE_ALL ((uint16_t)0x0001)
/**
* \brief Buffer structure
*/
typedef struct lwrb {
uint8_t* buff; // 指向缓冲区数据的指针。当buff != NULL且size > 0时，认为缓冲区已初始化 /
lwrb_sz_t size; /*!<缓冲区数据的大小。实际缓冲区的大小比此值小1字节 */
lwrb_sz_atomic_t r; /*!< 下一个读指针。当r == w时，认为缓冲区为空；当w == (r - 1 + size) % size时，认为缓冲区已满 */
lwrb_sz_atomic_t w; /*!< 下一个写指针。当r == w时，认为缓冲区为空；当w == (r - 1 + size) % size时，认为缓冲区已满 */
lwrb_evt_fn evt_fn; /*!< 事件回调函数指针 */
void* arg; /*!< 事件自定义用户参数t */
} lwrb_t;
uint8_t lwrb_init(lwrb_t* buff, void* buffdata, lwrb_sz_t size);
uint8_t lwrb_is_ready(lwrb_t* buff);
void lwrb_free(lwrb_t* buff);
void lwrb_reset(lwrb_t* buff);
void lwrb_set_evt_fn(lwrb_t* buff, lwrb_evt_fn fn);
void lwrb_set_arg(lwrb_t* buff, void* arg);
void* lwrb_get_arg(lwrb_t* buff);
/* Read/Write functions */
lwrb_sz_t lwrb_write(lwrb_t* buff, const void* data, lwrb_sz_t btw);
lwrb_sz_t lwrb_read(lwrb_t* buff, void* data, lwrb_sz_t btr);
lwrb_sz_t lwrb_peek(const lwrb_t* buff, lwrb_sz_t skip_count, void* data, lwrb_sz_t btp);
/* Extended read/write functions */
uint8_t lwrb_write_ex(lwrb_t* buff, const void* data, lwrb_sz_t btw, lwrb_sz_t* bw, uint16_t flags);
uint8_t lwrb_read_ex(lwrb_t* buff, void* data, lwrb_sz_t btr, lwrb_sz_t* br, uint16_t flags);
/* Buffer size information */
lwrb_sz_t lwrb_get_free(const lwrb_t* buff);
lwrb_sz_t lwrb_get_full(const lwrb_t* buff);
/* Read data block management */
void* lwrb_get_linear_block_read_address(const lwrb_t* buff);
lwrb_sz_t lwrb_get_linear_block_read_length(const lwrb_t* buff);
lwrb_sz_t lwrb_skip(lwrb_t* buff, lwrb_sz_t len);
/* Write data block management */
void* lwrb_get_linear_block_write_address(const lwrb_t* buff);
lwrb_sz_t lwrb_get_linear_block_write_length(const lwrb_t* buff);
lwrb_sz_t lwrb_advance(lwrb_t* buff, lwrb_sz_t len);
/* Search in buffer */
uint8_t lwrb_find(const lwrb_t* buff, const void* bts, lwrb_sz_t len, lwrb_sz_t start_offset, lwrb_sz_t* found_idx);
lwrb_sz_t lwrb_overwrite(lwrb_t* buff, const void* data, lwrb_sz_t btw);
lwrb_sz_t lwrb_move(lwrb_t* dest, lwrb_t* src);
/**
* \}
*/
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* LWRB_HDR_H */
... ...
/**
********************************************************************
* @file JZsdkCommonFuntion.h
* JZsdk常用函数库的头文件
*
*********************************************************************
*/
/* Define to prevent recursive inclusion 避免重定义 -------------------------------------*/
#ifndef JZSDKCOMMONFUNTION_H
#define JZSDKCOMMONFUNTION_H
/* Includes ------------------------------------------------------------------*/
#ifdef __cplusplus
extern "C" {
#endif
/* Exported constants --------------------------------------------------------*/
/* 常亮定义*/
#include "JZsdk_string/JZsdk_string.h"
#include "JZsdk_math/JZsdk_math.h"
/* Exported types ------------------------------------------------------------*/
/* Exported functions --------------------------------------------------------*/
#ifdef __cplusplus
}
#endif
#endif
... ...
/**
********************************************************************
* @file JZsdk_math.h
* 用于文件系统操作
*
*********************************************************************
*/
/* Define to prevent recursive inclusion 避免重定义 -------------------------------------*/
#ifndef JZSDK_MATH_H
#define JZSDK_MATH_H
/* Includes ------------------------------------------------------------------*/
#include <stddef.h>
#include "JZsdk_Base/JZsdk_Code/JZsdk_Code.h"
#ifdef __cplusplus
extern "C" {
#endif
/* Exported constants --------------------------------------------------------*/
/* 常亮定义*/
/* Exported types ------------------------------------------------------------*/
/* Exported functions --------------------------------------------------------*/
#define JZ_MATH_MAX(a, b) ((a) > (b) ? (a) : (b)) //比较大小
#define JZ_MATH_MIN(a, b) ((a) < (b) ? (a) : (b)) //比较大小
#define JZ_MATH_ADD(a, b) ((a) + (b)) //相加
#define JZ_MATH_SUB(a, b) ((a) - (b)) //相减
#define JZ_MATH_MUL(a, b) ((a) * (b)) //相乘
#define JZ_MATH_DIVIDE(a, b) ((b) != 0 ? (a) / (b) : (-1)) //相除
#define JZ_MATH_MODULUS(a, b) ((b) != 0 ? (a) % (b) : (-1)) //求余
#define JZ_MATH_ABS(a) ((a) < 0 ? -(a) : (a)) //求绝对值
#define JZ_MATH_SQUARE(a) ((a) * (a)) //求平方
#define JZ_MATH_CUBE(a) ((a) * (a) * (a)) //求立方
// 注意：这个宏只适用于正整数幂且幂次较小的情况
#define JZ_MATH_POW(base, exponent) ((exponent) == 0 ? 1 : ((base) * JZ_MATH_POW(base, (exponent) - 1)))
// 使用递归，对于大幂次或浮点数幂次，建议使用math.h中的pow函数
// #include <math.h>
// #define JZ_MATH_SQRT(a) sqrt(a)
#define JZ_MATH_CLAMP(value, min, max) ((value) < (min) ? (min) : ((value) > (max) ? (max) : (value))) //限制值在范围内（确保一个值在指定的最小值和最大值之间）：
#define JZ_MATH_SWAP(a, b) do { typeof(a) temp = (a); (a) = (b); (b) = temp; } while (0) //交换两个变量的值（这个宏使用了一个临时变量，但它仍然是通过宏来完成的）：
#ifdef __cplusplus
}
#endif
#endif
... ...
#include <stdio.h>
#include <string.h>
#include "JZsdk_string.h"
#include "../../JZsdkLib.h"
/*
* 用于字符串转int型
*/
int JZsdk_String_str_to_int(const char *str)
{
int temp = 0;
const char *ptr = str; //ptr保存str字符串开头
if (*str == '-' || *str == '+') //如果第一个字符是正负号，
{ //则移到下一个字符
str++;
}
while(*str != 0)
{
if ((*str < '0') || (*str > '9')) //如果当前字符不是数字
{ //则退出循环
break;
}
temp = temp * 10 + (*str - '0'); //如果当前字符是数字则计算数值
str++; //移到下一个字符
}
if (*ptr == '-') //如果字符串是以“-”开头，则转换成其相反数
{
temp = -temp;
}
return temp;
}
/*
* int型转字符串
*/
void JZsdk_String_int_to_str(int n, char *str)
{
char buf[10] = "";
int i = 0;
int len = 0;
int temp = n < 0 ? -n: n; // temp为n的绝对值
if (str == NULL)
{
return;
}
while(temp)
{
buf[i++] = (temp % 10) + '0'; //把temp的每一位上的数存入buf
temp = temp / 10;
}
len = n < 0 ? ++i: i; //如果n是负数，则多需要一位来存储负号
str[i] = 0; //末尾是结束符0
while(1)
{
i--;
if (buf[len-i-1] ==0)
{
break;
}
str[i] = buf[len-i-1]; //把buf数组里的字符拷到字符串
}
if (i == 0 )
{
str[i] = '-'; //如果是负数，添加一个负号
}
}
/*
* longlong型转字符串型
*/
size_t JZsdk_String_longlong_to_str(char *s, long long value,int radix)
{
char *p, aux;
unsigned long long v;
size_t l;
/* Generate the string representation, this method produces
* an reversed string. */
v = (value < 0) ? -value : value;
p = s;
do {
*p++ = '0' + (v % radix); // 2
v /= radix; // 2
} while (v);
if (value < 0) *p++ = '-';
/* Compute length and add null term. */
l = p - s;
*p = '\0';
/* Reverse the string. */
p--;
while (s < p) {
aux = *s;
*s = *p;
*p = aux;
s++;
p--;
}
return l;
}
/****************
*
* 用于判断数组是否为空
* 不为空 JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE
* 空 JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS
* ***********/
T_JZsdkReturnCode JZsdk_Array_isEmpty(unsigned char array[], int size)
{
for (int i = 0; i < size; i++) {
if (array[i] != 0) {
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE; // 数组不为空
}
}
return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS; // 数组为空
}
/****************
*
* 用于替换数组中的换行符'\n'为结束符'\0'
*
* 替换成功返回 JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS
* 没有替换 返回JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE
* ***********/
T_JZsdkReturnCode JZsdk_replace_newlines_with_null_terminator(char* string)
{
int replace_flag = JZ_FLAGCODE_OFF;
// 获取字符串的长度
int length = strlen(string);
// 遍历字符串，将换行符替换为结束符
for (int i = 0; i < length; i++) {
if (string[i] == '\n') {
string[i] = '\0';
replace_flag = JZ_FLAGCODE_ON;
}
}
if (replace_flag == JZ_FLAGCODE_ON)
{
return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}
else
{
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}
}
/****************
*
* 用于将两位u8的数据逆向合并为u16的数据
*
* 成功返回 JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS
* 失败 返回JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE
* ***********/
T_JZsdkReturnCode JZsdk_Merge_U8_to_U16_byReverse(U8_t *in_str, int in_str_len, U16_t *out_str, int *out_str_len)
{
// 检查输入长度是否是2的倍数
if (in_str_len % 2 != 0)
{
// 输入长度不是偶数，处理错误
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}
// 检查函数地址
if(in_str == NULL || out_str == NULL)
{
return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
}
int Step = 0;
for (int i = 0; i < in_str_len; i += 2)
{
// 两字节合并为一个16位的整数，注意高低位的顺序
out_str[Step++] = ((U16_t)in_str[i+1] << 8) | in_str[i];
}
// 设置输出字符串的长度为输入长度的一半
*out_str_len = in_str_len / 2;
return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}
/****************
*
* 用于将两位u8的数据正向合并为u16的数据
*
* 成x功返回 JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS
* 失败 返回JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE
* ***********/
T_JZsdkReturnCode JZsdk_Merge_U8_to_U16_byForward(U8_t *in_str, int in_str_len, U16_t *out_str, int *out_str_len)
{
// 检查输入长度是否是2的倍数
if (in_str_len % 2 != 0)
{
// 输入长度不是偶数，处理错误
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}
// 检查函数地址
if (in_str == NULL || out_str == NULL)
{
return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
}
int Step = 0;
for (int i = 0; i < in_str_len; i += 2)
{
// 两字节合并为一个16位的整数，注意高低位的顺序
out_str[Step++] = ((U16_t)in_str[i+1] << 8) | in_str[i];
}
// 设置输出字符串的长度为输入长度的一半
*out_str_len = in_str_len / 2;
return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}
\ No newline at end of file
... ...
/**
********************************************************************
* @file JZsdk_string.h
* 用于文件系统操作
*
*********************************************************************
*/
/* Define to prevent recursive inclusion 避免重定义 -------------------------------------*/
#ifndef JZSDK_STRING_H
#define JZSDK_STRING_H
/* Includes ------------------------------------------------------------------*/
#include <stddef.h>
#include "JZsdk_Base/JZsdk_Code/JZsdk_Code.h"
#ifdef __cplusplus
extern "C" {
#endif
/* Exported constants --------------------------------------------------------*/
/* 常亮定义*/
/* Exported types ------------------------------------------------------------*/
/* Exported functions --------------------------------------------------------*/
int JZsdk_String_str_to_int(const char *str);
void JZsdk_String_int_to_str(int n, char *str);
size_t JZsdk_String_longlong_to_str(char *s, long long value,int radix);
T_JZsdkReturnCode JZsdk_Array_isEmpty(unsigned char array[], int size);
T_JZsdkReturnCode JZsdk_replace_newlines_with_null_terminator(char* string) ;
T_JZsdkReturnCode JZsdk_Merge_U8_to_U16_byReverse(U8_t *in_str, int in_str_len, U16_t *out_str, int *out_str_len);
T_JZsdkReturnCode JZsdk_Merge_U8_to_U16_byForward(U8_t *in_str, int in_str_len, U16_t *out_str, int *out_str_len);
#ifdef __cplusplus
}
#endif
#endif
... ...
/******************************
*
* JZsdk的任务管理模块
*
*
* ***************************/
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
#include "./TaskManagement.h"
#include <JZsdkLib.h>
#define THREAD_POOL_SIZE 5 // 线程池大小
typedef struct {
void (*task_function)(void*); //任务函数指针,用于指定 执行的任务
void* data; // 任务参数 //任务参数的地址 用于输入任务内容
} t_JZsdk_TaskMgmt_TaskInput;
typedef struct {
pthread_t thread; // 线程 //调用的线程
int is_busy; // 标识线程是否忙碌
t_JZsdk_TaskMgmt_TaskInput* task; // 线程执行的任务
pthread_mutex_t lock; // 互斥锁
pthread_cond_t condition; // 条件变量
} t_ThreadPool;
t_ThreadPool TaskPool[THREAD_POOL_SIZE]; //任务池子
static void* TaskManagement_ThreadFunction(void* arg);
/**************
*
* 任务管理模块的初始化
*
* ***************/
T_JZsdkReturnCode TaskManagement_Init()
{
//1、创建任务池子
for (int i = 0; i < THREAD_POOL_SIZE; i++)
{
TaskPool[i].is_busy = 0;
pthread_mutex_init(&TaskPool[i].lock, NULL);
pthread_cond_init(&TaskPool[i].condition, NULL);
pthread_create(&TaskPool[i].thread, NULL, TaskManagement_ThreadFunction, &TaskPool[i]);
}
}
/**************
*
* 任务的输入
*
* ***************/
T_JZsdkReturnCode TaskManagement_SubmitTask(void (*task_function)(void*), void* data)
{
//检阅是否有空余的任务线程
int i = 0;
for ( ; i < THREAD_POOL_SIZE; i++)
{
if (!TaskPool[i].is_busy)
{
//检测到有空余的线程
break;
}
}
//没有多余的任务线程，退出该发送任务
if (i >= THREAD_POOL_SIZE)
{
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}
t_JZsdk_TaskMgmt_TaskInput *task = (t_JZsdk_TaskMgmt_TaskInput*)malloc(sizeof(t_JZsdk_TaskMgmt_TaskInput));
if (task == NULL)
{
// 处理内存分配失败的情况
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}
task->task_function = task_function;
task->data = data;
//将发送内容放入任务
TaskPool[i].task = task;
TaskPool[i].is_busy = 1;
pthread_cond_signal(&TaskPool[i].condition);
return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}
//执行函数
static void* TaskManagement_ThreadFunction(void* arg)
{
t_ThreadPool* pool = (t_ThreadPool*)arg;
while (1)
{
pthread_mutex_lock(&pool->lock);
while (!pool->is_busy)
{
pthread_cond_wait(&pool->condition, &pool->lock);
}
// 执行任务
pthread_mutex_unlock(&pool->lock);
if (pool->task->task_function != NULL)
{
pool->task->task_function(pool->task->data);
}
// 执行完成，将状态置为未忙碌
pthread_mutex_lock(&pool->lock);
if (pool->task != NULL)
{
free(pool->task);
pool->task = NULL;
}
pool->is_busy = 0;
pthread_mutex_unlock(&pool->lock);
}
return NULL;
}
\ No newline at end of file
... ...
/**
********************************************************************
* @file TaskManagement.h
*
*
*********************************************************************
*/
/* Define to prevent recursive inclusion 避免重定义 -------------------------------------*/
#ifndef JZSDK_TASK_MANAGEMENT_H
#define JZSDK_TASK_MANAGEMENT_H
/* Includes ------------------------------------------------------------------*/
#ifdef __cplusplus
extern "C" {
#endif
/* Exported constants --------------------------------------------------------*/
/* 常亮定义*/
#include "JZsdk_Base/JZsdk_Code/JZsdk_Code.h"
/* Exported types ------------------------------------------------------------*/
/* Exported functions --------------------------------------------------------*/
T_JZsdkReturnCode TaskManagement_Init();
T_JZsdkReturnCode TaskManagement_SubmitTask(void (*task_function)(void*), void* data);
#ifdef __cplusplus
}
#endif
#endif
... ...
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
#include "./TaskManagement.h"
#include <JZsdkLib.h>
typedef struct {
char* str;
int num;
} TaskData;
static void TaskMgmt_sample_funtion(void *data)
{
TaskData* taskData = (TaskData*)data;
printf("Sending data to serial: %s, %d\n", taskData->str, taskData->num);
free(taskData);
taskData = NULL;
}
//记得先初始化
static T_JZsdkReturnCode TaskMgmt_sample()
{
TaskData* data = (TaskData*)malloc(sizeof(TaskData));
if (data == NULL)
{
//内存注册失败
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}
data->num = 1;
data->str = "A";
T_JZsdkReturnCode ret = TaskManagement_SubmitTask(TaskMgmt_sample_funtion, data);
if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
{
free(data);
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}
return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}
... ...
为方便在多个板子之间移植
sdk包被我分成了多个部分
1、Base文件
不需要依赖任何第三方环境，只需要在linux上跑，同时为其他地方,如module提供延时函数等
2、JZsdk_Normal_Module
功能模组合集，为了移植时不依赖第三方文件或板子环境，使用JZsdk_module_inport.c进行参数提供
当你需要使用第三方参数给module时，你应该把接口写在Module_InPort,后Module内的模块调用Module_Inport
当你需要给第三方参数时
同样应该使用 JZsdk_Module_OutPort.c进行提供
... ...
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <string.h>
#include "JZsdkLib.h"
#include "version_choose.h"
#include "ircut.h"
#include "Megaphone/Megaphone.h"
#include "Gimbal_InAndOut.h"
#include "JZsdk_uart/JZsdk_Uart_Input.h"
#include "BaseConfig.h"
#include "Psdk_UI_io.h"
#include "Lighting_InAndOut.h"
#include "JZsdk_network/JZsdk_network.h"
#include "JZsdk_TaskManagement/TaskManagement.h"
#include "JZsdk_haldata_deal/JZsdk_data_transmisson.h"
#include "MediaProc/MediaProc.h"
#include "UI_control/WidegMgmt/JZsdk_Widget.h"
#if APP_VERSION == APP_PSDK
#include "fc_subscription/test_fc_subscription.h"
#endif
#include "DeviceInfo/DeviceInfo.h"
#if MEGAPHONE_CONFIG_STATUS == VERSION_SWITCH_ON
#include "AudioDeal/AudioDeal.h"
#include "Megaphone/Megaphone.h"
#endif
#if SIDE_LASER_STATUS_ON
#include "SideLaser/SideLaser.h"
#endif
static int Main_WorkMode();
static void *Main_WorkModeTask(void *arg);
static int WorkMode = JZ_FLAGCODE_OFF;
extern int MegaphoneStatusFlag;
static int g_All_filter_Mode = JZ_FLAGCODE_OFF; //用于m30的滤波开关
static int StartupPriorityNum = JZ_FLAGCODE_OFF; //优先启动项值
/*******************
*
* mode get 是未获取 m30滤波开关
* 其他值为set+get
*
* ********************/
T_JZsdkReturnCode Main_M30_all_filter_mode(int *mode)
{
//喊话器功能被打开时
#if MEGAPHONE_CONFIG_STATUS == VERSION_SWITCH_ON
if (*mode == JZ_FLAGCODE_GET)
{
*mode = g_All_filter_Mode;
printf("滤波模式获取%d\n",*mode);
return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}
else if ( (*mode != JZ_FLAGCODE_ON) && (*mode != JZ_FLAGCODE_OFF) )
{
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}
else
{
printf("滤波模式设置%d\n",*mode);
g_All_filter_Mode = *mode;
if (*mode == JZ_FLAGCODE_ON)
{
//先关闭播放
Megaphone_StopPlay(JZ_FLAGCODE_OFF);
//修改滤波
AudioDeal_FilterReset(0x01);
}
else
{
//先关闭播放
Megaphone_StopPlay(JZ_FLAGCODE_OFF);
//修改滤波
AudioDeal_FilterReset(0x00);
}
}
#endif
return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}
/*** ************************* *************************
*
* 判断设备是否可用
* return 0 可用
* return 1 未激活
* return 2 海外版检测到在国外不可用
*
* ******************** ******************************/
int Main_Device_Wheather_Use()
{
//先判断是否有激活
T_JZsdkReturnCode ret = SerialMAT_Get_SerialNumberStatus();
if(ret == 0x02 || ret == 0x03)
{
//未激活 返回1
return 1;
}
// //如果是国外版，判断是否在国内 //以后再单独领出一个模块
if (FIRMWARE_ORIGIN == OVERSEAS_VERSION)
{
#if APP_VERSION == APP_PSDK
//如果处于中国境内
if (Subscription_WhetherInChina() == 1)
{
return 2;
}
#endif
}
return 0;
}
T_JZsdkReturnCode Main_APP_Psdk()
{
//sdklib加载
JZsdk_LibInit();
JZSDK_LOG_INFO("%x,PsdkVersion%x.%x.%x.%x\n",DEVICE_VERSION,MAJOR_VERSION, MINOR_VERSION, MODIFY_VERSION, DEBUG_VERSION);
//引脚初始化
Ircut_Init();
//设备信息初始化
DeviceInfo_Init();
//工作模式设置函数，用于超时，及播放启动语音等
Main_WorkMode();
//外接传输模块
JZsdk_data_transmisson_Receive_Init();
//喊话器功能被打开时
if (MEGAPHONE_CONFIG_STATUS == VERSION_SWITCH_ON)
{
//音频库初始化
AudioDeal_Init();
//
}
if (DEVICE_VERSION == TF_A1)
{
//串口设备1初始化
//JZsdk_Uart_Init(UART_DEV_1);
//串口设备2初始化
JZsdk_Uart_Init(UART_DEV_2);
//喊话器初始化
Megaphone_Init();
//云台初始化
Gimbal_Init();
//灯类初始化
Lighting_Init();
delayMs(1000);
//消息订阅初始化
JZsdk_Uart_Send_MessageSubcription_Control(UART_DEV_2, JZ_FLAGCODE_ON);
}
else if (DEVICE_VERSION == JZ_H1E)
{
//串口设备1初始化
//JZsdk_Uart_Init(UART_DEV_1);
//喊话器初始化
Megaphone_Init();
}
else if (DEVICE_VERSION == JZ_H1T)
{
//串口设备1初始化
//JZsdk_Uart_Init(UART_DEV_1);
//4g设备初始化
JZsdk_Uart_Init(UART_4G);
//喊话器初始化
Megaphone_Init();
//云台初始化
Gimbal_Init();
}
else if (DEVICE_VERSION == JZ_H150S || DEVICE_VERSION == JZ_H150T)
{
//串口设备1初始化
// JZsdk_Uart_Init(UART_DEV_1);
if (DEVICE_VERSION == JZ_H150T)
{
//4g设备初始化
JZsdk_Uart_Init(UART_4G);
}
//喊话器初始化
Megaphone_Init();
//云台初始化
Gimbal_Init();
//相机初始化
MediaProc_Init();
}
else if (DEVICE_VERSION == JZ_H10)
{
//串口设备1初始化
// JZsdk_Uart_Init(UART_DEV_1);
//喊话器初始化
Megaphone_Init();
//云台初始化
Gimbal_Init();
}
else if (DEVICE_VERSION == JZ_H10T)
{
//串口设备1初始化
//JZsdk_Uart_Init(UART_DEV_1);
//4g设备初始化
JZsdk_Uart_Init(UART_4G);
//喊话器初始化
Megaphone_Init();
//云台初始化
Gimbal_Init();
}
else if (DEVICE_VERSION == JZ_U3)
{
//串口设备1初始化
//JZsdk_Uart_Init(UART_DEV_1);
//串口设备2初始化
JZsdk_Uart_Init(UART_DEV_2);
//喊话器初始化
Megaphone_Init();
//云台初始化
Gimbal_Init();
//灯类初始化
Lighting_Init();
delayMs(1000);
//消息订阅初始化
JZsdk_Uart_Send_MessageSubcription_Control(UART_DEV_2, JZ_FLAGCODE_ON);
}
else if (DEVICE_VERSION == JZ_U3S)
{
//串口设备1初始化
//JZsdk_Uart_Init(UART_DEV_1);
//串口设备2初始化
JZsdk_Uart_Init(UART_DEV_2);
//喊话器初始化
Megaphone_Init();
//云台初始化
Gimbal_Init();
//灯类初始化
Lighting_Init();
//侧边激光初始化
SideLaser_Init();
delayMs(1000);
//消息订阅初始化
JZsdk_Uart_Send_MessageSubcription_Control(UART_DEV_2, JZ_FLAGCODE_ON);
}
else if (DEVICE_VERSION == JZ_C1)
{
//引脚初始化
Ircut_Init();
//视频流模块初始化
MediaProc_Init();
}
//初始化控件
JZSDK_WidgetMgMT_Init();
//初始化app模式
JZsdk_Set_Psdk_UIcontrol_UseFlag(1);
Main_WorkModeSet(JZ_FLAGCODE_ON);
}
int Main_APP_Uart()
{
//lib库初始化
JZsdk_LibInit();
JZSDK_LOG_INFO("%x,UartVersion%x.%x.%x.%x\n",DEVICE_VERSION,MAJOR_VERSION, MINOR_VERSION, MODIFY_VERSION, DEBUG_VERSION);
//引脚初始化
Ircut_Init();
//设备信息初始化
DeviceInfo_Init();
//工作模式设置函数，用于超时，及播放启动语音等
Main_WorkMode();
//喊话器功能被打开时
if (MEGAPHONE_CONFIG_STATUS == VERSION_SWITCH_ON)
{
//音频库初始化
AudioDeal_Init();
//
}
if (DEVICE_VERSION == JZ_H1E)
{
//串口设备1初始化
JZsdk_Uart_Init(UART_DEV_1);
//喊话器初始化
Megaphone_Init();
}
if (DEVICE_VERSION == JZ_H1T)
{
//串口设备1初始化
JZsdk_Uart_Init(UART_DEV_1);
//4g设备初始化
JZsdk_Uart_Init(UART_4G);
//喊话器初始化
Megaphone_Init();
//云台初始化
Gimbal_Init();
// //测试增加选项
// //开启循环
// JZsdk_Uart_audio_PlayLoop(UART_DEV_1, 1);
// //设置音量
// JZsdk_Uart_Set_Volume(UART_DEV_1, 50);
}
if (DEVICE_VERSION == JZ_H150S || DEVICE_VERSION == JZ_H150T)
{
//串口设备1初始化
JZsdk_Uart_Init(UART_DEV_1);
//网口初始化
JZsdk_NetWork_Init();
if (DEVICE_VERSION == JZ_H150T)
{
//4g设备初始化
JZsdk_Uart_Init(UART_4G);
}
//云台初始化
Gimbal_Init();
//相机初始化
MediaProc_Init();
//喊话器初始化
Megaphone_Init();
}
if (DEVICE_VERSION == JZ_H10)
{
//串口设备1初始化
JZsdk_Uart_Init(UART_DEV_1);
//H10和10t固定打开滤波
int filter_mode = JZ_FLAGCODE_ON;
Main_M30_all_filter_mode(&filter_mode);
//喊话器初始化
Megaphone_Init();
//云台初始化
Gimbal_Init();
}
if (DEVICE_VERSION == JZ_H10T)
{
//串口设备1初始化
JZsdk_Uart_Init(UART_DEV_1);
//4g设备初始化
JZsdk_Uart_Init(UART_4G);
//H10和10t固定打开滤波
int filter_mode = JZ_FLAGCODE_ON;
Main_M30_all_filter_mode(&filter_mode);
//喊话器初始化
Megaphone_Init();
//云台初始化
Gimbal_Init();
}
if (DEVICE_VERSION == JZ_U3)
{
//串口设备1初始化
JZsdk_Uart_Init(UART_DEV_1);
//串口设备2初始化
JZsdk_Uart_Init(UART_DEV_2);
//喊话器初始化
Megaphone_Init();
//云台初始化
Gimbal_Init();
//灯类初始化
Lighting_Init();
delayMs(1000);
//消息订阅初始化
JZsdk_Uart_Send_MessageSubcription_Control(UART_DEV_2, JZ_FLAGCODE_ON);
// //测试需要开启亮度
// JZsdk_Uart_SearchLight_Control(UART_DEV_1, 1);
// JZsdk_Uart_SearchLight_Lumen(UART_DEV_1, 20, 20);
}
if (DEVICE_VERSION == TF_A1)
{
//串口设备1初始化
JZsdk_Uart_Init(UART_DEV_1);
//串口设备2初始化
JZsdk_Uart_Init(UART_DEV_2);
//喊话器初始化
Megaphone_Init();
//云台初始化
Gimbal_Init();
//消息订阅初始化
JZsdk_Uart_Send_MessageSubcription_Control(UART_DEV_2, JZ_FLAGCODE_ON);
}
}
int Main_TestAPP()
{
//串口设备1初始化
JZsdk_Uart_Init(UART_DEV_1);
}
//JZ_FLAGCODE_GET为返回工作值，其他值为设置
int Main_WorkModeSet(int mode)
{
if (mode == JZ_FLAGCODE_GET)
{
return WorkMode;
}
WorkMode = mode;
//如果工作模式被打开
if ( (WorkMode == JZ_FLAGCODE_ON) && (APP_VERSION == APP_UART) )
{
int flag = 0x00;
Main_StartupPriority(&flag);
}
return WorkMode;
}
static int Main_GetStartupPriorityStatus()
{
if( JZsdk_check_file_exists("/root/Uart_connected") == JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
{
StartupPriorityNum = 0x00;
}
else //目前只有psdk和串口的优先区分
{
StartupPriorityNum = 0x01;
}
return StartupPriorityNum;
}
//设置优先启动项
//0x00 优先启动串口程序
//0x01 优先大疆PSDK
//
T_JZsdkReturnCode Main_StartupPriority(int *choose)
{
if (*choose == JZ_FLAGCODE_GET)
{
printf("获取优先启动项\n");
//1、查询本地的是否存在优先启动值
Main_GetStartupPriorityStatus();
//2、返回优先启动值
*choose = StartupPriorityNum;
return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}
else
{
//1、设置本地的版本号
if (*choose == 0x00)
{
//增加uart连接标志
if(JZsdk_create_file("/root/Uart_connected") != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
{
JZSDK_LOG_ERROR("优先启动Uart模式失败");
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}
return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}
else if (*choose == 0x01)
{
//连接后清除串口标志
if(JZsdk_delete_file("/root/Uart_connected") != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
{
JZSDK_LOG_ERROR("优先启动psdk模式失败");
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}
return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}
else
{
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}
}
}
static int Main_WorkMode()
{
pthread_t work_mode_task;
pthread_attr_t task_attribute; //线程属性
pthread_attr_init(&task_attribute); //初始化线程属性
pthread_attr_setdetachstate(&task_attribute, PTHREAD_CREATE_DETACHED); //设置线程属性
int timer = pthread_create(&work_mode_task,&task_attribute,Main_WorkModeTask,NULL); //线程
if(timer != 0)
{
printf("创建计时线程失败！\n");
}
}
static void *Main_WorkModeTask(void *arg)
{
//计时flag
int i=0;
printf("进入串口等待函数\n");
int start_voice_flag = JZ_FLAGCODE_OFF;
#if APP_VERSION == APP_UART
for (i = 0; i < 60; i++)
{
#if CONNECTION_TIMED_OUT == VERSION_SWITCH_OFF
break;
#endif
delayMs(1000);//延迟一秒钟
printf("计数%d\n",i);
if (start_voice_flag == JZ_FLAGCODE_OFF && MegaphoneStatusFlag == JZ_FLAGCODE_ON)
{
start_voice_flag = JZ_FLAGCODE_ON;
Start_voice();
}
if (WorkMode == JZ_FLAGCODE_ON)
{
printf("串口连接成功,进入串口模式\n");
printf("连接花费时间%i秒\n",i);
i = 0;
break;
}
}
if(i==60 && WorkMode == JZ_FLAGCODE_OFF && CONNECTION_TIMED_OUT == VERSION_SWITCH_ON)
{
printf("串口连接超时,回到连接psdk");
exit(0);
}
#elif APP_VERSION == APP_PSDK
#endif
#if MEGAPHONE_CONFIG_STATUS == VERSION_SWITCH_ON
while (1)
{
if (start_voice_flag == JZ_FLAGCODE_OFF && MegaphoneStatusFlag == JZ_FLAGCODE_ON)
{
start_voice_flag = JZ_FLAGCODE_ON;
Start_voice();
}
//如果开启工作模式已经打开，且喊话模块已经初始化完毕，播报启动完成
if (WorkMode == JZ_FLAGCODE_ON && MegaphoneStatusFlag == JZ_FLAGCODE_ON && start_voice_flag == JZ_FLAGCODE_ON)
{
Start_up_and_broadcast_voice();
break;
}
delayMs(100);
}
#endif
}
... ...
/**
********************************************************************
* @file
*
*
*********************************************************************
*/
/* Define to prevent recursive inclusion 避免重定义 -------------------------------------*/
#ifndef BASECONFIG_H
#define BASECONFIG_H
/* Includes ------------------------------------------------------------------*/
#include "version_choose.h"
#include "JZsdkLib.h"
#ifdef __cplusplus
extern "C" {
#endif
/* Exported constants --------------------------------------------------------*/
/* 常亮定义*/
#define DEVICE_PSDK 0x1000 //psdk功能
#define UART_4G 0x1001 //4G功能
#define UART_DEV_1 0x1002 //1号设备功能
#define UART_DEV_2 0x1003 //2号设备功能
#define UART_DEV_3 0x1004 //3号设备功能
#define UART_DEV_4 0x1005 //4号设备功能
#define UART_DEV_5 0x1006 //5号设备功能
#define UART_USB_1 0x1100 //usb设备
#define UART_USB_2 0x1101 //usb设备
#define UART_USB_3 0x1102 //usb设备
#define UART_USB_4 0x1103 //usb设备
#define UART_USB_5 0x1104 //usb设备
#define HAL_DATA_TRANSMISSION 0x1200 //hal定制的特殊数据传播
#define COMBINE_DEVICE 0x1998 //组合设备
#define NO_SPECIFIED 0x1999 //无制定设备
//展架通讯串口
#if DEVICE_VERSION == JZ_H150S || DEVICE_VERSION == JZ_H150T
#define UART_DEV1_NUM "/dev/ttyUSB0"
#define UART_DEV1_BITRATE (115200)
#define UART_DEV2_NUM NULL
#define UART_DEV2_BITRATE (0)
#define COMM_4G_UART_NUM "/dev/ttyS1"
#define COMM_4G_UART_BITRATE (115200)
#define GIMBAL_UART_NUM "/dev/ttyS2"
#define GIMBAL_UART_BITRATE (115200)
#define NET_WORK_IPADDR "192.168.5.3"
#define NET_WORK_TARGET_IPADDR "192.168.5.10"
#define NET_WORK_NETMASK "255.255.255.0"
#elif DEVICE_VERSION == JZ_H1E
#define UART_DEV1_NUM "/dev/ttyS1"
#define UART_DEV1_BITRATE (115200)
#define UART_DEV2_NUM NULL
#define UART_DEV2_BITRATE (0)
#define COMM_4G_UART_NUM NULL
#define COMM_4G_UART_BITRATE (0)
#define GIMBAL_UART_NUM NULL
#define GIMBAL_UART_BITRATE (0)
#define NET_WORK_IPADDR NULL
#define NET_WORK_TARGET_IPADDR NULL
#define NET_WORK_NETMASK NULL
#elif DEVICE_VERSION == JZ_H1T
#define UART_DEV1_NUM "/dev/ttyS2"
#define UART_DEV1_BITRATE (115200)
#define UART_DEV2_NUM NULL
#define UART_DEV2_BITRATE (0)
#define COMM_4G_UART_NUM "/dev/ttyS1"
#define COMM_4G_UART_BITRATE (115200)
#define GIMBAL_UART_NUM NULL
#define GIMBAL_UART_BITRATE (0)
#define NET_WORK_IPADDR NULL
#define NET_WORK_TARGET_IPADDR NULL
#define NET_WORK_NETMASK NULL
#elif DEVICE_VERSION == JZ_H10
#define UART_DEV1_NUM "/dev/ttyUSB0"
#define UART_DEV1_BITRATE (115200)
#define UART_DEV2_NUM NULL
#define UART_DEV2_BITRATE (0)
#define COMM_4G_UART_NUM NULL
#define COMM_4G_UART_BITRATE (0)
#define GIMBAL_UART_NUM NULL
#define GIMBAL_UART_BITRATE (0)
#define NET_WORK_IPADDR NULL
#define NET_WORK_TARGET_IPADDR NULL
#define NET_WORK_NETMASK NULL
#elif DEVICE_VERSION == JZ_H10T
#define UART_DEV1_NUM "/dev/ttyS2"
#define UART_DEV1_BITRATE (115200)
#define UART_DEV2_NUM NULL
#define UART_DEV2_BITRATE (0)
#define COMM_4G_UART_NUM "/dev/ttyS1"
#define COMM_4G_UART_BITRATE (115200)
#define GIMBAL_UART_NUM NULL
#define GIMBAL_UART_BITRATE (0)
#define NET_WORK_IPADDR NULL
#define NET_WORK_TARGET_IPADDR NULL
#define NET_WORK_NETMASK NULL
#elif DEVICE_VERSION == JZ_U3
#define UART_DEV1_NUM "/dev/ttyS1"
#define UART_DEV1_BITRATE (115200)
#define UART_DEV2_NUM "/dev/ttyS2"
#define UART_DEV2_BITRATE (115200)
#define COMM_4G_UART_NUM NULL
#define COMM_4G_UART_BITRATE (0)
#define GIMBAL_UART_NUM NULL
#define GIMBAL_UART_BITRATE (0)
#define NET_WORK_IPADDR NULL
#define NET_WORK_TARGET_IPADDR NULL
#define NET_WORK_NETMASK NULL
#elif DEVICE_VERSION == JZ_U3S
#define UART_DEV1_NUM "/dev/ttyS1"
#define UART_DEV1_BITRATE (115200)
#define UART_DEV2_NUM "/dev/ttyS2"
#define UART_DEV2_BITRATE (115200)
#define COMM_4G_UART_NUM NULL
#define COMM_4G_UART_BITRATE (0)
#define GIMBAL_UART_NUM NULL
#define GIMBAL_UART_BITRATE (0)
#define NET_WORK_IPADDR NULL
#define NET_WORK_TARGET_IPADDR NULL
#define NET_WORK_NETMASK NULL
#elif DEVICE_VERSION == JZ_U3D
#define UART_DEV1_NUM "/dev/ttyS1"
#define UART_DEV1_BITRATE (115200)
#define UART_DEV2_NUM "/dev/ttyS2"
#define UART_DEV2_BITRATE (115200)
#define COMM_4G_UART_NUM NULL
#define COMM_4G_UART_BITRATE (0)
#define GIMBAL_UART_NUM NULL
#define GIMBAL_UART_BITRATE (0)
#define NET_WORK_IPADDR NULL
#define NET_WORK_TARGET_IPADDR NULL
#define NET_WORK_NETMASK NULL
#elif DEVICE_VERSION == TF_A1
#define UART_DEV1_NUM "/dev/ttyS2"
#define UART_DEV1_BITRATE (115200)
#define UART_DEV2_NUM "/dev/ttyS1"
#define UART_DEV2_BITRATE (115200)
#define COMM_4G_UART_NUM NULL
#define COMM_4G_UART_BITRATE (0)
#define GIMBAL_UART_NUM NULL
#define GIMBAL_UART_BITRATE (0)
#define NET_WORK_IPADDR NULL
#define NET_WORK_TARGET_IPADDR NULL
#define NET_WORK_NETMASK NULL
#elif DEVICE_VERSION == JZ_C1
#define UART_DEV1_NUM "/dev/ttyUSB0"
#define UART_DEV1_BITRATE (115200)
#define UART_DEV2_NUM NULL
#define UART_DEV2_BITRATE (115200)
#define COMM_4G_UART_NUM NULL
#define COMM_4G_UART_BITRATE (0)
#define GIMBAL_UART_NUM NULL
#define GIMBAL_UART_BITRATE (0)
#define NET_WORK_IPADDR NULL
#define NET_WORK_TARGET_IPADDR NULL
#define NET_WORK_NETMASK NULL
#else
#define UART_DEV1_NUM NULL
#define UART_DEV1_BITRATE (0)
#define UART_DEV2_NUM NULL
#define UART_DEV2_BITRATE (0)
#define COMM_4G_UART_NUM NULL
#define COMM_4G_UART_BITRATE (0)
#define GIMBAL_UART_NUM NULL
#define GIMBAL_UART_BITRATE (0)
#define NET_WORK_IPADDR NULL
#define NET_WORK_TARGET_IPADDR NULL
#define NET_WORK_NETMASK NULL
#endif
/* Exported types ------------------------------------------------------------*/
/* Exported functions --------------------------------------------------------*/
int Main_WorkModeSet(int mode);
int Main_APP_Uart();
T_JZsdkReturnCode Main_APP_Psdk();
int Main_TestAPP();
int Main_Device_Wheather_Use();
T_JZsdkReturnCode Main_M30_all_filter_mode(int *mode);
T_JZsdkReturnCode Main_StartupPriority(int *choose);
T_JZsdkReturnCode Main_SetDeviceName(unsigned int Port, int g_DeviceID);
#ifdef __cplusplus
}
#endif
#endif
... ...
/* ********************************************************************
*
* 用来规范version_choose的参数
*
***********************************************/
#ifndef CONFIG_PARAMS_H
#define CONFIG_PARAMS_H
//特殊版本号
#define SPECIAL_NORMAL 0x01
#define SPECIAL_DAOTONG 0x02
//软件模式
#define APP_PSDK 0x01 //psdk设备
#define APP_UART 0x02 //串口设备
#define APP_TEST 0x03 //测试设备
//平台选择
#define PLATFORM_H3 0x01
#define PLATFORM_V3S 0x02
//固件属地
#define OVERSEAS_VERSION 0x01 //海外版
#define DOMESTIC_VERSION 0x02 //国内版
//音频滤波的方式
//目前只有和h10使用带阻滤波
#define DIRECTED_STOPBAND_FILTERING 0x10001 //带阻滤波
#define HIGH_PASS_FILTERING 0x10002 //高通滤波
#define INTERGRATED_FILTERING_1 0x10003 //综合滤波1代
//加载开关
#define VERSION_SWITCH_ON 0x0001
#define VERSION_SWITCH_OFF 0x0000
//设备选择
#define JZ_H1E 0x0011
#define JZ_H1T 0x0016
#define JZ_U3 0x0017
#define JZ_U3S 0x0018
#define JZ_U3D 0x0019
#define JZ_H150S 0x0013
#define JZ_H150T 0x0015
#define JZ_H10 0x0012
#define JZ_H10T 0x0014
#define TF_A1 0x1010
#define JZ_C1 0x1011
#endif
... ...
/* ********************************************************************
*
* 用于确认对应设备的选择
*
***********************************************/
#ifndef VERSION_CHOOSE_H
#define VERSION_CHOOSE_H
#include "./ConfigParams.h"
//1~10行 除了D可以修改版本选择 禁止动任何东西
#define DEVICE_VERSION JZ_H1T
//禁止修改行 选择是串口程序 还是 psdk程序
#define APP_VERSION APP_UART
//禁止修改行 板子型号
#define PLATFORM_VERSION PLATFORM_V3S
//禁止修改行 串口连接程序的软件版本号
#define MAJOR_VERSION 0x00
#define MINOR_VERSION 0x00
#define MODIFY_VERSION 0x02
#define DEBUG_VERSION 0x04
//禁止修改行 滤波方式
#define FILTERING_TYPE HIGH_PASS_FILTERING
//禁止修改行固件属地 目前 国内版/海外版
#define FIRMWARE_ORIGIN DOMESTIC_VERSION
//禁止修改行指定特殊固件
#define SPECIAL_VERSION SPECIAL_NORMAL
//禁止修改行 全志编解码库
#define ALLWINNER_CEDAR VERSION_SWITCH_OFF
//禁止修改行 是否开启连接超时
#define CONNECTION_TIMED_OUT VERSION_SWITCH_OFF
//这个开关可以方便日常代码编写的跳转功能
#ifdef COMPILE_MODE_MODULE
//是否开启喊话器功能
#ifdef MACRO_MEGAPHONE_MODULE
#define MEGAPHONE_CONFIG_STATUS VERSION_SWITCH_ON
#else
#define MEGAPHONE_CONFIG_STATUS VERSION_SWITCH_OFF
#endif
//是否开启媒体功能
#ifdef MACRO_MEDIA_PROC_MODULE
#define MEDIA_PROC_CONFIG_STATUS VERSION_SWITCH_ON
#else
#define MEDIA_PROC_CONFIG_STATUS VERSION_SWITCH_OFF
#endif
//是否开启红外相机功能
#ifdef MACRO_IRC_MODULE
#define IRC_CONFIG_STATUS VERSION_SWITCH_ON
#else
#define IRC_CONFIG_STATUS VERSION_SWITCH_OFF
#endif
//是否加载usb模块
#ifdef MACRO_USB_MODULE
#define USB_CONFIG_STATUS VERSION_SWITCH_ON
#else
#define USB_CONFIG_STATUS VERSION_SWITCH_OFF
#endif
//是否加载RTK_MPP模块
#ifdef MACRO_RTK_MPP_MODULE
#define RTK_MPP_STATUS VERSION_SWITCH_ON
#else
#define RTK_MPP_STATUS VERSION_SWITCH_OFF
#endif
//是否加载WIRINGPI模块
#ifdef MACRO_WIRINGPI_MODULE
#define WIRINGPI_STATUS VERSION_SWITCH_ON
#else
#define WIRINGPI_STATUS VERSION_SWITCH_OFF
#endif
//是否加载侧边激光模块
#ifdef MACRO_SIDE_LASER_MODULE
#define SIDE_LASER_STATUS_ON
#endif
#else
//是否开启喊话器功能
#define MEGAPHONE_CONFIG_STATUS VERSION_SWITCH_ON
//是否开启媒体管理功能
#define MEDIA_PROC_CONFIG_STATUS VERSION_SWITCH_ON
//是否开启红外相机功能
#define IRC_CONFIG_STATUS VERSION_SWITCH_ON
//是否加载usb模块
#define USB_CONFIG_STATUS VERSION_SWITCH_ON
//是否加载RTK_MPP模块
#define RTK_MPP_STATUS VERSION_SWITCH_ON
//是否加载WIRINGPI模块
#define WIRINGPI_STATUS VERSION_SWITCH_ON
//是否加载侧边激光模块
#define SIDE_LASER_STATUS_ON
#endif
#endif
\ No newline at end of file
... ...
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <pthread.h>
#include "JZsdk_TaskManagement/TaskManagement.h"
#include "JZsdk_Base/JZsdk_Code/JZsdk_Code.h"
#include "JZsdk_Base/JZsdk_FrameComparsion/JZsdk_FrameComparsion.h"
#include "JZsdk_uart/JZsdk_Uart_UartDeal.h"
#include "BaseConfig.h"
typedef struct
{
char Message[1024]; // 传递的字符串
int MessageLength; // 字符串的长度
int ResLen; //剩余长度
pthread_mutex_t WriteMutex; // 互斥锁
pthread_mutex_t ReadMutex; // 互斥锁
} JZsdk_data_transmisson;
#define BUFFER_SIZE 128*1024 // 128k的缓冲区
static unsigned char DataTransmissonBuffer[BUFFER_SIZE]; //data_transmisson的被动接收缓冲区
static int buffer_head = 0; //缓冲区的写入标志位
static int buffer_end = 0; //缓冲区的写出标志位
static void *JZsdk_hal_data_rece(void *arg);
static void *JZsdk_hal_data_deal(void *arg);
static pthread_mutex_t DataTransmissonLock;
static int DataTransFlag = JZ_FLAGCODE_OFF; //用于判断初始化完成
/****************
*
* 计算缓冲区剩余容量
*
* **************/
static int JZsdk_data_transmisson_buffer_GetEmpty()
{
int empty;
//后续要找办法处理数据段长度的问题，目前先用大空间存储
//头在尾后面 说明目前数组缓冲区组成为 空数据 尾巴 实数据 头部 空数据
if (buffer_head >= buffer_end)
{
empty = BUFFER_SIZE - (buffer_head - buffer_end);
}
//尾在头后面 说明目前数组缓冲区组成为 实数据 头部 空数据 尾巴 实数据
else if (buffer_head < buffer_end)
{
empty = (buffer_end - buffer_head);
}
return empty;
}
/****************
*
* 池满判断
*
* **************/
static int JZsdk_data_transmisson_buffer_WriteDataEndReset() //池满判断
{
if (buffer_end >= BUFFER_SIZE)
{
buffer_end = 0;
}
}
static int JZsdk_data_transmisson_buffer_WriteDataHeadReset() //池满判断
{
if (buffer_head >= BUFFER_SIZE)
{
buffer_head = 0;
}
}
/******************************************************************
初始化hal口数据接收
******************************************************************/
int JZsdk_data_transmisson_Receive(unsigned char *data, int data_len)
{
//初始化完成前不能使用
if (DataTransFlag == JZ_FLAGCODE_OFF)
{
return 0 ;
}
int temp_lenth = 0; //临时长度;
//后续要增加缓冲区大小判断，避免出现问题
//计算当前缓冲区的剩余容量
int buffer_empty = JZsdk_data_transmisson_buffer_GetEmpty();
if (buffer_empty < data_len)
{
data_len = buffer_empty;
}
// 在写入解码前加锁
pthread_mutex_lock(&DataTransmissonLock);
while( (data_len - temp_lenth) > 0)
{
DataTransmissonBuffer[buffer_head] = data [temp_lenth];
temp_lenth+=1;
buffer_head+=1; //池尾后移一组
JZsdk_data_transmisson_buffer_WriteDataHeadReset() ; //池满判断
}
// 在解码数据后解锁
pthread_mutex_unlock(&DataTransmissonLock);
}
/******************************************************************
初始化hal口数据接收初始化
******************************************************************/
int JZsdk_data_transmisson_Receive_Init()
{
int ret = 0;
pthread_t Uart_rece_task;
pthread_attr_t task_attribute; // 线程属性
pthread_attr_init(&task_attribute); // 初始化线程属性
pthread_attr_setdetachstate(&task_attribute, PTHREAD_CREATE_DETACHED); // 设置线程属性
JZsdk_data_transmisson *parameter = (JZsdk_data_transmisson *)malloc(sizeof(JZsdk_data_transmisson));
parameter->MessageLength = 0;
memset(parameter->Message, 0, sizeof(parameter->Message));
pthread_mutex_init(&DataTransmissonLock, NULL); //初始化锁
pthread_mutex_init(&parameter->WriteMutex, NULL);
pthread_mutex_init(&parameter->ReadMutex, NULL);
// 创建串口数据接收线程
pthread_t receiveThread;
pthread_t SerialDealThread;
pthread_attr_t task_attribute1; // 线程属性
pthread_attr_t task_attribute2; // 线程属性
pthread_attr_setdetachstate(&task_attribute1, PTHREAD_CREATE_DETACHED); // 设置线程分离属性
pthread_attr_setdetachstate(&task_attribute2, PTHREAD_CREATE_DETACHED); // 设置线程分离属性
pthread_attr_init(&task_attribute1);
pthread_attr_init(&task_attribute2);
if (pthread_create(&receiveThread, &task_attribute1, JZsdk_hal_data_rece, parameter) != 0)
{
JZSDK_LOG_ERROR("Failed to create receive thread");
return 1;
}
// 创建串口数据处理线程
if (pthread_create(&SerialDealThread, &task_attribute2, JZsdk_hal_data_deal, parameter) != 0)
{
JZSDK_LOG_ERROR("Failed to create receive thread");
return 1;
}
DataTransFlag = JZ_FLAGCODE_ON;
JZSDK_LOG_INFO("hal数据传输模块初始化完成");
}
/***
*
* 数据读取函数
* 获取数据的数组str
* 最多可以获取max_get_len的长度
* ***/
static int Buffer_get_data(unsigned char *str, int max_get_len)
{
int return_len; //返回的长度
//头在尾后面 说明目前数组缓冲区组成为 空数据 尾巴 实数据 头部 空数据
if (buffer_head >= buffer_end)
{
if (max_get_len >= (buffer_head-buffer_end))
{
return_len = (buffer_head-buffer_end);
memcpy(str, &DataTransmissonBuffer[buffer_end], return_len);
buffer_end +=return_len;
JZsdk_data_transmisson_buffer_WriteDataEndReset();
return return_len;
}
else
{
return_len = max_get_len;
memcpy(str, &DataTransmissonBuffer[buffer_end], return_len);
buffer_end +=return_len;
JZsdk_data_transmisson_buffer_WriteDataEndReset();
return return_len;
}
}
//尾在头后面 说明目前数组缓冲区组成为 实数据 头部 空数据 尾巴 实数据
else if (buffer_head < buffer_end)
{
if (max_get_len >= ( (BUFFER_SIZE-buffer_end) + buffer_head) )
{
return_len = ( (BUFFER_SIZE-buffer_end) + buffer_head);
memcpy(str, &DataTransmissonBuffer[buffer_end], (BUFFER_SIZE-buffer_end));
memcpy(str + (BUFFER_SIZE-buffer_end), &DataTransmissonBuffer[0], buffer_head);
buffer_end = buffer_head;
JZsdk_data_transmisson_buffer_WriteDataEndReset();
return return_len;
}
else if(max_get_len < ( (BUFFER_SIZE-buffer_end) + buffer_head) )
{
// 实数据 头部 空数据 尾巴 大于接收区的实数据
if (max_get_len <= (BUFFER_SIZE-buffer_end) )
{
return_len = max_get_len;
memcpy(str, &DataTransmissonBuffer[buffer_end], return_len);
buffer_end+=max_get_len;
JZsdk_data_transmisson_buffer_WriteDataEndReset();
return return_len;
}
// 实数据 头部 空数据 尾巴 小于接收区的实数据
else
{
return_len = max_get_len;
memcpy(str, &DataTransmissonBuffer[buffer_end], (BUFFER_SIZE-buffer_end));
memcpy(str, &DataTransmissonBuffer[0], (max_get_len - (BUFFER_SIZE-buffer_end) ) );
buffer_end = (max_get_len - (BUFFER_SIZE-buffer_end) );
JZsdk_data_transmisson_buffer_WriteDataEndReset();
return return_len;
}
}
}
return return_len;
}
/***
*
* 数据接收线程
*
* ***/
static void *JZsdk_hal_data_rece(void *arg)
{
JZsdk_data_transmisson *args = (JZsdk_data_transmisson *)arg;
memset(args->Message, 0, sizeof(args->Message)); // 清空接收数组
args->ResLen = 0;
args->MessageLength = 0;
int data_len;
int data_len2;
while (1)
{
// 检查fs_read套接字是否有数据
if (buffer_head == buffer_end)
{
delayMs(1);
// 超时
continue;
}
// 如果有数据就加锁
pthread_mutex_lock(&args->WriteMutex);
// 读取串口内容
int bytesRead = Buffer_get_data(&(args->Message[args->ResLen]), (sizeof(args->Message) - args->ResLen));
printf("bytesRead %d\n",bytesRead);
if (bytesRead > 0)
{
args->MessageLength = args->ResLen + bytesRead;
// data_len+=bytesRead;
// data_len2+=args->MessageLength;
// printf("当前接收长度%d bytesRead%d bmessage%d reslen%d\n",data_len,bytesRead,data_len2,args->ResLen);
// JZSDK_LOG_INFO("从串口读取到,长度%d",(args->MessageLength-args->ResLen));
// for (int i = 0; i < (args->MessageLength-args->ResLen); i++)
// {
// JZSDK_LOG_OUTPUTHEX("%s",&args->Message[i+args->ResLen]);
// }
args->ResLen = 0;
}
else if (bytesRead == 0)
{
// 串口关闭或者无数据可读
JZSDK_LOG_ERROR("hal数据传输,读取数据为空");
args->MessageLength = 0;
args->ResLen = 0;
memset(&(args->Message[0]), 0, sizeof(args->Message));
}
else
{
// 读取错误发生
JZSDK_LOG_ERROR("hal数据传输读取错误");
args->MessageLength = 0;
args->ResLen = 0;
memset(&(args->Message[0]), 0, sizeof(args->Message));
}
// 通知线程
pthread_mutex_unlock(&args->ReadMutex); // 解锁
delayMs(3); // 加多了可能导致实时播放难恢复,以及声音间隔 3ms32字节 会向上约1个3ms opus一帧80字节
}
}
/***
*
* 串口处理线程
*
* ***/
// 串口数据处理线程函数
static void *JZsdk_hal_data_deal(void *arg)
{
JZsdk_data_transmisson *args = (JZsdk_data_transmisson *)arg;
static int ResidualLength = 0; // 未处理数据长度
while (1)
{
// 加锁
pthread_mutex_lock(&args->ReadMutex);
// data_len+=args->MessageLength;
// printf("当前处理长度%d\n",data_len);
if (args->MessageLength > 0)
{
//清除错误的多余半帧
//前面有帧的长度
if(args->ResLen != 0)
{
//存在第一帧，同时第二轮的数据开头是帧头，则清空前半段第一帧
if ( (args->Message[args->ResLen ] == 0x5A)
&& (args->Message[args->ResLen + 1] == 0x5A)
&& (args->Message[args->ResLen + 2] == 0x77) )
{
int temp_num;
temp_num = args->MessageLength - args->ResLen;
if (temp_num < 0)
{
temp_num = 0;
}
memcpy(args->Message, &(args->Message[args->ResLen]), temp_num);
memset(&args->Message[temp_num], 0, (args->MessageLength - temp_num));
args->MessageLength = temp_num;
args->ResLen = 0;
JZSDK_LOG_ERROR("串口上一帧为不完全帧，舍弃该帧操作");
}
}
// 处理数据
ResidualLength = UartDeal_Recv_interface(1,HAL_DATA_TRANSMISSION, args->Message, args->MessageLength);
//如果还有剩余的长度
if (ResidualLength != 0)
{
memcpy(args->Message, &(args->Message[args->MessageLength - ResidualLength]), ResidualLength);
memset(&(args->Message[ResidualLength]), 0, (sizeof(args->Message) - ResidualLength));
args->MessageLength = 0;
args->ResLen = ResidualLength;
}
else
{
memset(args->Message, 0, sizeof(args->Message));
args->MessageLength = 0;
args->ResLen = 0;
}
}
else
{
memset(args->Message, 0, sizeof(args->Message));
args->MessageLength = 0;
args->ResLen = 0;
}
pthread_mutex_unlock(&args->WriteMutex); // 解锁
}
}
... ...
/**
********************************************************************
* @file JZsdk_data_transmisson.h
* JZsdk_data_transmisson的头文件
*
*********************************************************************
*/
/* Define to prevent recursive inclusion 避免重定义 -------------------------------------*/
#ifndef JZSDK_DATA_TRANS_MISSION_H
#define JZSDK_DATA_TRANS_MISSION_H
/* Includes ------------------------------------------------------------------*/
#ifdef __cplusplus
extern "C" {
#endif
/* Exported constants --------------------------------------------------------*/
/* 常亮定义*/
#include "JZsdk_Base/JZsdk_Code/JZsdk_Code.h"
/* Exported types ------------------------------------------------------------*/
/* Exported functions --------------------------------------------------------*/
int JZsdk_data_transmisson_Receive_Init();
int JZsdk_data_transmisson_Receive(unsigned char *data, int data_len);
#ifdef __cplusplus
}
#endif
#endif
... ...
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <termios.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "BaseConfig.h"
#include "version_choose.h"
#include "JZsdkLib.h"
#include "./JZsdk_network.h"
#define LINUX_CMD_STR_MAX_SIZE (128)
#define LINUX_NETWORK_DEV "eth0"
#define UDP_SERVER_PORT (23003)
#define MAX_SEND_FRAME_LENTH (60000)
#define JZSDK_UTIL_MIN(a, b) (((a) < (b)) ? (a) : (b))
static int udp_socket = 0;
static struct sockaddr_in udp_server_addr;
static int NetworkMode = JZ_FLAGCODE_OFF; //网络模式
T_JZsdkReturnCode JZsdk_NetWork_Init()
{
T_JZsdkReturnCode ret;
char cmdStr[LINUX_CMD_STR_MAX_SIZE];
if (NET_WORK_IPADDR == NULL || NET_WORK_NETMASK == NULL)
{
JZSDK_LOG_ERROR("无网络参数配置");
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}
//1、打开网卡设备
memset(cmdStr, 0, sizeof(cmdStr));
snprintf(cmdStr, sizeof(cmdStr), "ifconfig %s up", LINUX_NETWORK_DEV);
ret = system(cmdStr);
if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
JZSDK_LOG_ERROR("Can't open the network."
"Probably the program not execute with root permission."
"Please use the root permission to execute the program.");
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}
//2、打开网络
memset(cmdStr, 0, sizeof(cmdStr));
snprintf(cmdStr, sizeof(cmdStr), "ifconfig %s %s netmask %s", LINUX_NETWORK_DEV, NET_WORK_IPADDR, NET_WORK_NETMASK);
ret = system(cmdStr);
if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
JZSDK_LOG_ERROR("Can't config the ip address of network."
"Probably the program not execute with root permission."
"Please use the root permission to execute the program.");
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}
//3、创建UDP socket 套接字
udp_socket = socket(AF_INET, SOCK_DGRAM, 0);
if (udp_socket == -1) {
JZSDK_LOG_ERROR("网口套接字注册失败");
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}
//4、配置udp服务器地址
memset(&udp_server_addr, 0, sizeof(udp_server_addr));
udp_server_addr.sin_family = AF_INET;
udp_server_addr.sin_port = htons(UDP_SERVER_PORT);
if(inet_aton(NET_WORK_TARGET_IPADDR, &udp_server_addr.sin_addr) == 0)
{
JZSDK_LOG_ERROR("udp服务器配置失败");
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}
NetworkMode = JZ_FLAGCODE_ON;
return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}
T_JZsdkReturnCode JZsdk_NetWork_DeInit()
{
NetworkMode = JZ_FLAGCODE_OFF;
return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}
static T_JZsdkReturnCode JZsdk_NetWork_Sent(const unsigned char *data, const int data_len)
{
int bytes_sent = sendto(udp_socket, data, data_len, 0,
(struct sockaddr *) &udp_server_addr, sizeof(udp_server_addr));
if (bytes_sent == -1)
{
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}
else
{
return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}
}
T_JZsdkReturnCode JZsdk_NetWork_SentData(const unsigned char *data, const int data_len)
{
if (NetworkMode != JZ_FLAGCODE_ON)
{
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}
T_JZsdkReturnCode returnCode;
int lengthOfDataHaveBeenSent = 0;
int lengthOfDataToBeSent = 0;
while (data_len - lengthOfDataHaveBeenSent)
{
lengthOfDataToBeSent = JZSDK_UTIL_MIN(MAX_SEND_FRAME_LENTH,
data_len - lengthOfDataHaveBeenSent);
returnCode = JZsdk_NetWork_Sent((const uint8_t *) data + lengthOfDataHaveBeenSent,
lengthOfDataToBeSent);
if (JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
{
JZSDK_LOG_ERROR("网口发送错误");
}
lengthOfDataHaveBeenSent += lengthOfDataToBeSent;
}
return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}
\ No newline at end of file
... ...
/**
********************************************************************
* @file JZsdk_Uart_UartDeal.h
* JZsdk_Uart_UartDeal的头文件
*
*********************************************************************
*/
/* Define to prevent recursive inclusion 避免重定义 -------------------------------------*/
#ifndef JZSDK_NETWORK_H
#define JZSDK_NETWORK_H
/* Includes ------------------------------------------------------------------*/
#ifdef __cplusplus
extern "C" {
#endif
/* Exported constants --------------------------------------------------------*/
/* 常亮定义*/
#include "JZsdk_Base/JZsdk_Code/JZsdk_Code.h"
/* Exported types ------------------------------------------------------------*/
/* Exported functions --------------------------------------------------------*/
T_JZsdkReturnCode JZsdk_NetWork_Init();
T_JZsdkReturnCode JZsdk_NetWork_DeInit();
T_JZsdkReturnCode JZsdk_NetWork_SentData(const unsigned char *data, const int data_len);
#ifdef __cplusplus
}
#endif
#endif
... ...
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "JZsdk_uart/UartConnection/UartConnection.h"
#include "Megaphone/Megaphone.h"
#include "BaseConfig.h"
#include "version_choose.h"
#include "JZsdk_uart/JZsdk_Uart_Input.h"
#include "JZsdk_uart/JZsdk_Uart_UartDeal.h"
#include "JZsdk_uart/Uart_Config.h"
#include "JZsdk_uart/JZsdk_Uart_Send/JZsdk_Uart_Send.h"
#include "Gimbal_InAndOut.h"
// 记录串口是否有被使用，方便ui_contrl进行信息反馈
struct UartDev_UseFlag
{
int UartDev_DEV1 ;
int UartDev_DEV2 ;
int UartDev_4G ;
};
static struct UartDev_UseFlag UartDevUseFlag = {JZ_FLAGCODE_OFF, JZ_FLAGCODE_OFF, JZ_FLAGCODE_OFF};
/****************
*
* 回复串口是否有被调用
*
* *************/
int JZsdk_Get_UartDev_UseFlag(int UART_DEV_NAME)
{
if (UART_DEV_NAME == UART_DEV_1)
{
return UartDevUseFlag.UartDev_DEV1;
}
else if (UART_DEV_NAME == UART_DEV_2)
{
return UartDevUseFlag.UartDev_DEV2;
}
else if (UART_DEV_NAME == UART_4G)
{
return UartDevUseFlag.UartDev_4G;
}
}
/**************
*
* 串口部分初始化
*
* *********/
int JZsdk_Uart_Init(int UART_DEV_NAME)
{
//初始化的是一号设备
if (UART_DEV_NAME == UART_DEV_1)
{
JZsdk_Uart_SecondInit(UART_DEV_1,UART_DEV1_BITRATE);
}
//初始化的是二号设备
else if (UART_DEV_NAME == UART_DEV_2)
{
JZsdk_Uart_SecondInit(UART_DEV_2, UART_DEV2_BITRATE);
}
else if (UART_DEV_NAME == UART_4G)
{
JZsdk_Uart_SecondInit(UART_4G, COMM_4G_UART_BITRATE);
}
printf("%x串口初始化完成\n", UART_DEV_NAME);
}
/**************
*
* 串口部分修改波特率
*
* *********/
int JZsdk_Uart_BitRateChange(int UART_DEV_NAME, int BitRate)
{
//1、释放掉原串口
if (UART_DEV_NAME == UART_DEV_1)
{
//将使用标识关闭
UartDevUseFlag.UartDev_DEV1 = JZ_FLAGCODE_OFF;
//等候关闭接收线程
JZsdk_Uart_CloseUartThead(UART_DEV_NAME, BitRate);
}
//1、释放掉原串口
else if (UART_DEV_NAME == UART_DEV_2)
{
//将使用标识关闭
UartDevUseFlag.UartDev_DEV2 = JZ_FLAGCODE_OFF;
//等候关闭接收线程
JZsdk_Uart_CloseUartThead(UART_DEV_NAME, BitRate);
}
//1、释放掉原串口
else if (UART_DEV_NAME == UART_4G)
{
//将使用标识关闭
UartDevUseFlag.UartDev_4G = JZ_FLAGCODE_OFF;
//等候关闭接收线程
JZsdk_Uart_CloseUartThead(UART_DEV_NAME, BitRate);
}
}
/**************
*
* 串口部分串口再注册
*
* *********/
int JZsdk_Uart_SecondInit(int UART_DEV_NAME, int BitRate)
{
int Uart_fd = 0;
printf("初始化串口%x\n",UART_DEV_NAME);
//初始化的是一号设备
if (UART_DEV_NAME == UART_DEV_1)
{
//1、串口初始化
Uart_fd = UartConnection_UartEnabled(UART_DEV1_NUM, BitRate);
//2、串口接收初始化
JZsdk_Uart_UartDeal_Receive(Uart_fd, UART_DEV_1);
//3、将使用标识打开
UartDevUseFlag.UartDev_DEV1 = JZ_FLAGCODE_ON;
}
else if (UART_DEV_NAME == UART_DEV_2)
{
//1、串口初始化
Uart_fd = UartConnection_UartEnabled(UART_DEV2_NUM, BitRate);
//2、串口接收初始化
JZsdk_Uart_UartDeal_Receive(Uart_fd, UART_DEV_2);
//3、将使用标识打开
UartDevUseFlag.UartDev_DEV2 = JZ_FLAGCODE_ON;
}
else if (UART_DEV_NAME == UART_4G)
{
//1、串口初始化
Uart_fd = UartConnection_UartEnabled(COMM_4G_UART_NUM, BitRate);
//2、串口接收初始化
JZsdk_Uart_UartDeal_Receive(Uart_fd, UART_4G);
//3、将使用标识打开
UartDevUseFlag.UartDev_4G = JZ_FLAGCODE_ON;
}
}
/*******************************
*
* 自由帧发送
*
* ******************/
int JZsdk_Uart_Send_CustomOrder(int UartPort, char *frame, int frame_len)
{
JZsdk_Uart_UartSend(UartPort, frame, frame_len);
}
/*****************
*
* 发送主动连接帧
*
* ******************/
int JZsdk_Uart_Send_ConnectFrame(int PortNum)
{
JZsdk_Uart_SendDeal_ConnectFrame(PortNum);
}
/*
*
* 发送播放结束状态帧
*
*/
int JZsdk_Uart_Reply_PlayStatus_end(int PortNum)
{
//发送播放状态结束帧
JZsdk_Uart_SendDeal_Send_PlayStatus_end(PortNum);
}
/**************
*
* 发送发送播放状态帧
*
* ***********/
int JZsdk_Uart_Send_PlayStatus(int Uartport ,int num)
{
JZsdk_Uart_SendDeal_Send_PlayStatus(Uartport, num);
}
/**************
*
* 发送音量
*
* ***********/
int JZsdk_Uart_Reply_Volume(int Uartport,int volume)
{
JZsdk_Uart_SendDeal_Reply_Volume(Uartport, volume);
}
/**************
*
* 发送音色
*
* ***********/
int JZsdk_Uart_Reply_TTS_tone(int Uartport,int tone)
{
JZsdk_Uart_SendDeal_Reply_TTS_tone(Uartport, tone);
}
/**************
*
* 发送语速
*
* ***********/
int JZsdk_Uart_Reply_TTS_speed(int Uartport,int speed)
{
JZsdk_Uart_SendDeal_Reply_TTS_speed(Uartport, speed);
}
/**************
*
* 发送循环状态
*
* ***********/
int JZsdk_Uart_Reply_AudioPlayLoopStatus(int Uartport,int speed)
{
JZsdk_Uart_SendDeal_Reply_LoopPlayStatus(Uartport, speed);
}
/**************
*
* 发送云台俯仰角度查询值
*
* ***********/
int JZsdk_Uart_Reply_GimbalPitchAngle(int Uartport,int angle)
{
JZsdk_Uart_SendDeal_Reply_GimbalPitchAngle(Uartport, angle);
}
/*************
*
* 设置云台俯仰角度
*
* **************/
int JZsdk_Uart_Send_SetGimbalPitch(int Uartport,int angle)
{
JZsdk_Uart_SendDeal_Set_GimbalPitchAngle(Uartport, angle);
}
/*************
*
* 查询云台角度
*
* **************/
int JZsdk_Uart_Send_CheckStatus_GimbalAngle(int Uartport ,int FrameSequence)
{
JZsdk_Uart_SendDeal_CheckStatus_GimbalAngle(Uartport, FrameSequence);
}
/*************
*
* 设置云台俯仰角度微调
*
* **************/
int JZsdk_Uart_Send_SetGimbalFineTuningPitch(int Uartport,int angle)
{
JZsdk_Uart_SendDeal_Set_GimbalFineTuningPitch(Uartport, angle);
}
/*************
*
* 查询云台微调角度
*
* **************/
int JZsdk_Uart_Send_CheckStatus_GimbalFineTuningPitch(int Uartport,int FrameSequence)
{
JZsdk_Uart_SendDeal_CheckStatus_GimbalFineTuningPitch(Uartport,FrameSequence);
}
/*************
*
* 发送云台俯仰微调值
*
* **************/
int JZsdk_Uart_Send_GimbalFineTuningPitch(int Uartport,int FrameSequence, int Pitch)
{
JZsdk_Uart_SendDeal_Reply_GimbalFineTuningPitch(Uartport,FrameSequence, Pitch);
}
/*************
*
* 设置云台联动
*
* **************/
int JZsdk_Uart_Send_Set_GimbalLinkageControl(int Uartport,int FrameSequence, int value)
{
JZsdk_Uart_SendDeal_Set_GimbalLinkageControl(Uartport,FrameSequence, value);
}
/*************
*
* 查询云台联动值
*
* **************/
int JZsdk_Uart_Send_CheckStatus_GimbalLinkage(int Uartport,int FrameSequence)
{
JZsdk_Uart_SendDeal_CheckStatus_GimbalLinkage(Uartport,FrameSequence);
}
/*************
*
* 发送云台联动值
*
* **************/
int JZsdk_Uart_Send_GimbalLinkageControl(int Uartport,int FrameSequence, int value)
{
JZsdk_Uart_SendDeal_GimbalLinkageControl(Uartport,FrameSequence,value);
}
/*************
*
* 设置云台最大最小值
*
* **************/
int JZsdk_Uart_Send_SetGimbalRange(int Uartport,int FrameSequence, int value)
{
JZsdk_Uart_SendDeal_SetGimbalRange(Uartport,FrameSequence,value);
}
/*******************************************************************************************************************************
*
* 探照灯部分
*
* *******************************************************************************************************************************/
/*************
*
* 设置探照灯爆闪频率
*
* **************/
int JZsdk_Uart_Send_SearchLight_SetFrequency(int Uartport,int Frequency)
{
JZsdk_Uart_SendDeal_Set_SearchLightFrequency(Uartport ,Frequency);
}
/*************
*
* 探照灯控制
*
* **************/
int JZsdk_Uart_Send_SearchLight_Control(int Uartport,int mode)
{
JZsdk_Uart_SendDeal_SearchLight_Control(Uartport, mode);
}
/*************
*
* 探照灯亮度
*
* **************/
int JZsdk_Uart_Send_SearchLight_SetLumen(int Uartport, int LeftLumen, int RightLumen)
{
JZsdk_Uart_SendDeal_SearchLight_SetLumen(Uartport, LeftLumen, RightLumen);
}
/*************
*
* 查询爆闪频率
*
* **************/
int JZsdk_Uart_Send_SearchLight_CheckStatus_Frequency(int Uartport)
{
JZsdk_Uart_SendDeal_Set_SearchLight_CheckStatus_Frequency(Uartport);
}
/*************
*
* 查询探照灯亮度
*
* **************/
int JZsdk_Uart_Send_SearchLight_CheckStatus_Lumen(int Uartport)
{
JZsdk_Uart_SendDeal_Set_SearchLight_CheckStatus_Lumen(Uartport);
}
/*************
*
* 查询探照灯模式
*
* **************/
int JZsdk_Uart_Send_SearchLight_CheckStatus_Mode(int Uartport)
{
JZsdk_Uart_SendDeal_Set_SearchLight_CheckStatus_Mode(Uartport);
}
/*************
*
* 查询探照灯属性
*
* **************/
int JZsdk_Uart_Send_SearchLight_CheckStatus_LightAttribute(int Uartport)
{
JZsdk_Uart_SendDeal_CheckStatus_LightAttribute(Uartport);
}
/*************
*
* 查询探照灯温度
*
* **************/
int JZsdk_Uart_Send_SearchLight_CheckStatus_SearchLightTemperture(int Uartport)
{
JZsdk_Uart_SendDeal_CheckStatus_SearchLightTemperture(Uartport);
}
/*************
*
* 探照灯消息订阅
*
* **************/
int JZsdk_Uart_Send_MessageSubcription_Control(int Uartport,int value)
{
JZsdk_Uart_SendDeal_MessageSubcription_Control(Uartport, value);
}
/*******************************************************************************************************************************
*
* 警灯部分
*
* *******************************************************************************************************************************/
/*************
*
* 设置警灯状态
*
* **************/
int JZsdk_Uart_Send_Set_WarningLight_Status(int Uartport,int status, int mode)
{
JZsdk_Uart_SendDeal_Set_WarningLight_Status(Uartport, status, mode);
}
/*************
*
* 设置警灯颜色
*
* **************/
int JZsdk_Uart_Send_Set_WarningLight_Color(int Uartport,int color1, int color2)
{
JZsdk_Uart_SendDeal_Set_WarningLight_Color(Uartport, color1, color2);
}
/*******************************************************************************************************************************
*
* 5B类部分
*
* *******************************************************************************************************************************/
/*************
*
* 发送opus解码状态
*
* **************/
int JZsdk_Uart_Send_OpusDecodeStatus(int Uartport,int value)
{
JZsdk_Uart_SendDeal_OpusDecodeStatus(Uartport, value);
}
/*************
*
* 发送探照灯爆闪频率
*
* **************/
int JZsdk_Uart_Send_SearchLight_Frequency(int Uartport,int value)
{
JZsdk_Uart_SendDeal_SearchLight_Frequency(Uartport, value);
}
/*************
*
* 发送探照灯模式
*
* **************/
int JZsdk_Uart_Send_SearchLight_Mode(int Uartport,int value)
{
JZsdk_Uart_SendDeal_SearchLight_Mode(Uartport, value);
}
/*************
*
* 发送探照灯亮度
*
* **************/
int JZsdk_Uart_Send_SearchLight_Lumen(int Uartport,int LeftLumen, int RightLumen)
{
JZsdk_Uart_SendDeal_SearchLight_Lumen(Uartport, LeftLumen, RightLumen);
}
/*************
*
* 发送探照灯温度
*
* **************/
int JZsdk_Uart_Send_SearchLight_Temperature(int Uartport,int LeftTemperature, int RightTemperature)
{
JZsdk_Uart_SendDeal_SearchLight_Temperature(Uartport, LeftTemperature, RightTemperature);
}
/*************
*
* 发送对外供电电源的状态
*
* **************/
int JZsdk_Uart_Send_OutputPowerStatus(int Uartport, int FrameSequence, int status)
{
JZsdk_Uart_SendDeal_OutputPowerStatus(Uartport, FrameSequence, status);
}
/*******************************************************************************************************************************
*
* 警灯部分
*
* *******************************************************************************************************************************/
/*************
*
* 发送警灯状态
*
* **************/
int JZsdk_Uart_Send_WarningLight_Status(int Uartport, int status, int mode)
{
JZsdk_Uart_SendDeal_WarningLight_Status(Uartport, status, mode);
}
/*************
*
* 发送警灯颜色
*
* **************/
int JZsdk_Uart_Send_WarningLight_Color(int Uartport, int color1, int color2)
{
JZsdk_Uart_SendDeal_WarningLight_Color(Uartport, color1, color2);
}
/*************
*
* 查询警灯状态
*
* **************/
int JZsdk_Uart_Send_CheckStatus_WarningLightStatus(int Uartport)
{
JZsdk_Uart_SendDeal_CheckStatus_WarningLightStatus(Uartport);
}
/*************
*
* 查询警灯颜色
*
* **************/
int JZsdk_Uart_Send_CheckStatus_WarningLightColor(int Uartport)
{
JZsdk_Uart_SendDeal_CheckStatus_WarningLightColor(Uartport);
}
... ...
/**
********************************************************************
* @file JZsdk_Uart_Input.h
* JZsdk_Uart_Input
*
*********************************************************************
*/
/* Define to prevent recursive inclusion 避免重定义 -------------------------------------*/
#ifndef JZSDK_UART_INPUT_H
#define JZSDK_UART_INPUT_H
/* Includes ------------------------------------------------------------------*/
#ifdef __cplusplus
extern "C" {
#endif
/* Exported constants --------------------------------------------------------*/
/* 常亮定义*/
/* Exported types ------------------------------------------------------------*/
/* Exported functions --------------------------------------------------------*/
int JZsdk_Uart_Init(int UART_DEV_NAME);
int JZsdk_Get_UartDev_UseFlag(int UART_DEV_NAME);
int JZsdk_Uart_Reply_PlayStatus_end(int PortNum);
int JZsdk_Uart_Send_PlayStatus(int Uartport ,int num);
int JZsdk_Uart_Reply_Volume(int Uartport,int volume);
int JZsdk_Uart_Reply_TTS_tone(int Uartport,int tone);
int JZsdk_Uart_Reply_TTS_speed(int Uartport,int speed);
int JZsdk_Uart_Reply_AudioPlayLoopStatus(int Uartport,int speed);
int JZsdk_Uart_Send_OpusDecodeStatus(int Uartport,int value);
int JZsdk_Uart_Send_CustomOrder(int UartPort, char *frame, int frame_len);
int JZsdk_Uart_Send_ConnectFrame(int PortNum);
int JZsdk_Uart_Reply_GimbalPitchAngle(int Uartport,int angle);
int JZsdk_Uart_Send_SetGimbalPitch(int Uartport,int angle);
int JZsdk_Uart_Send_SetGimbalFineTuningPitch(int Uartport,int angle);
int JZsdk_Uart_Send_Gimbal_Pitch(int Uartport, int pitch);
int JZsdk_Uart_Send_CheckStatus_GimbalFineTuningPitch(int Uartport,int FrameSequence);
int JZsdk_Uart_Send_GimbalFineTuningPitch(int Uartport,int FrameSequence, int Pitch);
int JZsdk_Uart_Send_Set_GimbalLinkageControl(int Uartport,int FrameSequence, int value);
int JZsdk_Uart_Send_CheckStatus_GimbalLinkage(int Uartport,int FrameSequence);
int JZsdk_Uart_Send_GimbalLinkageControl(int Uartport,int FrameSequence, int value);
int JZsdk_Uart_Send_CheckStatus_GimbalAngle(int Uartport ,int FrameSequence);
int JZsdk_Uart_Send_SetGimbalRange(int Uartport,int FrameSequence, int value);
int JZsdk_Uart_Send_SearchLight_SetFrequency(int Uartport,int Frequency);
int JZsdk_Uart_Send_SearchLight_Control(int Uartport,int mode);
int JZsdk_Uart_Send_SearchLight_SetLumen(int Uartport, int LeftLumen, int RightLumen);
int JZsdk_Uart_Send_MessageSubcription_Control(int Uartport,int value);
int JZsdk_Uart_Send_Set_WarningLight_Status(int Uartport,int status, int mode);
int JZsdk_Uart_Send_Set_WarningLight_Color(int Uartport,int color1, int color2);
int JZsdk_Uart_Send_SearchLight_CheckStatus_Frequency(int Uartport);
int JZsdk_Uart_Send_SearchLight_CheckStatus_Lumen(int Uartport);
int JZsdk_Uart_Send_SearchLight_CheckStatus_Mode(int Uartport);
int JZsdk_Uart_Send_SearchLight_CheckStatus_LightAttribute(int Uartport);
int JZsdk_Uart_Send_SearchLight_CheckStatus_SearchLightTemperture(int Uartport);
int JZsdk_Uart_Send_SearchLight_Frequency(int Uartport,int value);
int JZsdk_Uart_Send_SearchLight_Mode(int Uartport,int value);
int JZsdk_Uart_Send_SearchLight_Lumen(int Uartport,int LeftLumen, int RightLumen);
int JZsdk_Uart_Send_SearchLight_Temperature(int Uartport,int LeftTemperature, int RightTemperature);
int JZsdk_Uart_Send_WarningLight_Status(int Uartport, int status, int mode);
int JZsdk_Uart_Send_WarningLight_Color(int Uartport, int color1, int color2);
int JZsdk_Uart_Send_CheckStatus_WarningLightStatus(int Uartport);
int JZsdk_Uart_Send_CheckStatus_WarningLightColor(int Uartport);
int JZsdk_Uart_Send_OutputPowerStatus(int Uartport, int FrameSequence, int status);
int JZsdk_Uart_BitRateChange(int UART_DEV_NAME, int BitRate);
int JZsdk_Uart_SecondInit(int UART_DEV_NAME, int BitRate);
#ifdef __cplusplus
}
#endif
#endif
... ...
/**
********************************************************************
* @file JZsdk_Uart_RecvDeal.h
* JZsdk_Uart_RecvDeal的头文件
*
*********************************************************************
*/
/* Define to prevent recursive inclusion 避免重定义 -------------------------------------*/
#ifndef JZSDK_UART_RECVDEAL_H
#define JZSDK_UART_RECVDEAL_H
/* Includes ------------------------------------------------------------------*/
#ifdef __cplusplus
extern "C" {
#endif
/* Exported constants --------------------------------------------------------*/
/* 常亮定义*/
/* Exported types ------------------------------------------------------------*/
/* Exported functions --------------------------------------------------------*/
int JZsdk_Uart_RecvDeal_CharmDeal(int Port, unsigned char *getbuf, int len);
#ifdef __cplusplus
}
#endif
#endif
... ...
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "../JZsdk_Uart_UartDeal.h"
#include "../Uart_Config.h"
#include "./JZsdk_Uart_Send.h"
#include "JZsdk_TaskManagement/TaskManagement.h"
#include "JZsdk_Base/JZsdk_Code/JZsdk_Code.h"
#include "JZsdk_Base/JZsdk_FrameComparsion/JZsdk_FrameComparsion.h"
//发送主动连接帧
int JZsdk_Uart_SendDeal_ConnectFrame(int PortNum)
{
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_5AFRAME_ASKFORCONNECT , sendbuf, &send_buf_len);
//2、发送帧
JZsdk_Uart_UartSend(PortNum ,sendbuf, send_buf_len);
}
//回复连接帧
int JZsdk_Uart_SendDeal_Send_Connect(int Uartport , int FrameSequence,int Version_flag)
{
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_5BFRAME_INITIATECONNECT , sendbuf, &send_buf_len);
//2、写入硬件码
sendbuf[9] = Version_flag;
//写入帧序列
sendbuf[6] = FrameSequence; //帧序列
//3、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len);
}
//回复心跳帧
int JZsdk_Uart_SendDeal_Send_HeartBeatStatus(int Uartport , int FrameSequence,int HeartBeatStatus)
{
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_5BFRAME_HEARTBEAT , sendbuf, &send_buf_len);
//2、写入硬件码
sendbuf[9] = HeartBeatStatus;
//写入帧序列
sendbuf[6] = FrameSequence; //帧序列
//3、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len);
}
//设置电源状态
T_JZsdkReturnCode JZsdk_Uart_SendDeal_PowerStatus(int Uartport, int FrameSequence, int status)
{
printf("发送电源状态\n");
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_5AFRAME_FRAME_POWER_STATUS, sendbuf, &send_buf_len);
sendbuf[9] = status;
sendbuf[6] = FrameSequence; //帧序列
//2、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len);
}
//发送心跳帧
T_JZsdkReturnCode JZsdk_Uart_SendDeal_Ask_HeartBeatStatus(int Uartport , int FrameSequence,int HeartBeatStatus)
{
printf("发送请求心跳帧\n");
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_5AFRAME_HEARTBEAT, sendbuf, &send_buf_len);
sendbuf[9] = HeartBeatStatus;
sendbuf[6] = FrameSequence; //帧序列
//2、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len);
}
//发送请求时间戳帧
T_JZsdkReturnCode JZsdk_Uart_SendDeal_Ask_TimeStamp(int Uartport , int FrameSequence)
{
printf("发送请求时间戳帧\n");
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_5AFRAME_TIMESTAMP, sendbuf, &send_buf_len);
sendbuf[6] = FrameSequence; //帧序列
//2、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len);
}
//发送版本号
T_JZsdkReturnCode JZsdk_Uart_SendDeal_SendAllVersion(int Uartport, int FrameSequence, int DeviceID, int MajorVersion, int MinorVersion, int ModifyVersion, int DebugVersion)
{
printf("发送所有版本号\n");
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_5BFRAME_ALL_VERSION, sendbuf, &send_buf_len);
sendbuf[6] = FrameSequence; //帧序列
sendbuf[9] = DeviceID;
sendbuf[10] = MajorVersion;
sendbuf[11] = MinorVersion;
sendbuf[12] = ModifyVersion;
sendbuf[13] = DebugVersion;
//2、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len);
}
//发送序列号
T_JZsdkReturnCode JZsdk_Uart_SendDeal_SendAllSerialNumber(int Uartport, int FrameSequence, int DeviceID, unsigned char *SerialNumber, int SerialNumberLen)
{
printf("发送所有序列号\n");
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_5BFRAME_ALL_SERIAL_NUMBER, sendbuf, &send_buf_len);
sendbuf[6] = FrameSequence; //帧序列
sendbuf[9] = DeviceID;
memcpy(&sendbuf[10], SerialNumber, SerialNumberLen);
send_buf_len = send_buf_len - 1 + SerialNumberLen;
sendbuf[send_buf_len-2] = 0x00;
sendbuf[send_buf_len-1] = 0x23;
sendbuf[3] = (send_buf_len >> 8);
sendbuf[4] = (send_buf_len & 0xff);
//2、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len);
}
//发送成功帧
int JZsdk_Uart_SendDeal_Reply_Sucesss(int Uartport ,int FrameSequence)
{
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_5BFRAME_SUCESS , sendbuf, &send_buf_len);
//2、写入数据
sendbuf[6] = FrameSequence; //帧序列
//3、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len);
}
//发送失败帧
int JZsdk_Uart_SendDeal_Reply_Failure(int Uartport ,int FrameSequence)
{
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_5BFRAME_DEFEAT , sendbuf, &send_buf_len);
//2、写入数据
sendbuf[6] = FrameSequence; //帧序列
//3、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len);
}
//发送当前从设备名
int JZsdk_Uart_SendDeal_Reply_SecondaryDeviceName(int Uartport , int device_name, int FrameSequence)
{
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_6BFRAME_CHECKSTATUS_SECONDARY_DEVICE_NAME , sendbuf, &send_buf_len);
//2、写入数据
sendbuf[6] = FrameSequence; //帧序列
sendbuf[10] = device_name;
//3、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len);
}
//查询当前从设备名
int JZsdk_Uart_SendDeal_QuerySecondaryDeviceName(int Uartport ,int FrameSequence)
{
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_6AFRAME_CHECKSTATUS_SECONDARY_DEVICE_NAME , sendbuf, &send_buf_len);
//2、写入数据
sendbuf[6] = FrameSequence; //帧序列
//3、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len);
}
//发送当前设备序列号
int JZsdk_Uart_SendDeal_SerialNumber(int UartPort, int FrameSequence, char *SerialNumber, int SerialNumberLenth)
{
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_5BFRAME_CHECKSTATUS_SERIALNUMBER , sendbuf, &send_buf_len);
//2、写入数据
sendbuf[6] = FrameSequence; //帧序列
for (int i = 0; i < SerialNumberLenth; i++)
{
sendbuf[9+i] = SerialNumber[i];
}
sendbuf[9+SerialNumberLenth] = 0x00;
sendbuf[9+SerialNumberLenth + 1] = 0x23;
send_buf_len = (9+SerialNumberLenth + 2);
sendbuf[4] = send_buf_len;
//3、发送帧
JZsdk_Uart_UartSend(UartPort ,sendbuf, send_buf_len);
}
/*********
*
* 发送设备信息
*
*
* *******/
T_JZsdkReturnCode JZsdk_Uart_SendDeal_DeviceMessage(int UartPort, int FrameSequence, unsigned char *message, unsigned int messageLen)
{
unsigned char sendbuf[300];
memset(sendbuf,0,sizeof(sendbuf));
unsigned int send_buf_len = 0;
//获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_5BFRAME_DEVICE_MESSAGE , sendbuf, &send_buf_len);
memcpy(&sendbuf[9], message, messageLen);
send_buf_len = 9+messageLen+2;
sendbuf[9+messageLen] = 0x00;
sendbuf[9+messageLen + 1] = 0x23;
//3、发送帧
JZsdk_Uart_UartSend(UartPort ,sendbuf, send_buf_len);
}
struct JZsdk_MusicListSentStruct
{
int UartPort;
int FrameSequence;
int music_sum;
char **MusicName;
int *MusicNameLength;
};
/**********
*
* 歌曲列表发送任务函数
*
* ***********/
static void JZsdk_Uart_SentDeal_Reply_Musiclist_Task(void *data)
{
struct JZsdk_MusicListSentStruct *taskData = (struct JZsdk_MusicListSentStruct *)data;
unsigned char sendbuf[256];
int send_buf_len;
//1、发送操作成功
//获取帧样板
memset(sendbuf,0,sizeof(sendbuf));
JZsdk_GetFrameTemplate(JZ_INSCODE_5BFRAME_SUCESS , sendbuf, &send_buf_len);
//写入数据
sendbuf[6] = taskData->FrameSequence; //帧序列
//发送帧
printf("发送操作成功帧\n");
JZsdk_Uart_UartSend_NotTask(taskData->UartPort ,sendbuf, send_buf_len);
//2、发送开始帧
//获取帧样板
memset(sendbuf,0,sizeof(sendbuf));
JZsdk_GetFrameTemplate(JZ_INSCODE_5BFRAME_MUSICLIST_START , sendbuf, &send_buf_len);
//写入数据
sendbuf[6] = taskData->FrameSequence; //帧序列
sendbuf[9] = taskData->music_sum;
//发送帧
printf("发送歌曲开始列表帧\n");
JZsdk_Uart_UartSend_NotTask(taskData->UartPort ,sendbuf, send_buf_len);
//3、逐一调用发送函数将歌曲名发出
for (int i = 0; i < (taskData->music_sum) ; i++)
{
memset(sendbuf,0,sizeof(sendbuf));
JZsdk_GetFrameTemplate(JZ_INSCODE_5BFRAME_MUSICLIST_TRANS , sendbuf, &send_buf_len);
memcpy(&sendbuf[9],taskData->MusicName[i],taskData->MusicNameLength[i]);
sendbuf[9+taskData->MusicNameLength[i]]=0x00;
sendbuf[10+taskData->MusicNameLength[i]]=0x23;
send_buf_len = send_buf_len -1 + taskData->MusicNameLength[i] ;
sendbuf[3] = (send_buf_len >> 8);
sendbuf[4] = (send_buf_len & 0xff);
sendbuf[6] = taskData->FrameSequence; //帧序列
JZsdk_Uart_UartSend_NotTask(taskData->UartPort ,sendbuf, send_buf_len);
}
//4、发送结束帧
//获取帧样板
memset(sendbuf,0,sizeof(sendbuf));
JZsdk_GetFrameTemplate(JZ_INSCODE_5BFRAME_MUSICLIST_STOP , sendbuf, &send_buf_len);
//写入数据
sendbuf[6] = taskData->FrameSequence; //帧序列
sendbuf[9] = taskData->music_sum;
//发送帧
printf("发送歌曲结束列表");
JZsdk_Uart_UartSend_NotTask(taskData->UartPort ,sendbuf, send_buf_len);
//5、释放内存
for (int i = 0; i < taskData->music_sum; i++)
{
free(taskData->MusicName[i]);
taskData->MusicName[i] = NULL;
}
free(taskData->MusicName);
taskData->MusicName = NULL;
free(taskData->MusicNameLength);
free(taskData);
taskData = NULL;
}
T_JZsdkReturnCode JZsdk_Uart_SentDeal_Reply_Musiclist(int UartPort ,int FrameSequence, int music_sum ,char **MusicName ,int *MusicNameLength)
{
struct JZsdk_MusicListSentStruct *musicList = (struct JZsdk_MusicListSentStruct *)malloc(sizeof(struct JZsdk_MusicListSentStruct));
if (musicList == NULL)
{
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}
musicList->UartPort = UartPort;
musicList->FrameSequence = FrameSequence;
musicList->music_sum = music_sum;
musicList->MusicName = MusicName;
musicList->MusicNameLength = MusicNameLength;
T_JZsdkReturnCode ret = TaskManagement_SubmitTask(JZsdk_Uart_SentDeal_Reply_Musiclist_Task, (void *)musicList);
if (ret == JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE)
{
free(musicList);
musicList = NULL;
return ret;
}
return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}
//发送播放状态结束帧
int JZsdk_Uart_SendDeal_Send_PlayStatus_end(int Uartport)
{
printf("发送播放状态结束帧\n");
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_5BFRAME_AUDIO_PLAYSTATUS_END , sendbuf, &send_buf_len);
//2、写入数据
//3、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len);
}
//发送播放状态帧
int JZsdk_Uart_SendDeal_Send_PlayStatus(int Uartport ,int num)
{
printf("向");
switch (Uartport)
{
case UART_4G:
printf("4G模块");
break;
case UART_DEV_1:
printf("串口1设备");
break;
case UART_DEV_2:
printf("串口2设备");
break;
default:
break;
}
printf("发送播放状态帧%x\n",num);
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_5BFRAME_AUDIO_PLAYSTATUS , sendbuf, &send_buf_len);
//2、写入数据
sendbuf[9] = (char)num;
//3、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len);
}
//回复当前播放的歌曲名字
int JZsdk_Uart_SendDeal_Reply_MusicName(int Uartport ,char *music_name, int music_name_len)
{
printf("发送当前歌曲名字帧");
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_5BFRAME_AUDIO_PLAYFILENAME , sendbuf, &send_buf_len);
//2、写入数据
memcpy(&sendbuf[9],music_name,music_name_len);
sendbuf[9+music_name_len]=0x00;
sendbuf[10+music_name_len]=0x23;
int len = send_buf_len -1 + music_name_len;
sendbuf[3] = len >> 8;
sendbuf[4] = len & 0xff;
//3、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, len);
}
//回复当前音量
int JZsdk_Uart_SendDeal_Reply_Volume(int Uartport ,int num)
{
printf("发送播放状态帧\n");
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_5BFRAME_VOLUME, sendbuf, &send_buf_len);
//2、写入数据
sendbuf[9] = (char)num;
//3、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len);
}
//回复软件版本号
int JZsdk_Uart_SendDeal_Reply_SoftVersion(int Uartport ,char majorVersion, char minorVersion, char modifyVersion, char debugVersion)
{
printf("发送软件版本号帧\n");
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_5BFRAME_SORTWAREVERSION, sendbuf, &send_buf_len);
//2、写入数据
sendbuf[9] = majorVersion;
sendbuf[10] = minorVersion;
sendbuf[11] = modifyVersion;
sendbuf[12] = debugVersion;
//3、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len);
}
//发送循环状态
int JZsdk_Uart_SendDeal_Reply_LoopPlayStatus(int Uartport ,int status)
{
printf("发送循环状态帧\n");
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_5BFRAME_AUDIO_PLAYLOOPSTATUS, sendbuf, &send_buf_len);
//2、写入数据
sendbuf[9] = status;
//3、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len);
}
//发送音色
int JZsdk_Uart_SendDeal_Reply_TTS_tone(int Uartport ,int tone)
{
printf("发送音色帧\n");
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_5BFRAME_TTS_TONE, sendbuf, &send_buf_len);
//2、写入数据
sendbuf[9] = tone;
//3、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len);
}
//发送语速
int JZsdk_Uart_SendDeal_Reply_TTS_speed(int Uartport ,int speed)
{
printf("发送音色帧\n");
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_5BFRAME_TTS_SPEED, sendbuf, &send_buf_len);
//2、写入数据
sendbuf[9] = speed;
//3、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len);
}
/*************
*
* 发送opus解码状态
*
* **************/
int JZsdk_Uart_SendDeal_OpusDecodeStatus(int Uartport,int value)
{
printf("发送opus解码状态帧\n");
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_5BFRAME_OPUS_DECODE_STATUS, sendbuf, &send_buf_len);
//2、写入数据
sendbuf[9] = value;
//3、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len);
}
/****************************************************************************************************************************************************
*
* 云台部分
*
****************************************************************************************************************************************************/
//回复当前云台角度
int JZsdk_Uart_SendDeal_Reply_GimbalPitchAngle(int Uartport ,int angle)
{
printf("发送当前云台角度帧\n");
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_5BFRAME_GIMBAL_PITCH, sendbuf, &send_buf_len);
//2、写入数据
char signal = 0x00;
if (angle < 0)
{
signal = 0xff;
angle = -angle;
}
sendbuf[9] = (char)signal;
sendbuf[10] = (char)(angle >> 8);
sendbuf[11] = (char)(angle & 255);
//3、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len);
}
//设置当前云台角度
int JZsdk_Uart_SendDeal_Set_GimbalPitchAngle(int Uartport ,int angle)
{
//printf("发送设置云台角度帧 %d\n",angle); //该打印可能会造成卡顿
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_5AFRAME_GIMBAL_PITCH_CONTROL, sendbuf, &send_buf_len);
//char sendbuf[14] = {0x5A ,0x5A ,0x77 ,0x00 ,0x0E ,0x00 ,0x00 ,0x64 ,0x51 ,0x00 ,0x00 ,0x00 ,0x00 ,0x23};
//send_buf_len = 14;
//2、写入数据
if (angle < 0)
{
angle = -angle;
sendbuf[9] = 0xff;
}
else
{
sendbuf[9] = 0x00;
}
sendbuf[10] = ((angle>>8) & 0xff);
sendbuf[11] = (angle & 0xff);
//3、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len);
}
//查询云台角度
int JZsdk_Uart_SendDeal_CheckStatus_GimbalAngle(int Uartport ,int FrameSequence)
{
printf("发送查询云台角度帧\n");
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_5AFRAME_CHECKSTATUS_GIMBAL, sendbuf, &send_buf_len);
//2、写入帧序列
sendbuf[6] = FrameSequence;
//3、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len);
}
//微调云台pitch
int JZsdk_Uart_SendDeal_Set_GimbalFineTuningPitch(int Uartport, int PitchFineTuning)
{
printf("发送微调云台pitch帧\n");
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_5AFRAME_GIMBAL_PITCH_FINETUNING_CONTROL, sendbuf, &send_buf_len);
//2、写入数据
if (PitchFineTuning < 0)
{
PitchFineTuning = -PitchFineTuning;
sendbuf[9] = 0xff;
}
else
{
sendbuf[9] = 0x00;
}
sendbuf[10] = ((PitchFineTuning>>8) & 0xff);
sendbuf[11] = (PitchFineTuning & 0xff);
//3、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len);
}
//查询云台角度微调值
int JZsdk_Uart_SendDeal_CheckStatus_GimbalFineTuningPitch(int Uartport, int FrameSequence)
{
printf("发送查询云台角度微调值帧\n");
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_5AFRAME_CHECKSTATUS_GIMBAL_FINETUNING, sendbuf, &send_buf_len);
//2、写入数据
sendbuf[6] = FrameSequence; //帧序列
//3、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len);
}
//回复云台pitch微调值
int JZsdk_Uart_SendDeal_Reply_GimbalFineTuningPitch(int Uartport, int FrameSequence, int FineTunigPitch)
{
printf("发送云台pitch微调值\n");
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_5BFRAME_GIMBAL_PITCH_FINETUNING, sendbuf, &send_buf_len);
//2、写入数据
if (FineTunigPitch < 0)
{
FineTunigPitch = -FineTunigPitch;
sendbuf[9] = 0xff;
}
else
{
sendbuf[9] = 0x00;
}
sendbuf[10] = ((FineTunigPitch>>8) & 0xff);
sendbuf[11] = (FineTunigPitch & 0xff);
//3、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len);
}
//设置云台联动
int JZsdk_Uart_SendDeal_Set_GimbalLinkageControl(int Uartport,int FrameSequence, int value)
{
printf("发送设置云台联动帧\n");
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_6AFRAME_GIMBAL_LINKAGE_CONTROL, sendbuf, &send_buf_len);
//2、写入数据
sendbuf[6] = FrameSequence; //帧序列
sendbuf[10] = value;
//3、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len);
}
//查询云台联动值
int JZsdk_Uart_SendDeal_CheckStatus_GimbalLinkage(int Uartport,int FrameSequence)
{
printf("发送查询云台联动值帧\n");
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_6AFRAME_CHECKSTATUS_GIMBAL_LINKAGE, sendbuf, &send_buf_len);
//2、写入数据
sendbuf[6] = FrameSequence; //帧序列
//3、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len);
}
//发送云台联动值
int JZsdk_Uart_SendDeal_GimbalLinkageControl(int Uartport,int FrameSequence,int value)
{
printf("发送云台联动值帧\n");
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_6BFRAME_CHECKSTATUS_GIMBAL_LINKAGE, sendbuf, &send_buf_len);
//2、写入数据
sendbuf[6] = FrameSequence; //帧序列
sendbuf[10] = value;
//3、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len);
}
//发送云台最大最小值帧
int JZsdk_Uart_SendDeal_SetGimbalRange(int Uartport,int FrameSequence,int value)
{
printf("发送云台最大最小值帧\n");
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_6AFRAME_SET_GIMBAL_MAXMIN_RANGE, sendbuf, &send_buf_len);
//2、写入数据
sendbuf[6] = FrameSequence; //帧序列
sendbuf[10] = value;
//3、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len);
}
/****************************************************************************************************************************************************
*
* 探照灯部分
*
****************************************************************************************************************************************************/
//发送设置探照灯爆闪频率
int JZsdk_Uart_SendDeal_Set_SearchLightFrequency(int Uartport ,int Frequency)
{
printf("发送设置爆闪频率帧\n");
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_5AFRAME_SEARCHLIGHT_SET_FREQUENCY, sendbuf, &send_buf_len);
//2、写入数据
sendbuf[10] = Frequency;
//3、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len);
}
//设置探照灯控制
int JZsdk_Uart_SendDeal_SearchLight_Control(int Uartport,int mode)
{
printf("发送探照灯控制\n");
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_5AFRAME_SEARCHLIGHT_CONTROL, sendbuf, &send_buf_len);
//2、写入数据
sendbuf[10] = mode;
//3、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len);
}
//设置探照灯亮度
int JZsdk_Uart_SendDeal_SearchLight_SetLumen(int Uartport, int LeftLumen, int RightLumen)
{
printf("发送设置探照灯亮度\n");
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_5AFRAME_SEARCHLIGHT_SET_LUMEN, sendbuf, &send_buf_len);
//2、写入数据
sendbuf[9] = LeftLumen;
sendbuf[10] = RightLumen;
//3、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len);
}
//发送
//查询探照灯频率
int JZsdk_Uart_SendDeal_Set_SearchLight_CheckStatus_Frequency(int Uartport)
{
printf("发送查询探照灯频率帧\n");
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_5AFRAME_CHECKSTATUS_SEARCHLIGHT_FREQUENCY, sendbuf, &send_buf_len);
//2、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len);
}
//查询探照灯亮度
int JZsdk_Uart_SendDeal_Set_SearchLight_CheckStatus_Lumen(int Uartport)
{
printf("发送查询探照灯亮度帧\n");
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_5AFRAME_CHECKSTATUS_SEARCHLIGHT_LUMEN, sendbuf, &send_buf_len);
//2、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len);
}
//查询探照灯模式
int JZsdk_Uart_SendDeal_Set_SearchLight_CheckStatus_Mode(int Uartport)
{
printf("发送查询探照灯模式帧\n");
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_5AFRAME_CHECKSTATUS_SEARCHLIGHT_MODE, sendbuf, &send_buf_len);
//2、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len);
}
//查询探照灯属性
int JZsdk_Uart_SendDeal_CheckStatus_LightAttribute(int Uartport)
{
printf("发送查询探照灯属性帧\n");
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_5AFRAME_CHECKSTATUS_SEARCHLIGHT_LIGHTATTRIBUTE, sendbuf, &send_buf_len);
//2、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len);
}
//查询探照灯温度
int JZsdk_Uart_SendDeal_CheckStatus_SearchLightTemperture(int Uartport)
{
printf("发送查询探照灯温度\n");
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_5AFRAME_CHECKSTATUS_SEARCHLIGHT_TEMPERATURE, sendbuf, &send_buf_len);
//2、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len);
}
//开启消息订阅
int JZsdk_Uart_SendDeal_MessageSubcription_Control(int Uartport, int value)
{
printf("发送开启消息订阅%d\n",value);
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_5AFRAME_SEARCHLIGHT_MESSAGE_SUBSCRIPTION_CONTROL, sendbuf, &send_buf_len);
//2、写入数据
sendbuf[10] = value;
//3、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len);
}
/****************************************************************************************************************************************************
*
* 警灯部分
*
****************************************************************************************************************************************************/
/*************
*
* 设置警灯状态
*
* **************/
int JZsdk_Uart_SendDeal_Set_WarningLight_Status(int Uartport,int status, int mode)
{
printf("发送设置警灯状态\n");
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_5AFRAME_WARNINGLIGHT_CONTROL, sendbuf, &send_buf_len);
//2、写入数据
sendbuf[9] = status;
sendbuf[10] = mode;
//3、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len);
}
/*************
*
* 设置警灯颜色
*
* **************/
int JZsdk_Uart_SendDeal_Set_WarningLight_Color(int Uartport,int color1, int color2)
{
printf("发送设置警灯颜色\n");
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_5AFRAME_WARNINGLIGHT_COLOUR, sendbuf, &send_buf_len);
//2、写入数据
sendbuf[9] = color1;
sendbuf[10] = color2;
//3、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len);
}
//查询警灯状态
int JZsdk_Uart_SendDeal_CheckStatus_WarningLightStatus(int Uartport)
{
printf("发送查询警灯状态\n");
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_5AFRAME_CHECKSTATUS_WARNINGLIGHT_STATUS, sendbuf, &send_buf_len);
//2、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len);
}
//查询警灯颜色
int JZsdk_Uart_SendDeal_CheckStatus_WarningLightColor(int Uartport)
{
printf("发送查询警灯颜色\n");
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_5AFRAME_CHECKSTATUS_WARNINGLIGHT_COLOR, sendbuf, &send_buf_len);
//2、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len);
}
/****************************************************************************************************************************************************
*
* 5B类帧
*
****************************************************************************************************************************************************/
/*************
*
* 发送探照灯爆闪频率
*
* **************/
int JZsdk_Uart_SendDeal_SearchLight_Frequency(int Uartport, int Frequency)
{
printf("发送灯光频率帧\n");
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_5BFRAME_CHECKSTATUS_SEARCHLIGHT_FREQUENCY, sendbuf, &send_buf_len);
//2、写入数据
sendbuf[10] = Frequency;
//3、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len);
}
/*************
*
* 发送探照灯模式
*
* **************/
int JZsdk_Uart_SendDeal_SearchLight_Mode(int Uartport, int mode)
{
printf("发送探照灯模式帧\n");
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_5BFRAME_CHECKSTATUS_SEARCHLIGHT_MODE, sendbuf, &send_buf_len);
//2、写入数据
sendbuf[10] = mode;
//3、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len);
}
/*************
*
* 发送探照灯亮度
*
* **************/
int JZsdk_Uart_SendDeal_SearchLight_Lumen(int Uartport,int LeftLumen, int RightLumen)
{
printf("发送探照灯亮度帧\n");
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_5BFRAME_CHECKSTATUS_SEARCHLIGHT_LUMEN, sendbuf, &send_buf_len);
//2、写入数据
sendbuf[9] = LeftLumen;
sendbuf[10] = RightLumen;
//3、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len);
}
/*************
*
* 发送探照灯温度
*
* **************/
int JZsdk_Uart_SendDeal_SearchLight_Temperature(int Uartport, int LeftTemperature, int RightTemperature)
{
printf("发送探照灯温度帧\n");
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_5BFRAME_CHECKSTATUS_SEARCHLIGHT_TEMPERATURE, sendbuf, &send_buf_len);
//2、写入数据
sendbuf[9] = LeftTemperature;
sendbuf[10] = RightTemperature;
//3、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len);
}
/*************
*
* 发送警灯状态
*
* **************/
int JZsdk_Uart_SendDeal_WarningLight_Status(int Uartport, int status, int mode)
{
printf("发送警灯状态帧\n");
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_5BFRAME_CHECKSTATUS_WARNINGLIGHT_STATUS, sendbuf, &send_buf_len);
//2、写入数据
sendbuf[9] = status;
sendbuf[10] = mode;
//3、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len); }
/*************
*
* 发送警灯颜色
*
* **************/
int JZsdk_Uart_SendDeal_WarningLight_Color(int Uartport, int color1, int color2)
{
printf("发送警灯颜色帧\n");
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_5BFRAME_CHECKSTATUS_WARNINGLIGHT_COLOR, sendbuf, &send_buf_len);
//2、写入数据
sendbuf[9] = color1;
sendbuf[10] = color2;
//3、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len);
}
/*************
*
* 发送对外电源状态
*
* **************/
int JZsdk_Uart_SendDeal_OutputPowerStatus(int Uartport, int FrameSequence, int status)
{
printf("发送对外电源状态帧\n");
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_5BFRAME_CHECKSTATUS_OUTPUTPOWER, sendbuf, &send_buf_len);
//2、写入数据
sendbuf[9] = status;
//3、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len);
}
/****************************************************************************************************************************************************
*
* 6B类帧
*
****************************************************************************************************************************************************/
//发送特殊参数
int JZsdk_Uart_Reply_CheckSpecialParameters(int Uartport,int FrameSequence,int type, int value)
{
printf("发送特殊参数帧\n");
unsigned char sendbuf[256];
int send_buf_len;
//1、获取帧样板
JZsdk_GetFrameTemplate(JZ_INSCODE_6BFRAME_CHECK_SPECIAL_PARAMETERS, sendbuf, &send_buf_len);
//2、写入数据
sendbuf[6] = FrameSequence; //帧序列
sendbuf[9] = type;
sendbuf[10] = value;
//3、发送帧
JZsdk_Uart_UartSend(Uartport ,sendbuf, send_buf_len);
}
\ No newline at end of file
... ...
/**
********************************************************************
* @file JZsdk_Uart_SendDeal.h
*
*
*********************************************************************
*/
/* Define to prevent recursive inclusion 避免重定义 -------------------------------------*/
#ifndef JZSDK_IART_SENDDEAL_H
#define JZSDK_IART_SENDDEAL_H
/* Includes ------------------------------------------------------------------*/
#include "JZsdk_Base/JZsdk_Code/JZsdk_Code.h"
#ifdef __cplusplus
extern "C" {
#endif
/* Exported constants --------------------------------------------------------*/
/* 常亮定义*/
/* Exported types ------------------------------------------------------------*/
int JZsdk_Uart_SendDeal_Send_Connect(int Uartport , int FrameSequence,int Version_flag);
int JZsdk_Uart_SendDeal_ConnectFrame(int PortNum);
int JZsdk_Uart_SendDeal_Send_HeartBeatStatus(int Uartport , int FrameSequence,int HeartBeatStatus);
T_JZsdkReturnCode JZsdk_Uart_SendDeal_PowerStatus(int Uartport, int FrameSequence, int status);
T_JZsdkReturnCode JZsdk_Uart_SendDeal_Ask_HeartBeatStatus(int Uartport , int FrameSequence,int HeartBeatStatus);
T_JZsdkReturnCode JZsdk_Uart_SendDeal_Ask_TimeStamp(int Uartport , int FrameSequence);
T_JZsdkReturnCode JZsdk_Uart_SendDeal_SendAllVersion(int Uartport, int FrameSequence, int DeviceID, int MajorVersion, int MinorVersion, int ModifyVersion, int DebugVersion);
T_JZsdkReturnCode JZsdk_Uart_SendDeal_SendAllSerialNumber(int Uartport, int FrameSequence, int DeviceID, unsigned char *SerialNumber, int SerialNumberLen);
T_JZsdkReturnCode JZsdk_Uart_SendDeal_DeviceMessage(int UartPort, int FrameSequence, unsigned char *message, unsigned int messageLen);
int JZsdk_Uart_SendDeal_Reply_SecondaryDeviceName(int Uartport , int device_name, int FrameSequence);
int JZsdk_Uart_SendDeal_QuerySecondaryDeviceName(int Uartport ,int FrameSequence);
int JZsdk_Uart_SendDeal_Reply_Sucesss(int Uartport ,int FrameSequence);
int JZsdk_Uart_SendDeal_Reply_Failure(int Uartport ,int FrameSequence);
T_JZsdkReturnCode JZsdk_Uart_SentDeal_Reply_Musiclist(int UartPort ,int FrameSequence, int music_sum ,char **MusicName ,int *MusicNameLength);
int JZsdk_Uart_SendDeal_Send_PlayStatus_end(int Uartport);
int JZsdk_Uart_SendDeal_Send_PlayStatus(int Uartport ,int num);
int JZsdk_Uart_SendDeal_Reply_MusicName(int Uartport ,char *music_name, int music_name_len);
int JZsdk_Uart_SendDeal_Reply_Volume(int Uartport ,int num);
int JZsdk_Uart_SendDeal_OpusDecodeStatus(int Uartport,int value);
int JZsdk_Uart_SendDeal_Reply_GimbalPitchAngle(int Uartport ,int angle);
int JZsdk_Uart_SendDeal_Set_GimbalPitchAngle(int Uartport ,int angle);
int JZsdk_Uart_SendDeal_Reply_GimbalFineTuningPitch(int Uartport, int FrameSequence, int FineTunigPitch);
int JZsdk_Uart_SendDeal_Set_GimbalFineTuningPitch(int Uartport, int PitchFineTuning);
int JZsdk_Uart_SendDeal_CheckStatus_GimbalFineTuningPitch(int Uartport, int FrameSequence);
int JZsdk_Uart_SendDeal_Set_GimbalLinkageControl(int Uartport,int FrameSequence, int value);
int JZsdk_Uart_SendDeal_CheckStatus_GimbalLinkage(int Uartport,int FrameSequence);
int JZsdk_Uart_SendDeal_GimbalLinkageControl(int Uartport,int FrameSequence,int value);
int JZsdk_Uart_SendDeal_CheckStatus_GimbalAngle(int Uartport ,int FrameSequence);
int JZsdk_Uart_SendDeal_SetGimbalRange(int Uartport,int FrameSequence,int value);
int JZsdk_Uart_SendDeal_Reply_SoftVersion(int Uartport ,char majorVersion, char minorVersion, char modifyVersion, char debugVersion);
int JZsdk_Uart_SendDeal_Reply_LoopPlayStatus(int Uartport ,int status);
int JZsdk_Uart_SendDeal_Reply_TTS_tone(int Uartport ,int tone);
int JZsdk_Uart_SendDeal_Reply_TTS_speed(int Uartport ,int speed);
int JZsdk_Uart_SendDeal_Set_SearchLightFrequency(int Uartport ,int Frequency);
int JZsdk_Uart_SendDeal_SearchLight_Control(int Uartport,int mode);
int JZsdk_Uart_SendDeal_SearchLight_SetLumen(int Uartport, int LeftLumen, int RightLumen);
int JZsdk_Uart_SendDeal_MessageSubcription_Control(int Uartport, int value);
int JZsdk_Uart_SendDeal_Set_WarningLight_Status(int Uartport,int status, int mode);
int JZsdk_Uart_SendDeal_Set_WarningLight_Color(int Uartport,int color1, int color2);
int JZsdk_Uart_SendDeal_SerialNumber(int UartPort, int FrameSequence, char *SerialNumber, int SerialNumberLenth);
int JZsdk_Uart_Reply_CheckSpecialParameters(int Uartport,int FrameSequence,int type, int value);
int JZsdk_Uart_SendDeal_SearchLight_Frequency(int Uartport, int Frequency);
int JZsdk_Uart_SendDeal_SearchLight_Mode(int Uartport, int mode);
int JZsdk_Uart_SendDeal_SearchLight_Lumen(int Uartport,int LeftLumen, int RightLumen);
int JZsdk_Uart_SendDeal_SearchLight_Temperature(int Uartport, int LeftTemperature, int RightTemperature);
//查询探照灯频率
int JZsdk_Uart_SendDeal_Set_SearchLight_CheckStatus_Frequency(int Uartport);
int JZsdk_Uart_SendDeal_Set_SearchLight_CheckStatus_Lumen(int Uartport);
int JZsdk_Uart_SendDeal_Set_SearchLight_CheckStatus_Mode(int Uartport);
int JZsdk_Uart_SendDeal_CheckStatus_LightAttribute(int Uartport);
int JZsdk_Uart_SendDeal_CheckStatus_SearchLightTemperture(int Uartport);
int JZsdk_Uart_SendDeal_WarningLight_Status(int Uartport, int status, int mode);
int JZsdk_Uart_SendDeal_WarningLight_Color(int Uartport, int color1, int color2);
int JZsdk_Uart_SendDeal_CheckStatus_WarningLightStatus(int Uartport);
int JZsdk_Uart_SendDeal_CheckStatus_WarningLightColor(int Uartport);
int JZsdk_Uart_SendDeal_OutputPowerStatus(int Uartport, int FrameSequence, int status);
/* Exported functions --------------------------------------------------------*/
#ifdef __cplusplus
}
#endif
#endif
\ No newline at end of file
... ...
#include <stdio.h>
#include <string.h>
#include <pthread.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <termios.h>
#include <sys/time.h>
#include "JZsdk_uart/Uart_Config.h"
#include "JZsdk_Uart_Recv/JZsdk_Uart_RecvDeal.h"
#include "JZsdkLib.h"
#include "JZsdk_uart/JZsdk_Uart_Input.h"
#include "JZsdk_TaskManagement/TaskManagement.h"
#include "JZsdk_Uart_UartDeal.h"
#if APP_VERSION == APP_PSDK
#include "data_transmission/test_data_transmission.h"
#endif
// 串口参数结构体
typedef struct
{
int UartFd; // 串口识别符
int UartDevName; //串口名
char Message[1024]; // 传递的字符串
int MessageLength; // 字符串的长度
int ResLen; //剩余长度
pthread_mutex_t WriteMutex; // 互斥锁
pthread_mutex_t ReadMutex; // 互斥锁
pthread_cond_t cond; // 条件变量
} s_SerialArgs;
// 再注册串口
typedef struct
{
int UartFd; // 串口识别符
int UartDevName; //串口名
int BitRate; //波特率
} s_SerialInitArg;
//不同串口的描述符
static int Uart_4G_fd;
static int Uart_DEV1_fd;
static int Uart_DEV2_fd;
//用于判断关闭的是哪个串口
static int Uart_4G_Switch = JZ_FLAGCODE_OFF;
static int Uart_DEV1_Switch = JZ_FLAGCODE_OFF;
static int Uart_DEV2_Switch = JZ_FLAGCODE_OFF;
static int Recv_Thread = JZ_FLAGCODE_OFF; //用于判断接收线程是否成功退出
static int Deal_Thread = JZ_FLAGCODE_OFF; //用于判断处理线程是否成功退出
static void *UartDeal_rece(void *arg);
static void *UartDeal_deal(void *arg);
/*********************
*
* 串口接收线程
*
* *****************/
/******************************************************************
初始化串口接收和处理
******************************************************************/
int JZsdk_Uart_UartDeal_Receive(int Uart_fd, int Uart_Dev_name)
{
int ret = 0;
pthread_t Uart_rece_task;
pthread_attr_t task_attribute; // 线程属性
pthread_attr_init(&task_attribute); // 初始化线程属性
pthread_attr_setdetachstate(&task_attribute, PTHREAD_CREATE_DETACHED); // 设置线程属性
if (Uart_Dev_name == UART_DEV_1)
{
Uart_DEV1_fd = Uart_fd;
}
else if (Uart_Dev_name == UART_DEV_2)
{
Uart_DEV2_fd = Uart_fd;
}
else if (Uart_Dev_name == UART_4G)
{
Uart_4G_fd = Uart_fd;
}
s_SerialArgs *parameter = (s_SerialArgs *)malloc(sizeof(s_SerialArgs));
parameter->UartFd = Uart_fd;
parameter->UartDevName = Uart_Dev_name;
parameter->MessageLength = 0;
memset(parameter->Message, 0, sizeof(parameter->Message));
pthread_mutex_init(&parameter->WriteMutex, NULL);
pthread_mutex_init(&parameter->ReadMutex, NULL);
pthread_cond_init(&parameter->cond, NULL);
// 创建串口数据接收线程
pthread_t receiveThread;
pthread_t SerialDealThread;
pthread_attr_t task_attribute1; // 线程属性
pthread_attr_t task_attribute2; // 线程属性
pthread_attr_setdetachstate(&task_attribute1, PTHREAD_CREATE_DETACHED); // 设置线程分离属性
pthread_attr_setdetachstate(&task_attribute2, PTHREAD_CREATE_DETACHED); // 设置线程分离属性
pthread_attr_init(&task_attribute1);
pthread_attr_init(&task_attribute2);
if (pthread_create(&receiveThread, &task_attribute1, UartDeal_rece, parameter) != 0)
{
JZSDK_LOG_ERROR("Failed to create receive thread");
return 1;
}
// 创建串口数据处理线程
if (pthread_create(&SerialDealThread, &task_attribute2, UartDeal_deal, parameter) != 0)
{
JZSDK_LOG_ERROR("Failed to create receive thread");
return 1;
}
}
/***
*
* 串口接收线程
*
* ***/
static void *UartDeal_rece(void *arg)
{
s_SerialArgs *args = (s_SerialArgs *)arg;
struct timeval timeout; // 超时时间
fd_set fs_read;
int Uart_fd = args->UartFd;
FD_ZERO(&fs_read);
FD_SET(Uart_fd, &fs_read);
memset(args->Message, 0, sizeof(args->Message)); // 清空接收数组
args->ResLen = 0;
args->MessageLength = 0;
int *TheadSwtch = NULL;
if (args->UartDevName == UART_4G)
{
TheadSwtch = &Uart_4G_Switch;
Uart_4G_Switch = JZ_FLAGCODE_ON;
}
else if (args->UartDevName == UART_DEV_1)
{
TheadSwtch = &Uart_DEV1_Switch;
Uart_DEV1_Switch = JZ_FLAGCODE_ON;
}
else if (args->UartDevName == UART_DEV_2)
{
TheadSwtch = &Uart_DEV2_Switch;
Uart_DEV2_Switch = JZ_FLAGCODE_ON;
}
while (*TheadSwtch)
{
FD_ZERO(&fs_read);
FD_SET(Uart_fd, &fs_read);
timeout.tv_sec = 0;
timeout.tv_usec = 100000; // 设置为可变的超时时间（100毫秒）
// 检查fs_read套接字是否有数据
int ret = select(Uart_fd + 1, &fs_read, NULL, NULL, &timeout);
if (ret < 0) {
// 发生错误
JZSDK_LOG_ERROR("串口select出错");
args->MessageLength = 0;
args->ResLen = 0;
memset(&(args->Message[0]), 0, sizeof(args->Message));
delayMs(3);
continue;
} else if (ret == 0)
{
// 超时
continue;
}
// 如果有数据就加锁
pthread_mutex_lock(&args->WriteMutex);
// 读取串口内容
int bytesRead = read(Uart_fd, &(args->Message[args->ResLen]), (sizeof(args->Message) - args->ResLen));
if (bytesRead > 0)
{
args->MessageLength = args->ResLen + bytesRead;
// data_len+=bytesRead;
// data_len2+=args->MessageLength;
// printf("当前接收长度%d bytesRead%d bmessage%d reslen%d\n",data_len,bytesRead,data_len2,args->ResLen);
// JZSDK_LOG_INFO("从串口读取到,长度%d",(args->MessageLength-args->ResLen));
// for (int i = 0; i < (args->MessageLength-args->ResLen); i++)
// {
// JZSDK_LOG_OUTPUTHEX("%s",&args->Message[i+args->ResLen]);
// }
args->ResLen = 0;
}
else if (bytesRead == 0)
{
// 串口关闭或者无数据可读
JZSDK_LOG_ERROR("串口读取数据为空");
args->MessageLength = 0;
args->ResLen = 0;
memset(&(args->Message[0]), 0, sizeof(args->Message));
}
else
{
// 读取错误发生
JZSDK_LOG_ERROR("Error reading from serial port");
args->MessageLength = 0;
args->ResLen = 0;
memset(&(args->Message[0]), 0, sizeof(args->Message));
}
// 通知线程
//pthread_cond_signal(&args->cond);
pthread_mutex_unlock(&args->ReadMutex); // 解锁
// 添加适当延时，确保接收缓冲区完全填满
delayMs(3); // 加多了可能导致实时播放难恢复,以及声音间隔 3ms32字节 会向上约1个3ms opus一帧80字节
}
//注销相关
Recv_Thread = JZ_FLAGCODE_OFF;
// 通知线程
//pthread_cond_signal(&args->cond);
pthread_mutex_unlock(&args->WriteMutex); // 解锁
JZSDK_LOG_WARN("串口接收线程被关闭");
}
/***
*
* 串口处理线程
*
* ***/
// 串口数据处理线程函数
static void *UartDeal_deal(void *arg)
{
s_SerialArgs *args = (s_SerialArgs *)arg;
static int ResidualLength = 0; // 未处理数据长度
int *TheadSwtch = NULL;
if (args->UartDevName == UART_4G)
{
TheadSwtch = &Uart_4G_Switch;
Uart_4G_Switch = JZ_FLAGCODE_ON;
}
else if (args->UartDevName == UART_DEV_1)
{
TheadSwtch = &Uart_DEV1_Switch;
Uart_DEV1_Switch = JZ_FLAGCODE_ON;
}
else if (args->UartDevName == UART_DEV_2)
{
TheadSwtch = &Uart_DEV2_Switch;
Uart_DEV2_Switch = JZ_FLAGCODE_ON;
}
//int data_len = 0;
while (*TheadSwtch)
{
// 加锁
pthread_mutex_lock(&args->ReadMutex);
// 等候接收线程的通知
//pthread_cond_wait(&args->cond, &args->mutex);
// data_len+=args->MessageLength;
// printf("当前处理长度%d\n",data_len);
if (args->MessageLength > 0)
{
//清除错误的多余半帧
//前面有帧的长度
if(args->ResLen != 0)
{
//存在第一帧，同时第二轮的数据开头是帧头，则清空前半段第一帧
if ( (args->Message[args->ResLen ] == 0x5A)
&& (args->Message[args->ResLen + 1] == 0x5A)
&& (args->Message[args->ResLen + 2] == 0x77) )
{
int temp_num;
temp_num = args->MessageLength - args->ResLen;
if (temp_num < 0)
{
temp_num = 0;
}
memcpy(args->Message, &(args->Message[args->ResLen]), temp_num);
memset(&args->Message[temp_num], 0, (args->MessageLength - temp_num));
args->MessageLength = temp_num;
args->ResLen = 0;
JZSDK_LOG_ERROR("串口上一帧为不完全帧，舍弃该帧操作");
}
}
// 处理数据
ResidualLength = UartDeal_Recv_interface(0, args->UartFd, args->Message, args->MessageLength);
//如果还有剩余的长度
if (ResidualLength != 0)
{
memcpy(args->Message, &(args->Message[args->MessageLength - ResidualLength]), ResidualLength);
memset(&(args->Message[ResidualLength]), 0, (sizeof(args->Message) - ResidualLength));
args->MessageLength = 0;
args->ResLen = ResidualLength;
}
else
{
memset(args->Message, 0, sizeof(args->Message));
args->MessageLength = 0;
args->ResLen = 0;
}
}
else
{
memset(args->Message, 0, sizeof(args->Message));
args->MessageLength = 0;
args->ResLen = 0;
}
pthread_mutex_unlock(&args->WriteMutex); // 解锁
}
Deal_Thread = JZ_FLAGCODE_OFF;
free(args); //释放掉处理结构体
JZSDK_LOG_WARN("串口处理线程被关闭");
}
/*
数据排出函数
*/
static int UartDeal_Recv_Ouput(int tpye, int fd, unsigned char *getbuf, int ReadLen)
{
//JZSDK_LOG_INFO("UartDeal_Recv_Ouput排出函数%d",ReadLen);
if (tpye == 0)
{
if (fd == Uart_DEV1_fd)
{
JZsdk_Uart_RecvDeal_CharmDeal(UART_DEV_1, getbuf, ReadLen);
}
else if (fd == Uart_DEV2_fd)
{
JZsdk_Uart_RecvDeal_CharmDeal(UART_DEV_2, getbuf, ReadLen);
}
else if (fd == Uart_4G_fd)
{
JZsdk_Uart_RecvDeal_CharmDeal(UART_4G, getbuf, ReadLen);
}
else
{
JZSDK_LOG_ERROR("接收到的数据不是从正常串口来的");
return 0;
}
}
else if (tpye == 1)
{
if (fd == HAL_DATA_TRANSMISSION)
{
JZsdk_Uart_RecvDeal_CharmDeal(HAL_DATA_TRANSMISSION, getbuf, ReadLen);
}
else
{
JZSDK_LOG_ERROR("接收到的数据不是从hal_transmisson来的");
return 0;
}
}
}
/*
处理数据接口，返回没有处理的数据长度
*/
int UartDeal_Recv_interface(int type, int Uart_fd , unsigned char *getbuf, int getbufLen)
{
//0即是串口内容
if (type == 0)
{
if (Uart_fd == Uart_DEV1_fd)
{
JZSDK_LOG_INFO("串口-设备1号,接受到数据+未处理数据的长度len: %d", getbufLen);
}
else if (Uart_fd == Uart_DEV2_fd)
{
JZSDK_LOG_INFO("串口-设备2号,接受到数据+未处理数据的长度len: %d", getbufLen);
}
else if (Uart_fd == Uart_4G_fd)
{
JZSDK_LOG_INFO("串口-设备4G,接受到数据+未处理数据的长度len: %d", getbufLen);
}
else
{
JZSDK_LOG_ERROR("接收到的数据不是从正常串口来的");
return 0;
}
}
else if (type == 1)
{
if (Uart_fd == HAL_DATA_TRANSMISSION)
{
JZSDK_LOG_INFO("hal_data,接受到数据+未处理数据的长度len: %d", getbufLen);
}
else
{
JZSDK_LOG_ERROR("接收到的数据不是从hal_transmisson来的");
return 0;
}
}
// 是否要打印内容
// printf("getbuf: %s\n", getbuf);
// for (int i = 0; i < getbufLen; i++)
// {
// printf("%x ", getbuf[i]);
// }
// printf("\n");
int HaveReadLen = 0; // 已读长度
int HaveDealLen = 0; // 已处理长度
int FrameFlag = 0; // 帧标志
int FrameLen = 0;
// 检索出帧数据
// 遍历数据找帧头，直到数据的倒数第4位，如果这里有帧，帧存在帧头3位+数据长度两位
//printf("遍历开始\n");
for (HaveReadLen = 0; HaveReadLen < (getbufLen - 4); )
{
// 1、如果找到 5A 5B 6A 6B 判断是否是帧
switch (getbuf[HaveReadLen])
{
case 0x5A:
if ( (getbuf[HaveReadLen + 1] == 0x5A) && (getbuf[HaveReadLen + 2] == 0x77))
{
//JZSDK_LOG_INFO("输入5A");
FrameFlag = 0x5A;
break;
}
else
{
FrameFlag = 0x00;
break;
}
case 0x5B:
if ((getbuf[HaveReadLen + 1] == 0x5B) && (getbuf[HaveReadLen + 2] == 0x77))
{
//JZSDK_LOG_INFO("输入5B");
FrameFlag = 0x5B;
break;
}
else
{
FrameFlag = 0x00;
break;
}
case 0x6A:
if ((getbuf[HaveReadLen + 1] == 0x6A) && (getbuf[HaveReadLen + 2] == 0x77))
{
//JZSDK_LOG_INFO("输入6A");
FrameFlag = 0x6A;
break;
}
else
{
FrameFlag = 0x00;
break;
}
case 0x6B:
if ((getbuf[HaveReadLen + 1] == 0x6B) && (getbuf[HaveReadLen + 2] == 0x77))
{
//JZSDK_LOG_INFO("输入6B");
FrameFlag = 0x6B;
break;
}
else
{
FrameFlag = 0x00;
break;
}
default:
FrameFlag = 0x00;
break;
}
if (FrameFlag == 0)
{
if (HaveReadLen >= (getbufLen - 5))
{
//JZSDK_LOG_INFO("没有找到帧头");
}
HaveReadLen++;
continue;
}
// 3、如果有帧头,则先判断前面有没有多余的数据残留,并将其排出到处理线程
if ((HaveReadLen - HaveDealLen) > 0)
{
//JZSDK_LOG_INFO("残余处理%d",(HaveReadLen - HaveDealLen));
UartDeal_Recv_Ouput(type, Uart_fd, &getbuf[HaveDealLen], (HaveReadLen - HaveDealLen));
HaveDealLen = HaveReadLen;
}
// 4、检查帧长度是否超过数组剩余内容
FrameLen = (((int)getbuf[HaveReadLen+3]) << 8) + (int)getbuf[HaveReadLen+4];
if (FrameLen > (getbufLen - HaveReadLen))
{
JZSDK_LOG_DEBUG("当前帧长度位长度%d 超出剩余帧长度%d ",FrameLen,(getbufLen - HaveReadLen));
// 直接跳出for循环
break;
}
//5、检查帧长度是否为0，避免卡死接收串口
if (FrameLen == 0)
{
JZSDK_LOG_ERROR("严重错误，接收到的帧出现长度为空");
//直接清空接收的数组
return 0;
}
// 6、以上检查都没问题，则正常输出帧
//JZSDK_LOG_INFO("正常输出帧%d",FrameLen);
UartDeal_Recv_Ouput(type, Uart_fd, &getbuf[HaveReadLen], FrameLen);
HaveReadLen = HaveReadLen + FrameLen;
HaveDealLen = HaveReadLen;
JZSDK_LOG_INFO("framelen%d read%d [read]:%x get%d",FrameLen ,HaveReadLen, getbuf[HaveReadLen], getbufLen);
FrameLen = 0;
FrameFlag = 0;
}
//JZSDK_LOG_INFO("UartDeal_Recv_Ouput%d %d %d",HaveDealLen,HaveReadLen , getbufLen);
// 如果没有数据残留了
if (HaveDealLen >= getbufLen)
{
//printf("HaveReadLen:%d HaveDealLen%d getbufLen:%d\n",HaveReadLen,HaveDealLen,getbufLen);
return 0;
}
// 如果是有帧头的情况跳出的，说明是帧被切了，需要返回帧长度给接收线程
if (FrameFlag != 0) //bu
{
// 1、判断帧的长度会不会不合理，帧的长度最大为文件名帧，其长度为9+2+400
if (FrameLen > (9 + 2 + 400))
{
// 将其排出不返回
UartDeal_Recv_Ouput(type, Uart_fd, &getbuf[HaveReadLen], (getbufLen - HaveReadLen));
HaveDealLen = HaveReadLen;
return 0;
}
printf("切帧返回%d\n",(getbufLen - HaveDealLen));
// 2、如果合理，则返回剩余长度
return (getbufLen - HaveDealLen);
}
// 如果是没有帧头的情况下跳出的
// 1、先检查 未经检查最后 最后4 3位
//如果还有4 或者 3 位未处理
for (; HaveReadLen < getbufLen - 2; HaveReadLen++)
{
if ((getbuf[HaveReadLen] == 0x5A && getbuf[HaveReadLen + 1] == 0x5A && getbuf[HaveReadLen + 2] == 0x77) ||
(getbuf[HaveReadLen] == 0x5B && getbuf[HaveReadLen + 1] == 0x5B && getbuf[HaveReadLen + 2] == 0x77) ||
(getbuf[HaveReadLen] == 0x6A && getbuf[HaveReadLen + 1] == 0x6A && getbuf[HaveReadLen + 2] == 0x77) ||
(getbuf[HaveReadLen] == 0x6B && getbuf[HaveReadLen + 1] == 0x6B && getbuf[HaveReadLen + 2] == 0x77))
{
if ((HaveReadLen - HaveDealLen) > 0)
{
UartDeal_Recv_Ouput(type, Uart_fd, &getbuf[HaveDealLen], (HaveReadLen - HaveDealLen));
HaveDealLen = HaveReadLen;
}
printf("检查最后3 4位%d\n",(getbufLen - HaveDealLen));
return (getbufLen - HaveDealLen);
}
}
// 2、检查最后两位
// 如果还有两位未处理
for (; HaveReadLen < getbufLen - 1; HaveReadLen++)
{
if ((getbuf[HaveReadLen] == 0x5A && getbuf[HaveReadLen + 1] == 0x5A) ||
(getbuf[HaveReadLen] == 0x5B && getbuf[HaveReadLen + 1] == 0x5B) ||
(getbuf[HaveReadLen] == 0x6A && getbuf[HaveReadLen + 1] == 0x6A) ||
(getbuf[HaveReadLen] == 0x6B && getbuf[HaveReadLen + 1] == 0x6B))
{
if ((HaveReadLen - HaveDealLen) > 0)
{
UartDeal_Recv_Ouput(type, Uart_fd, &getbuf[HaveDealLen], (HaveReadLen - HaveDealLen));
HaveDealLen = HaveReadLen;
}
printf("检查最后两位%d\n",(getbufLen - HaveDealLen));
return (getbufLen - HaveDealLen);
}
}
// 2、检查最后一位
// 如果还有一位未处理
for (; HaveReadLen < getbufLen - 0; HaveReadLen++)
{
// 1、检查最后一位
if (getbuf[HaveReadLen] == 0x5A ||
getbuf[HaveReadLen] == 0x5B ||
getbuf[HaveReadLen] == 0x6A ||
getbuf[HaveReadLen] == 0x6B)
{
if ((HaveReadLen - HaveDealLen) > 0)
{
UartDeal_Recv_Ouput(type, Uart_fd, &getbuf[HaveDealLen], (HaveReadLen - HaveDealLen));
HaveDealLen = HaveReadLen;
}
printf("检查最后一位%d\n",(getbufLen - HaveDealLen));
return (getbufLen - HaveDealLen);
}
}
// 都检查完了，还是没有帧头在里面, 将剩余的所有数据排出
UartDeal_Recv_Ouput(type, Uart_fd, &getbuf[HaveDealLen], (HaveReadLen - HaveDealLen));
printf("检查完毕,排出剩余数据HaveReadLen:%d HaveDealLen%d getbufLen:%d\n",HaveReadLen,HaveDealLen,getbufLen);
return 0;
}
/**********
*
* 无任务发送函数
*
* ***********/
T_JZsdkReturnCode JZsdk_Uart_UartSend_NotTask(int Uart_Name, unsigned char *str, int str_lenth)
{
if (Uart_Name == UART_4G)
{
printf("向4G设备发送\n");
write(Uart_4G_fd, str, str_lenth);
}
else if (Uart_Name == UART_DEV_1)
{
printf("向串口1号设备发送\n");
write(Uart_DEV1_fd, str, str_lenth);
}
else if (Uart_Name = UART_DEV_2)
{
printf("向串口2号设备发送\n");
write(Uart_DEV2_fd, str, str_lenth);
}
return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}
typedef struct {
char* str;
int str_lenth;
int Uart_name;
} UartSendData;
/**********
*
* 发送任务函数
*
* ***********/
static void JZsdk_Uart_UartSend_Task(void *data)
{
UartSendData* taskData = (UartSendData*)data;
if (taskData->Uart_name == UART_4G)
{
printf("向4G设备发送\n");
write(Uart_4G_fd, taskData->str, taskData->str_lenth);
}
else if (taskData->Uart_name == UART_DEV_1)
{
printf("向串口1号设备发送\n");
write(Uart_DEV1_fd, taskData->str, taskData->str_lenth);
}
else if (taskData->Uart_name == UART_DEV_2)
{
printf("向串口2号设备发送\n");
write(Uart_DEV2_fd, taskData->str, taskData->str_lenth);
}
else if (taskData->Uart_name == HAL_DATA_TRANSMISSION)
{
#if APP_VERSION == APP_PSDK
DJI_Low_Data_Trans(taskData->str, taskData->str_lenth);
#endif
}
free(taskData->str);
taskData->str = NULL;
free(taskData);
taskData = NULL;
}
/****************
*
*
* 发送函数
*
* ****************/
T_JZsdkReturnCode JZsdk_Uart_UartSend(int UartPort, unsigned char *send, int num)
{
UartSendData *senddata = (UartSendData*)malloc(sizeof(UartSendData));
if (senddata == NULL) {
// 处理内存分配失败的情况
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}
senddata->str = (unsigned char*)malloc(num + 1); // 分配足够的内存用于保存字符串
if (senddata->str == NULL) {
// 处理内存分配失败的情况
free(senddata); // 释放之前分配的内存
senddata = NULL;
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}
senddata->str_lenth = num;
senddata->Uart_name = UartPort;
memcpy(senddata->str, send, num);
T_JZsdkReturnCode ret = TaskManagement_SubmitTask(JZsdk_Uart_UartSend_Task, (void *)senddata);
if (ret == JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE)
{
free(senddata->str);
senddata->str = NULL;
free(senddata);
senddata = NULL;
return ret;
}
return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}
/****************
*
* 串口识别符关闭
*
* ****************/
int JZsdk_Uart_CloseUartFd(int UartPort)
{
if (UartPort == UART_4G)
{
JZSDK_LOG_INFO("关闭4g串口识别符\n");
close(Uart_4G_fd);
return 0;
}
else if (UartPort == UART_DEV_1)
{
JZSDK_LOG_INFO("关闭串口1识别符\n");
close(Uart_DEV1_fd);
return 0;
}
else if (UartPort == UART_DEV_2)
{
JZSDK_LOG_INFO("关闭串口2识别符\n");
close(Uart_DEV1_fd);
return 0;
}
}
static void *CloseUart(void *arg)
{
s_SerialInitArg *args = (s_SerialInitArg *)arg;
int UartPort = args->UartDevName;
int BitRate = args->BitRate;
Recv_Thread = JZ_FLAGCODE_ON;
Deal_Thread = JZ_FLAGCODE_ON;
if (UartPort == UART_4G)
{
JZSDK_LOG_INFO("关闭4g线程\n");
Uart_4G_Switch = JZ_FLAGCODE_OFF;
}
else if (UartPort == UART_DEV_1)
{
JZSDK_LOG_INFO("关闭串口1线程\n");
Uart_DEV1_Switch = JZ_FLAGCODE_OFF;
}
else if (UartPort == UART_DEV_2)
{
JZSDK_LOG_INFO("关闭串口2线程\n");
Uart_DEV2_Switch = JZ_FLAGCODE_OFF;
}
else
{
return 0;
}
while ( (Recv_Thread != JZ_FLAGCODE_OFF) && (Deal_Thread != JZ_FLAGCODE_OFF))
{
delayMs(1);
}
delayMs(100);
//保证全部注销后
JZSDK_LOG_INFO("串口注销完毕");
//创建新的
JZsdk_Uart_SecondInit(UartPort, BitRate);
free(args);
}
/****************
*
* 线程关闭, 并创建一个新的串口
*
* ****************/
int JZsdk_Uart_CloseUartThead(int UartPort, int BitRate)
{
//将串口描述符关闭
JZsdk_Uart_CloseUartFd(UartPort);
s_SerialInitArg *parameter = (s_SerialInitArg *)malloc(sizeof(s_SerialInitArg));
parameter->UartDevName = UartPort;
parameter->BitRate = BitRate;
// 创建关闭串口的线程
pthread_t CloseThread;
pthread_attr_t task_attribute; // 线程属性
pthread_attr_setdetachstate(&task_attribute, PTHREAD_CREATE_DETACHED); // 设置线程分离属性
pthread_attr_init(&task_attribute);
// 创建串口数据处理线程
if (pthread_create(&CloseThread, &task_attribute, CloseUart, parameter) != 0)
{
JZSDK_LOG_ERROR("Failed to create receive thread");
return 1;
}
}
\ No newline at end of file
... ...
/**
********************************************************************
* @file JZsdk_Uart_UartDeal.h
* JZsdk_Uart_UartDeal的头文件
*
*********************************************************************
*/
/* Define to prevent recursive inclusion 避免重定义 -------------------------------------*/
#ifndef JZSDK_UART_UARTDEAL_H
#define JZSDK_UART_UARTDEAL_H
/* Includes ------------------------------------------------------------------*/
#ifdef __cplusplus
extern "C" {
#endif
/* Exported constants --------------------------------------------------------*/
/* 常亮定义*/
#include "JZsdk_Base/JZsdk_Code/JZsdk_Code.h"
/* Exported types ------------------------------------------------------------*/
/* Exported functions --------------------------------------------------------*/
T_JZsdkReturnCode JZsdk_Uart_UartSend(int UartPort ,unsigned char *send, int num);
int JZsdk_Uart_UartDeal_Receive(int Uart_fd, int Uart_Dev_name);
int JZsdk_Uart_CloseUartFd(int UartPort);
int JZsdk_Uart_CloseUartThead(int UartPort, int BitRate);
T_JZsdkReturnCode JZsdk_Uart_UartSend_NotTask(int Uart_Name, unsigned char *str, int str_lenth);
int UartDeal_Recv_interface(int type, int Uart_fd , unsigned char *getbuf, int getbufLen);
#ifdef __cplusplus
}
#endif
#endif
... ...
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <termios.h>
#include <sys/time.h>
#include "JZsdkLib.h"
/*******************************************
*
* 使能一个串口 返回设备号
* 变量1 串口设备名
变量2 比特率
返回 int 设备号
例子: UartDeal_Base_CreateReceive("/dev/ttyS2", 115200)
*******************************************/
int UartConnection_UartEnabled(char *UartDev, int BitRate)
{
int ret = 0;
int UartReceive_fd = 0;
pthread_t UartReceive_task;
char PrintStr[256];
//1、读取串口
UartReceive_fd = open(UartDev,O_RDWR);
if(UartReceive_fd < 0)
{
snprintf(PrintStr, 256, "打开%s失败", UartDev);
printf("%s\n", PrintStr);
return -1;
}
else
{
snprintf(PrintStr, 256, "打开%s成功", UartDev);
printf("%s\n", PrintStr);
}
//2、获取终端信息
struct termios options;
if(tcgetattr(UartReceive_fd,&options)!= 0) //获取终端信息
{
printf("获取终端信息失败！\n");
return -1;
}
//3、设置比特率
switch (BitRate)
{
case 115200:
cfsetispeed(&options, B115200);
cfsetospeed(&options, B115200);
break;
case 230400:
cfsetispeed(&options, B230400);
cfsetospeed(&options, B230400);
break;
case 460800:
cfsetispeed(&options, B460800);
cfsetospeed(&options, B460800);
break;
case 921600:
cfsetispeed(&options, B921600);
cfsetospeed(&options, B921600);
break;
case 1000000:
cfsetispeed(&options, B1000000);
cfsetospeed(&options, B1000000);
break;
default:
return -1;
break;
}
options.c_cflag |= (unsigned) CLOCAL;
options.c_cflag |= (unsigned) CREAD;
options.c_cflag &= ~(unsigned) CRTSCTS;
options.c_cflag &= ~(unsigned) CSIZE;
options.c_cflag |= (unsigned) CS8;
options.c_cflag &= ~(unsigned) PARENB;
options.c_iflag &= ~(unsigned) INPCK;
options.c_cflag &= ~(unsigned) CSTOPB;
options.c_oflag &= ~(unsigned) OPOST;
options.c_lflag &= ~((unsigned) ICANON | (unsigned) ECHO | (unsigned) ECHOE | (unsigned) ISIG);
options.c_iflag &= ~((unsigned) BRKINT | (unsigned) ICRNL | (unsigned) INPCK | (unsigned) ISTRIP | (unsigned) IXON);
options.c_cc[VTIME] = 0;
options.c_cc[VMIN] = 0;
tcflush(UartReceive_fd,TCIOFLUSH); //刷清输入、输出队列
tcsetattr(UartReceive_fd,TCSAFLUSH,&options); //串口设置使能
JZSDK_LOG_INFO("使能串口 波特率%d成功",BitRate);
return UartReceive_fd;
}
\ No newline at end of file
... ...
/**
********************************************************************
* @file UartDeal_Base.h
* UartDeal_Base的头文件
*
*********************************************************************
*/
/* Define to prevent recursive inclusion 避免重定义 -------------------------------------*/
#ifndef UARTDEAL_BASE_H
#define UARTDEAL_BASE_H
/* Includes ------------------------------------------------------------------*/
#ifdef __cplusplus
extern "C" {
#endif
/* Exported constants --------------------------------------------------------*/
/* 常亮定义*/
/* Exported types ------------------------------------------------------------*/
/* Exported functions --------------------------------------------------------*/
int UartConnection_UartEnabled(char *UartDev, int BitRate);
#ifdef __cplusplus
}
#endif
#endif
... ...
/**
********************************************************************
* @file Uart_Config.h
* Uart_Config的头文件
* 用于管理串口的基本信息
*********************************************************************
*/
/* Define to prevent recursive inclusion 避免重定义 -------------------------------------*/
#ifndef UART_CONFIG_H
#define UART_CONFIG_H
/* Includes ------------------------------------------------------------------*/
#include "BaseConfig.h"
#ifdef __cplusplus
extern "C" {
#endif
/* Exported constants --------------------------------------------------------*/
/* 常亮定义*/
/* Exported types ------------------------------------------------------------*/
/* Exported functions --------------------------------------------------------*/
#ifdef __cplusplus
}
#endif
#endif
... ...
#include <stdio.h>
#include <stdlib.h>
#include "version_choose.h"
#include "JZsdkLib.h"
#include "./JZsdk_usb_bulk.h"
#if USB_CONFIG_STATUS == VERSION_SWITCH_ON
#include <libusb-1.0/libusb.h>
#endif
#define LINUX_USB_BULK_TRANSFER_TIMEOUT_MS (50)
#define LINUX_USB_BULK_TRANSFER_WAIT_FOREVER (-1)
typedef struct JZsdk_T_HalUsbBulkObj{
#if USB_CONFIG_STATUS == VERSION_SWITCH_ON
libusb_device_handle *handle; //usb的权柄
#endif
unsigned int interfaceNum; //接口编号
int isUsbHost;
unsigned int pid; //pid号码 用于标识产商
unsigned int vid; //vid号码 用于标识设备名
unsigned int PointIn; //读取输入引脚
unsigned int PointOut; //写入输出引脚
}JZsdk_T_HalUsbBulkObj;
T_JZsdkReturnCode JZsdk_HalUsbBulk_Init(void **index, int interfaceNum, int isUsbHost,
unsigned int pid, unsigned int vid, unsigned int PointIn, unsigned int PointOut)
{
#if USB_CONFIG_STATUS == VERSION_SWITCH_ON
//创建一个usb信息结构体
struct JZsdk_T_HalUsbBulkObj *UsbBulkObj = NULL;
//为usb信息结构体注册内存
UsbBulkObj = (struct JZsdk_T_HalUsbBulkObj *)malloc(sizeof(struct JZsdk_T_HalUsbBulkObj));
if (UsbBulkObj == NULL) {
JZSDK_LOG_ERROR("HalUsbBulk注册失败");
return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
}
UsbBulkObj->handle = NULL;
UsbBulkObj->interfaceNum = interfaceNum;
UsbBulkObj->isUsbHost = isUsbHost;
UsbBulkObj->pid = pid;
UsbBulkObj->vid = vid;
UsbBulkObj->PointIn = PointIn;
UsbBulkObj->PointOut = PointOut;
int ret;
ret = libusb_init(NULL);
if (ret < 0) {
JZSDK_LOG_ERROR("init usb bulk failed, errno = %d", ret);
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}
UsbBulkObj->handle = libusb_open_device_with_vid_pid(NULL, UsbBulkObj->vid, UsbBulkObj->pid);
if(UsbBulkObj->handle == NULL) {
JZSDK_LOG_ERROR("Open Device Error\n");
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}
// ret = libusb_detach_kernel_driver(UsbBulkObj->handle, UsbBulkObj->interfaceNum);
// if (ret < 0)
// {
// printf("销毁usb任务失败\n");
// }
ret = libusb_claim_interface(UsbBulkObj->handle, UsbBulkObj->interfaceNum);
if(ret < 0) {
JZSDK_LOG_ERROR("Cannot Claim Interface\n");
libusb_close(UsbBulkObj->handle);
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}
JZSDK_LOG_INFO("USB 初始化完成\n");
*index = (void *)UsbBulkObj;
#endif
return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}
T_JZsdkReturnCode JZsdk_HalUsbBulk_DeInit(void **index)
{
// struct libusb_device_handle *handle = NULL;
// int32_t ret;
// T_DjiOsalHandler *osalHandler = DjiPlatform_GetOsalHandler();
// if (usbBulkHandle == NULL) {
// return DJI_ERROR_SYSTEM_MODULE_CODE_SYSTEM_ERROR;
// }
// handle = ((T_HalUsbBulkObj *) usbBulkHandle)->handle;
// 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);
// free(usbBulkHandle);
return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}
T_JZsdkReturnCode JZsdk_HalUsbBulk_WriteData(void **index ,const unsigned char *buf, unsigned int len, unsigned int *realLen)
{
struct JZsdk_T_HalUsbBulkObj *UsbBulkObj = (struct JZsdk_T_HalUsbBulkObj *) *index;
int ret;
int actualLen = 0;
#if USB_CONFIG_STATUS == VERSION_SWITCH_ON
ret = libusb_bulk_transfer(UsbBulkObj->handle, UsbBulkObj->PointOut,
(unsigned char *) buf, len, &actualLen, LINUX_USB_BULK_TRANSFER_TIMEOUT_MS);
if (ret < 0) {
JZSDK_LOG_ERROR("Write usb bulk data failed, errno = %d", ret);
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}
#endif
*realLen = actualLen;
return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}
T_JZsdkReturnCode JZsdk_HalUsbBulk_ReadData(void **index ,unsigned char *buf, unsigned int len,unsigned int *realLen)
{
struct JZsdk_T_HalUsbBulkObj *UsbBulkObj = (struct JZsdk_T_HalUsbBulkObj *) *index;
int ret;
int actualLen = 0;
#if USB_CONFIG_STATUS == VERSION_SWITCH_ON
ret = libusb_bulk_transfer(UsbBulkObj->handle, UsbBulkObj->PointIn,
buf, len, &actualLen, LINUX_USB_BULK_TRANSFER_WAIT_FOREVER);
if (ret < 0) {
JZSDK_LOG_ERROR("Read usb bulk data failed, errno = %d", ret);
return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}
#endif
*realLen = actualLen;
return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}
// T_DjiReturnCode HalUsbBulk_GetDeviceInfo(T_DjiHalUsbBulkDeviceInfo *deviceInfo)
// {
// //attention: this interface only be called in usb device mode.
// deviceInfo->vid = LINUX_USB_VID;
// deviceInfo->pid = LINUX_USB_PID;
// // This bulk channel is used to obtain DJI camera video stream and push 3rd-party camera video stream.
// deviceInfo->channelInfo[DJI_HAL_USB_BULK_NUM_0].interfaceNum = LINUX_USB_BULK1_INTERFACE_NUM;
// deviceInfo->channelInfo[DJI_HAL_USB_BULK_NUM_0].endPointIn = LINUX_USB_BULK1_END_POINT_IN;
// deviceInfo->channelInfo[DJI_HAL_USB_BULK_NUM_0].endPointOut = LINUX_USB_BULK1_END_POINT_OUT;
// // This bulk channel is used to obtain DJI perception image and download camera media file.
// deviceInfo->channelInfo[DJI_HAL_USB_BULK_NUM_1].interfaceNum = LINUX_USB_BULK2_INTERFACE_NUM;
// deviceInfo->channelInfo[DJI_HAL_USB_BULK_NUM_1].endPointIn = LINUX_USB_BULK2_END_POINT_IN;
// deviceInfo->channelInfo[DJI_HAL_USB_BULK_NUM_1].endPointOut = LINUX_USB_BULK2_END_POINT_OUT;
// return DJI_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
// }
// int JZ_HalUsbBulk_GetDeviceInfo() {
// libusb_device **devs; // 指针的指针，用于存储设备列表
// libusb_context *ctx = NULL; // libusb上下文
// libusb_device_handle *dev_handle; // 设备句柄
// int r; // 用于存储返回值
// ssize_t cnt; // 设备数量
// libusb_device_descriptor desc; // 设备描述符
// libusb_config_descriptor *config_desc; // 配置描述符
// const libusb_interface *intf; // 接口
// const libusb_interface_descriptor *intf_desc; // 接口描述符
// int i, j;
// // 初始化libusb库
// r = libusb_init(&ctx);
// if(r < 0) {
// printf("初始化libusb失败\n");
// return 1;
// }
// libusb_set_debug(ctx, 3); // 设置调试级别
// // 获取USB设备列表
// cnt = libusb_get_device_list(ctx, &devs);
// if(cnt < 0) {
// printf("获取设备列表失败\n");
// libusb_exit(ctx);
// return 1;
// }
// // 遍历设备列表
// printf("找到了 %zd 个设备\n", cnt);
// for (i = 0; i < cnt; i++) {
// dev_handle = libusb_open_device_with_vid_pid(ctx, VENDOR_ID, PRODUCT_ID); // 使用厂商ID和产品ID打开设备
// if (dev_handle == NULL) {
// printf("无法打开设备\n");
// continue;
// }
// // 获取设备描述符
// r = libusb_get_device_descriptor(devs[i], &desc);
// if (r < 0) {
// printf("获取设备描述符失败\n");
// libusb_close(dev_handle);
// continue;
// }
// printf("设备描述符：\n");
// printf(" 厂商ID: 0x%04x\n", desc.idVendor);
// printf(" 产品ID: 0x%04x\n", desc.idProduct);
// // 获取活动配置的描述符
// r = libusb_get_active_config_descriptor(devs[i], &config_desc);
// if (r < 0) {
// printf("获取配置描述符失败\n");
// libusb_close(dev_handle);
// continue;
// }
// // 遍历配置中的接口
// for (j = 0; j < config_desc->bNumInterfaces; j++) {
// intf = &config_desc->interface[j];
// printf("接口编号: %d\n", intf->bInterfaceNumber);
// // 遍历接口中的设置
// for (int k = 0; k < intf->num_altsetting; k++) {
// intf_desc = &intf->altsetting[k];
// // 这里可以进一步处理接口描述符的信息，比如端点等
// printf(" 设置编号: %d\n", intf_desc->bAlternateSetting);
// // ...
// }
// }
// libusb_free_config_descriptor(config_desc); // 释放配置描述符
// libusb_close(dev_handle); // 关闭设备句柄
// }
// libusb_free_device_list(devs, 1); // 释放设备列表
// libusb_exit(ctx); // 退出libusb库
// return 0;
// }
\ No newline at end of file
... ...
/**
********************************************************************
* @file JZsdk_usb_bulk.h
* JZsdk_usb_bulk的头文件
*
*********************************************************************
*/
/* Define to prevent recursive inclusion 避免重定义 -------------------------------------*/
#ifndef JZSDK_USB_BULK_H
#define JZSDK_USB_BULK_H
/* Includes ------------------------------------------------------------------*/
#include "JZsdk_Base/JZsdk_Code/JZsdk_Code.h"
#ifdef __cplusplus
extern "C" {
#endif
#define LINUX_USB_VID (0x04b4)
#define LINUX_USB_PID (0x00f1)
#define USB_OUT_POINT (0x02)
#define USB_IN_POINT (0x86)
T_JZsdkReturnCode JZsdk_HalUsbBulk_WriteData(void **index ,const unsigned char *buf, unsigned int len, unsigned int *realLen);
T_JZsdkReturnCode JZsdk_HalUsbBulk_ReadData(void **index ,unsigned char *buf, unsigned int len,unsigned int *realLen);
T_JZsdkReturnCode JZsdk_HalUsbBulk_Init(void **index, int interfaceNum, int isUsbHost,
unsigned int pid, unsigned int vid, unsigned int PointIn, unsigned int PointOut);
#ifdef __cplusplus
}
#endif
#endif
... ...
#更新日志
... ...
#!/bin/bash
#1、输入分支名，账号，密码，描述信息
branch_name="dev_00.00.02.00"
Account="PanHaoBin"
PassWord="ookk3866"
Message="更新"
ProjectName="114.132.166.25:8099/PanHaoBin/JZSDK_Linux.git"
# 检查分支是否存在
if git rev-parse --verify "$branch_name" >/dev/null 2>&1; then
echo "分支 $branch_name 存在"
else
echo "分支 $branch_name 不存在"
# 创建新分支
git branch "$branch_name"
fi
# 切换到新创建的分支
git checkout "$branch_name"
#选择上传内容
#git add -n . | grep -v "project_build" | xargs git add
git add .
# 写入描述/注释
git commit -m "$Message"
# 设置远程仓库的URL
remote_url="http://$Account:$PassWord@$ProjectName"
# 上传到远程仓库
git push "$remote_url" "$branch_name"
echo "推送完成"
... ...