跳转至

SCL编程手册（C/C++）

简介

本篇章介绍SCL接口api使用，主要头文件是SCL目录下的头文件。

源文件组织结构

.
├── base
│   └── BsdClient.h
├── board
│   ├── Backlight.h
│   ├── Beep.h
│   ├── BoardEventDefine.h
│   ├── board.h
│   ├── CommuParam.h
│   ├── Cpu.h
│   ├── Device.h
│   ├── FbImage.h
│   ├── Flash.h
│   ├── Keyboard.h
│   ├── LedLamp.h
│   ├── SerialPort.h
│   ├── TimeZone.h
│   ├── Touch.h
│   └── Usb.h
├── net
│   ├── NetEventDefine.h
│   ├── NetT4G.h
│   ├── NetTcommon.h
│   ├── netT.h
│   └── NetTwifi.h
├── pb
│   ├── bipc.pb.h
│   ├── ibox.search.pb.h
│   ├── pb.h
│   ├── sysd.manager.pb.h
│   ├── sysd.notify.pb.h
│   ├── sysd.shell.pb.h
│   └── udp2g.pb.h
├── scl.h
├── serach
│   ├── ProtoFrame.h
│   ├── SearchClient.h
│   └── SearchServer.h
├── shell
│   └── shell.h
└── udev
    ├── UdevClient.h
    ├── UdevEventDefine.h
    └── UsbInputDevice.h

准备工作

Windows

下载SDK压缩包，解压到你的工程目录或者其余任意目录 检查目录中是否包含上述内容

Linux

下载SDK压缩包，解压到你的工程目录或者其余任意目录 检查目录中是否包含上述内容

SDK说明

WeconCNC SDK使用统一的命名空间scl

背光管理接口类型定义

FUNC_ON_BACKLIGHT_INFO：是一个回调函数类型，它主要用于处理背光的相关信息。

using FUNC_ON_BACKLIGHT_INFO = std::function<int(const BACKLIGHT_INFO_T &stBackLightInfo, void *lpParameter)>;

*FUNC_ON_BACKLIGHT_STATUS *： 是一个回调函数类型，它用于处理背光的开关状态。

using FUNC_ON_BACKLIGHT_STATUS = std::function<int(const bool &bBacklightStatus, void *lpParameter)>;

BACKLIGHT_INFO_T：定义了与背光设置相关的多个参数，用于控制和管理显示设备的背光状态。

bool bEnable{false};            /*true 启用定时熄暗屏功能， false 常亮*/
int nBacklightTime{1200};       /*熄暗屏幕时间,单位:秒*/
int nBacklightBrightness{100};  /*背光亮度值*/
int nMaxBacklight{100};         /*只读- 用于查看当前系统允许配置的最大亮度值*/

背光运行模式

enum {
    BL_RUN_MODE_STOP    = 0,        //stop
    BL_RUN_MODE_START   = 1 << 0,   //start
};

背光管理接口

backlightEnable

定义：int backlightEnable(const bool bEnable);

说明：启用定时熄暗屏功能

参数：【IN】bEnable - 是否启用定时熄暗屏功能。true 启用定时熄暗屏功能，false 常亮。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
bool bEnable = false;
int ret = scl::backlightEnable(bEnable);
if (ret == 0) {
    printf("Backlight is successfully disabled.\n");
} else {
    printf("Failed to disable backlight.\n");
}

backlightTime

定义：int backlightTime(const int nBacklightTime);

说明：熄暗屏幕时间

参数：【IN】nBacklightTime - 设置熄暗屏幕的时间，单位为秒。nBacklightTime 为 0 表示常亮，不进行定时熄暗。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
int nBacklightTime = 5;
if (scl::backlightTime(nBacklightTime) != 0) {
    printf("Failed to set backlight time to %d seconds.\n", nBacklightTime);
} else {
    printf("Backlight time set to %d seconds successfully.\n", nBacklightTime);
}

backlightBrightness

定义：int backlightBrightness(const int nBacklightBrightness);

说明：设置背光亮度值

参数：【IN】nBacklightBrightness - 设置背光亮度值，取值范围通常是 0 到 100，其中 0 表示最暗，100 表示最亮。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
int nBacklightBrightness = 80;
int ret = backlightBrightness(nBacklightBrightness);
if (ret == 0) {
    printf("Backlight brightness set to %d%% successfully.\n", nBacklightBrightness);
} else {
    printf("Failed to set backlight brightness to %d%%. Error code: %d\n", nBacklightBrightness, ret);
}

getMaxBacklight

定义：int getMaxBacklight(int &nMaxBacklight);

说明：获取系统允许的最大背光亮度值。

参数：【OUT】nMaxBacklight - 用于存储系统允许的最大背光亮度值。

返回值：返回 0 表示成功，其registerBacklightStatusCallBack他返回值表示错误。

示例：

1
2
3
4
5
6
7
int nMaxBacklight = 0;
int ret = getMaxBacklight(nMaxBacklight);
if (ret == 0) {
    printf("Max backlight brightness is: %d\n", nMaxBacklight);
} else {
    printf("Failed to get max backlight brightness. Error code: %d\n", ret);
}

registerBacklightStatusCallBack

定义：int registerBacklightStatusCallBack(const std::string &sCallBackFuncId, FUNC_ON_BACKLIGHT_STATUS onBacklightStatus, void *lpParameter, bool bTrigger);

说明：该函数用于注册一个回调函数，以获取背光状态的更新（背光亮或熄灭）。通过回调函数，系统会在背光状态改变时通知调用者。

参数：【IN】sCallBackFuncId - 回调函数的标识符，用于唯一标识注册的回调函数。

【IN】onBacklightStatus - 回调函数指针，该函数会在背光状态发生变化时被调用。回调函数的类型为 FUNC_ON_BACKLIGHT_STATUS。

【IN】lpParameter - 附加参数，用于传递给回调函数。用户可以自定义该参数的内容。

【IN】bTrigger - 一个布尔值，指示是否在注册时立即触发一次回调。true 表示立即触发回调，false 表示等待背光状态发生变化时再触发。

具体数据类型请参见FUNC_ON_BACKLIGHT_STATUS

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
std::string callbackId = "TestBackLight";
std::string additionalInfo = "TestParameter";
FUNC_ON_BACKLIGHT_STATUS onBacklightStatus = [](const bool &bBacklightStatus, void *lpParameter) -> int {
    std::string *paramStr = static_cast<std::string*>(lpParameter);
    std::cout << "Backlight status changed: " << (bBacklightStatus ? "ON" : "OFF") << std::endl;
    std::cout << "Additional info: " << *paramStr << std::endl;
    return 0;
};
int ret = registerBacklightStatusCallBack(callbackId, onBacklightStatus, &additionalInfo, true);
if (ret == 0) {
    std::cout << "Callback function registered successfully." << std::endl;
} else {
    std::cerr << "Failed to register callback function. Error code: " << ret << std::endl;
}
getchar();

unRegisterBacklightStatusCallBack

定义：int unRegisterBacklightStatusCallBack(const std::string &sCallBackFuncId);

说明：该函数用于取消注册已经注册的背光状态回调函数。

参数：【IN】sCallBackFuncId - 回调函数的唯一标识符，用于指定要注销的回调函数。该标识符应与注册回调时提供的一致。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
std::string callbackId = "TestBackLight";
int ret = unRegisterBacklightStatusCallBack(callbackId);
if (ret == 0) {
    std::cout << "Successfully unregistered backlight callback with ID: " << callbackId << std::endl;
} else {
    std::cerr << "Failed to unregister backlight callback. Error code: " << ret << std::endl;
}

getBacklightStatus

定义：int getBacklightStatus(bool &bBacklightStatus);

说明：该函数用于获取当前背光的状态，判断背光是否处于开启状态。

参数：【OUT】bBacklightStatus - 背光状态，true 表示背光亮起，false 表示背光关闭。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
bool bBacklightStatus = false;
int ret = getBacklightStatus(bBacklightStatus);
if (ret == 0) {
    std::cout << "Backlight Status: " << (bBacklightStatus ? "ON" : "OFF") << std::endl;
} else {
    std::cerr << "Failed to retrieve backlight status. Error code: " << ret << std::endl;
}

updateBacklightOnTime

定义：int updateBacklightOnTime();

说明：该函数用于更新当前系统中的背光点亮时间（即背光保持开启的时间）。通过调用该函数，可以触发系统将当前的背光点亮时间参数刷新

参数：无

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
int ret = updateBacklightOnTime();
if (ret == 0) {
    std::cout << "Backlight on-time updated successfully." << std::endl;
} else {
    std::cerr << "Failed to update backlight on-time. Error code: " << ret << std::endl;
}

prohibitBacklit

定义：int prohibitBacklit(const bool bProhibit);

说明：该函数用于控制是否禁止触摸点亮背光功能。

参数：【IN】bProhibit - 控制背光禁止状态的布尔值。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
bool bProhibit = true;
int ret = prohibitBacklit(bProhibit);
if (ret == 0) {
    std::cout << "Backlight operation prohibition set successfully." << std::endl;
} else {
    std::cerr << "Failed to set backlight operation prohibition. Error code: " << ret << std::endl;
}

registerBacklightCallBack

定义：int registerBacklightCallBack(const std::string &sCallBackFuncId, FUNC_ON_BACKLIGHT_INFO onBacklightInfo, void *lpParameter, bool bTrigger);

说明：该函数用于注册一个背光状态变化的回调函数。当背光状态发生变化时，系统将自动调用注册的回调函数以执行相应的处理。

参数：【IN】sCallBackFuncId - 回调函数的唯一标识符，用于区分不同的回调函数。

【IN】onBacklightInfo - 指向回调函数的指针，类型为 FUNC_ON_BACKLIGHT_INFO，该回调函数将在背光状态变化时被触发。

【IN】lpParameter - 回调函数的用户自定义参数，在回调触发时传递给回调函数，允许传递上下文或附加信息。

【IN】bTrigger - 布尔值，表示是否立即触发一次回调：

具体数据类型请参见FUNC_ON_BACKLIGHT_INFO

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
std::string callbackId = "TestBacklightCallback";
BACKLIGHT_INFO_T info;

FUNC_ON_BACKLIGHT_INFO onBacklightInfo = [](const BACKLIGHT_INFO_T &stInfo, void *lpParameter) -> int {
    std::cout << "Backlight callback triggered." << std::endl;
    std::cout << "  Enable: " << (stInfo.bEnable ? "true" : "false") << "\n"
        << "  Time: " << stInfo.nBacklightTime << "\n"
        << "  Brightness: " << stInfo.nBacklightBrightness << "\n";
    return 0;
};

int ret = registerBacklightCallBack(callbackId, onBacklightInfo, &info, true);
if (ret == 0) {
    std::cout << "Backlight callback registered successfully." << std::endl;
} else {
    std::cerr << "Failed to register backlight callback. Error code: " << ret << std::endl;
}
getchar();

unRegisterBacklightCallBack

定义：int unRegisterBacklightCallBack(const std::string &sCallBackFuncId);

说明：该函数用于注销之前注册的背光状态变化回调函数。

参数：【IN】sCallBackFuncId - 回调函数的唯一标识符，用于指定要注销的回调函数。该标识符应与注册回调时提供的一致。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
std::string callbackId = "TestBacklightCallback";
int ret = unRegisterBacklightCallBack(callbackId);
if (ret == 0) {
    std::cout << "Backlight callback unregistered successfully." << std::endl;
} else {
    std::cerr << "Failed to unregister backlight callback. Error code: " << ret << std::endl;
}

setBacklightInfo

定义：int setBacklightInfo(const BACKLIGHT_INFO_T stBacklightInfo);

说明：该函数用于更新当前系统中的背光工作参数，包括是否启用定时熄暗屏功能、背光熄暗时间、背光亮度和最大亮度。

【IN】stBacklightInfo - 背光设置的结构体，包含背光相关的所有配置参数，具体包括：

bEnable (类型: bool): 启用或禁用定时熄暗屏功能。true 表示启用定时熄暗屏，false 表示禁用，即保持常亮。

nBacklightTime (类型: int): 背光熄暗前的保持时间，单位为秒。即屏幕保持亮起状态的时间，超时后会自动熄暗。

nBacklightBrightness (类型: int): 设置的背光亮度，取值范围为 0 到 nMaxBacklight。该值决定了屏幕的亮度强度。

nMaxBacklight (类型: int): 系统允许配置的最大背光亮度值，表示背光亮度的最大限制。

具体数据类型请参见BACKLIGHT_INFO_T数据类型。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
BACKLIGHT_INFO_T info;
info.bEnable = true;
info.nBacklightTime = 600;
info.nBacklightBrightness = 80;
info.nMaxBacklight = 100;
int ret = setBacklightInfo(info);
if (ret == 0) {
    std::cout << "Backlight info set successfully." << std::endl;
} else {
    std::cerr << "Failed to set backlight info. Error code: " << ret << std::endl;
}

getBacklightInfo

定义：int getBacklightInfo(BACKLIGHT_INFO_T &stBacklightInfo);

说明：该函数用于获取当前背光工作的相关参数信息。它将通过引用传递的 stBacklightInfo 参数返回背光的工作状态、亮度等信息。

参数：[OUT] stBacklightInfo - 用于传递背光信息的结构体，函数会填充该结构体中的字段（如背光状态、亮度等信息）。结构体类型为 BACKLIGHT_INFO_T。

具体数据类型请参见BACKLIGHT_INFO_T数据类型。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
BACKLIGHT_INFO_T info;
int ret = getBacklightInfo(info);
if (ret == 0) {
    std::cout << "Backlight info retrieved successfully." << std::endl;
    std::cout << "  Enable: " << (info.bEnable ? "true" : "false") << "\n"
        << "  Time: " << info.nBacklightTime << "\n"
        << "  Brightness: " << info.nBacklightBrightness << "\n"
        << "  Max Brightness: " << info.nMaxBacklight << "\n";
} else {
    std::cerr << "Failed to retrieve backlight info. Error code: " << ret << std::endl;
}

backlightOn

定义：int backlightOn(bool bOn);

说明：该函数用于控制背光的开启或关闭。根据传入的参数 bOn，如果 bOn 为 true，则强制开启背光；如果 bOn 为 false，则强制关闭背光。

参数：[IN] bOn - 布尔值，用于指定背光的目标状态。true：开启背光。false：关闭背光。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
bool bOn = true;
int ret = backlightOn(bOn);
if (ret == 0) {
    std::cout << "Backlight turned on successfully." << std::endl;
} else {
    std::cerr << "Failed to turn on backlight. Error code: " << ret << std::endl;
}

isDeviceLcdBacklightExist

定义：int isDeviceLcdBacklightExist(bool &bExist);

说明：该函数用于检查设备是否存在 LCD 背光。如果设备支持 LCD 背光，bExist 将被设置为 true，否则设置为 false

参数：[OUT] bExist: 这是一个布尔类型的引用参数，用于存储设备是否存在 LCD 背光的结果。如果设备存在 LCD 背光，bExist 将被设置为 true，否则设置为 false。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
bool bExist = false;
int ret = isDeviceLcdBacklightExist(bExist);
if (ret == 0) {
    std::cout << "Device LCD backlight existence check successful: " << (bExist ? "Exists" : "Does not exist") << std::endl;
} else {
    std::cerr << "Failed to check backlight existence. Error code: " << ret << std::endl;
}

setBacklightRunMode

定义：int setBacklightRunMode(const int bRunMode = BL_RUN_MODE_START);

说明：该函数用于设置背光的运行模式。可以指定背光的启用或停用模式。默认情况下，函数将背光设置为启动模式。通过传入参数 bRunMode，可以选择停止或启动背光的工作状态。

参数：[IN] bRunMode: 背光运行模式。该参数是一个整数，表示要设置的背光运行模式，具体取值可以是：

BL_RUN_MODE_STOP（0）：表示停止背光。

BL_RUN_MODE_START（1）：表示启动背光。

具体数据类型请参见背光运行模式的枚举定义

默认值：BL_RUN_MODE_START（1），表示默认情况下启动背光。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
int runMode = BL_RUN_MODE_START;
int ret = setBacklightRunMode(runMode);
if (ret == 0) {
    std::cout << "Backlight run mode set to START successfully." << std::endl;
} else {
    std::cerr << "Failed to set backlight run mode. Error code: " << ret << std::endl;
}

蜂鸣器接口类型定义

FUNC_ON_BEEP_INFO：是一个回调函数类型，它主要用于处理蜂鸣器的相关信息。

using FUNC_ON_BEEP_INFO = std::function<int(const BEEPINFO &stBeepInfo, void *lpParameter)>;

BEEP_INFO_T：用于描述蜂鸣器（Buzzer）的配置和状态信息。

bool bEnable{false};        /*按键蜂鸣功能开关，是否启用*/
bool bTouchEnable{false};   /*触摸蜂鸣开关，是否启用*/
int nDurationMs{100};       /*蜂鸣时长, 单位ms*/
int nBuzzerType{1};         /*内置频段类别选择*/

蜂鸣器相关接口

beepEnable

定义：int beepEnable(const bool bEnasetBeepInfoble);

说明：该函数用于控制蜂鸣功能是否启用。如果启用蜂鸣功能，设备将响起声音；如果禁用蜂鸣功能，设备将不发出声音。

参数：[IN] bEnable: 布尔值，表示是否启用蜂鸣功能。true 表示启用蜂鸣，false 表示禁用蜂鸣。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
bool enable = true;
int ret = beepEnable(enable);
if (ret == 0) {
    std::cout << "Beep enabled successfully." << std::endl;
} else {
    std::cerr << "Failed to enable beep. Error code: " << ret << std::endl;
}

beepTouchEnable

定义：int beepTouchEnable(const bool bTouchEnable);

说明：该函数用于启用或禁用触摸蜂鸣功能。如果启用，触摸屏操作时会触发蜂鸣声。

参数：[IN] bTouchEnable: 布尔值，表示是否启用触摸蜂鸣功能。true 表示启用，false 表示禁用。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
bool touchEnable = true;
int ret = beepTouchEnable(touchEnable);
if (ret == 0) {
    std::cout << "Touch beep enabled successfully." << std::endl;
} else {
    std::cerr << "Failed to enable touch beep. Error code: " << ret << std::endl;
}

beepDurationMs

定义：int beepDurationMs(const int nDurationMs);

说明：该函数用于设置蜂鸣的持续时长，单位为毫秒。设置后，蜂鸣会持续指定时长。

参数：[IN] nDurationMs: 蜂鸣持续的时长（单位：毫秒）。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
int durationMs = 500; 
int ret = beepDurationMs(durationMs);
if (ret == 0) {
    std::cout << "Beep duration set successfully." << std::endl;
} else {
    std::cerr << "Failed to set beep duration. Error code: " << ret << std::endl;
}

beepBuzzerType

定义：int beepBuzzerType(const int nBuzzerType);

说明：该函数用于设置蜂鸣器的频段类型，可以选择不同类型的蜂鸣器声调。

参数：[IN] nBuzzerType: 蜂鸣器类型。具体类型依据设备的定义进行选择。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
int buzzerType = 1; 
int ret = beepBuzzerType(buzzerType);
if (ret == 0) {
    std::cout << "Beep buzzer type set successfully." << std::endl;
} else {
    std::cerr << "Failed to set buzzer type. Error code: " << ret << std::endl;
}

setBeepInfo

定义：int setBeepInfo(const BEEPINFO stBeepInfo);

说明：该函数用于设置蜂鸣器的工作参数。通过该接口，用户可以传递一个结构体 BEEPINFO，设置蜂鸣器的详细参数。

参数：[IN] stBeepInfo: 一个 BEEPINFO 结构体，包含蜂鸣器的相关设置。

具体数据类型请参见BEEPINFO

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
BEEPINFO beepInfo;
beepInfo.bEnable = true;
beepInfo.nDurationMs = 500;
beepInfo.nBuzzerType = 1;
int ret = setBeepInfo(beepInfo);
if (ret == 0) {
    std::cout << "Beep info set successfully." << std::endl;
} else {
    std::cerr << "Failed to set beep info. Error code: " << ret << std::endl;
}

getBeepInfo

定义：int getBeepInfo(BEEPINFO &stBeepInfo);

说明：该函数用于获取蜂鸣器当前的工作参数，将当前参数通过 BEEPINFO 结构体返回。

参数：[OUT] stBeepInfo: 一个 BEEPINFO 结构体，函数将当前蜂鸣器参数填充到该结构体中。

具体数据类型请参见BEEPINFO

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
BEEPINFO beepInfo;
int ret = getBeepInfo(beepInfo);
if (ret == 0) {
    std::cout << "Beep info retrieved successfully: " << std::endl;
    std::cout << "Enable: " << beepInfo.bEnable << std::endl;
    std::cout << "Duration: " << beepInfo.nDurationMs << " ms" << std::endl;
    std::cout << "Buzzer Type: " << beepInfo.nBuzzerType << std::endl;
} else {
    std::cerr << "Failed to get beep info. Error code: " << ret << std::endl;
}

beep

定义：int beep(bool bOn);

说明：该函数用于控制蜂鸣器是否发声。传入 true 时，蜂鸣器开始发声，传入 false 时，蜂鸣器停止发声。

参数：[IN] bOn: 布尔值，true 表示蜂鸣器开始发声，false 表示停止蜂鸣器发声。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
bool on = true;
int ret = beep(on);
if (ret == 0) {
    std::cout << "Beep started successfully." << std::endl;
} else {
    std::cerr << "Failed to start beep. Error code: " << ret << std::endl;
}

beepEx

定义：int beepEx(bool bOn, int nDurationMs, int nBuzzerType);

说明：该函数用于控制蜂鸣器的发声，并且可以指定发声的持续时长和蜂鸣器类型。

参数：[IN] bOn: 布尔值，true 表示蜂鸣器开始发声，false 表示停止蜂鸣器发声。

[IN] nDurationMs: 蜂鸣器发声的持续时长（单位：毫秒）。

[IN] nBuzzerType: 蜂鸣器的类型，控制发声的频段类型。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
8
9
bool on = true;
int durationMs = 300;
int buzzerType = 1;
int ret = beepEx(on, durationMs, buzzerType);
if (ret == 0) {
    std::cout << "Temporary beep started successfully." << std::endl;
} else {
    std::cerr << "Failed to start temporary beep. Error code: " << ret << std::endl;
}

registerBeepCallBack

定义：int registerBeepCallBack(const std::string &sCallBackFuncId, FUNC_ON_BEEP_INFO onBeepInfo, void *lpParameter, bool bTrigger);

说明：该函数用于注册蜂鸣回调函数。当系统检测到蜂鸣状态变化时，会触发回调函数。

参数：[IN] sCallBackFuncId: 回调函数的唯一标识符，用于标识和管理回调函数。

[IN] onBeepInfo: 回调函数，类型为 FUNC_ON_BEEP_INFO，用于处理蜂鸣状态变化。

[IN] lpParameter: 回调函数的附加参数， 用于传递给回调函数的上下文信息。

[IN] bTrigger: 布尔值，表示是否在注册时立即触发回调。true 表示立即触发，false 表示不触发。

具体数据类型请参见FUNC_ON_BEEP_INFO

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
std::string callbackId = "TestBeepCallback";
std::string additionalInfo = "Callback Test";
FUNC_ON_BEEP_INFO callback = [](const BEEPINFO &stBeepInfo, void *lpParameter) -> int {
    std::string *param = static_cast<std::string *>(lpParameter);
    std::cout << "Beep callback triggered." << std::endl;
    std::cout << "Additional info: " << *param << std::endl;
    std::cout << "Beep Info - Enable: " << stBeepInfo.bEnable
        << ", Duration: " << stBeepInfo.nDurationMs
        << ", Buzzer Type: " << stBeepInfo.nBuzzerType << std::endl;
    return 0;
};
int ret = registerBeepCallBack(callbackId, callback, &additionalInfo, true);
if (ret == 0) {
    std::cout << "Beep callback registered successfully." << std::endl;
} else {
    std::cerr << "Failed to register beep callback. Error code: " << ret << std::endl;
}
getchar();

unRegisterBeepCallBack

定义：int unRegisterBeepCallBack(const std::string &sCallBackFuncId);

说明：该函数用于注销之前注册的蜂鸣回调函数。

参数：[IN] sCallBackFuncId: 回调函数的唯一标识符，用于指定要注销的回调函数。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
std::string callbackId = "TestBeepCallback";
int ret = unRegisterBeepCallBack(callbackId);
if (ret == 0) {
    std::cout << "Beep callback unregistered successfully." << std::endl;
} else {
    std::cerr << "Failed to unregister beep callback. Error code: " << ret << std::endl;
}

isDeviceBeepExist

定义：int isDeviceBeepExist(bool &bExist);

说明：该函数用于检查设备是否支持蜂鸣功能。如果设备支持蜂鸣功能，bExist 参数会被设置为 true，否则为 false。

参数：[OUT] bExist: 布尔值，返回设备是否支持蜂鸣功能。true 表示支持，false 表示不支持。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
bool exist = false;
int ret = isDeviceBeepExist(exist);
if (ret == 0) {
    std::cout << "Device beep existence check completed: " << (exist ? "Exists" : "Does not exist") << std::endl;
} else {
    std::cerr << "Failed to check device beep existence. Error code: " << ret << std::endl;
}

串口接口类型定义

SERIALMODE：是一个串口模式枚举，它主要用来定义不同的串口通信模式。

typedef enum tag_SerialMode{
    UART_RS485      = 0,
    UART_RS422      = 1,/*The above two mode are used together with the incoming serial port path*/
    COM1_MODE_232   = 2,
    COM1_MODE_485   = 3,
    COM1_MODE_422   = 4,
    COM1_MODE_TTL   = 5,
    COM1_MODE_485_2 = 6,
    COM1_MODE_422_2 = 7,
    COM1_MODE_TTL_2 = 8,
    COM1_MODE_485_3 = 9,
    COM1_MODE_422_3 = 10,
    COM1_MODE_TTL_3 = 11,
    COM2_MODE_232   = 12,
    COM2_MODE_485   = 13,
    COM2_MODE_422   = 14,
    COM2_MODE_TTL   = 15,
    COM2_MODE_485_2 = 16,
    COM2_MODE_422_2 = 17,
    COM2_MODE_TTL_2 = 18,
    COM3_MODE_485   = 19,
    COM4_MODE_485   = 20,
    COM5_MODE_485   = 21,
    COM6_MODE_485   = 22,
    COM7_MODE_485   = 23,
    COM7_MODE_422   = 24,
    COM_TOTAL_NUM,
}SERIAL_MODE;
using SERIALMODE = SERIAL_MODE;

PARITY_MODE：是一个枚举类型，用来表示串口通信中的校验方式。

typedef enum {
    PARITY_MODE_NONE = 0,  // 无校验
    PARITY_MODE_ODD,       // 奇校验
    PARITY_MODE_EVEN,      // 偶校验
    PARITY_MODE_SPACE,     // 空格校验
} PARITY_MODE;

UARTBAUDINFO：用来存储串口的波特率配置及其它串口参数

int nBaudrate;  // 波特率
int nStopBit;   // 停止位
int nDataBit;   // 数据位
int nCheckBit;  // 校验位
uartbaudinfo_tag(){
nBaudrate = 115200;       // 默认波特率 115200
nStopBit = 1;             // 默认停止位 1
nDataBit = 8;             // 默认数据位 8
nCheckBit = PARITY_MODE_NONE; // 默认无校验
}

串口接口

serialOpen

定义：int serialOpen(const UARTBAUDINFO stUartBaudInfo, SERIALMODE emSerialMode = COM1_MODE_422);

说明：该函数用于打开串口设备，并根据指定的波特率、数据位、停止位、校验位以及串口模式进行配置。

参数：[IN] stUartBaudInfo: 包含串口配置的结构体（波特率、数据位、停止位、校验位等信息）。

[IN] emSerialMode: 串口工作模式，默认为 COM1_MODE_232，其他模式可以通过枚举 SERIALMODE 设置。

具体数据类型请参见UARTBAUDINFO和SERIALMODE

返回值：返回 文件描述符（fd），如果打开成功则为有效文件描述符，其他返回值表示错误。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
UARTBAUDINFO baudInfo;
baudInfo.nBaudrate = 9600;
baudInfo.nStopBit = 1;
baudInfo.nDataBit = 8;
baudInfo.nCheckBit = scl::PARITY_MODE_NONE;
SERIALMODE serialMode = scl::COM1_MODE_232;
int fd = serialOpen(baudInfo, serialMode);
if (fd < 0) {
    std::cerr << "Failed to open serial port!" << std::endl;
    return;
}
std::cout << "Serial port opened successfully, fd: " << fd << std::endl;

serialBaudConfig

定义：int serialBaudConfig(int fd, const UARTBAUDINFO stUartBaudInfo);

说明：该函数用于配置已打开串口的波特率、数据位、停止位和校验位。

参数：[IN] fd: 打开的串口文件描述符。

[IN] stUartBaudInfo: 包含波特率、数据位、停止位和校验位等配置参数的结构体。

具体数据类型请参见UARTBAUDINFO

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
int configResult = serialBaudConfig(fd, baudInfo);
if (configResult != 0) {
    std::cerr << "Failed to configure baud rate!" << std::endl;
    serialClose(fd);
    return;
}
std::cout << "Baud rate configured successfully." << std::endl;

serialWrite

定义：int serialWrite(int fd, const void *buf, int len);

说明：该函数用于向已打开的串口写入数据。

参数：[IN] fd: 打开的串口文件描述符。

[IN] buf: 要写入的数据缓冲区。

[IN] len: 要写入的字节数。

返回值：返回实际写入的字节数。如果写入成功且字节数为正值，表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
8
const char *writeData = "Hello, Serial Port!";
int writeLen = serialWrite(fd, writeData, strlen(writeData));
if (writeLen < 0) {
    std::cerr << "Failed to write data to serial port!" << std::endl;
    serialClose(fd);
    return;
}
std::cout << "Data written to serial port: " << writeData << std::endl;

serialRead

定义：int serialRead(const int fd, void *buf, int nsize, int nTimeoutMs);

说明：该函数用于从串口读取数据，并在指定超时的情况下返回。

参数：[IN] fd: 打开的串口文件描述符。

[OUT] buf: 数据存储的缓冲区。

[IN] nsize: 要读取的字节数。

[IN] nTimeoutMs: 超时时间（毫秒），会在时间结束后结束读取操作。

返回值：返回实际读取的字节数，其他返回值表示错误。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
char readBuffer[256];
memset(readBuffer, 0, sizeof(readBuffer));
int readLen = serialRead(fd, readBuffer, sizeof(readBuffer), 5000); 
if (readLen > 0) {
    std::cout << "Data read from serial port: " << readBuffer << std::endl;
} else if (readLen == 0) {
    std::cout << "No data received within timeout period." << std::endl;
} else {
    std::cerr << "Failed to read data from serial port!" << std::endl;
}

serialRead

定义：int serialRead(const int fd, void *buf, int nsize);

说明：该函数用于从串口读取数据，并阻塞等待，直到读取指定的字节数。

参数：[IN] fd: 打开的串口文件描述符。

[OUT] buf: 数据存储的缓冲区。

[IN] nsize: 要读取的字节数。

返回值：返回实际读取的字节数，其他返回值表示错误。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
char readBuffer[256];
memset(readBuffer, 0, sizeof(readBuffer));
int readLen = serialRead(fd, readBuffer, sizeof(readBuffer));
if (readLen > 0) {
    std::cout << "Data read from serial port: " << readBuffer << std::endl;
} else if (readLen == 0) {
    std::cout << "No data received within timeout period." << std::endl;
} else {
    std::cerr << "Failed to read data from serial port!" << std::endl;
}

serialClose

定义：void serialClose(int fd);

说明：该函数用于关闭已打开的串口。

参数：[IN] fd: 打开的串口文件描述符。

返回值：无

示例：

1
serialClose(fd);

CPU相关接口

getCpuTemperature

定义：int getCpuTemperature(std::string &sTemperature);

说明：该函数用于获取当前设备的 CPU 温度，并将其存储在 sTemperature 字符串中。

参数：[OUT] sTemperature: 输出参数，返回获取到的 CPU 温度值

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
std::string sTemperature;
if (scl::getCpuTemperature(sTemperature) < 0) {
    printf("get cpu temperature failed \n");
} else {
    printf("cpu temperature is %s \n", sTemperature.c_str());
}

getCpuDominantFrequency

定义：int getCpuDominantFrequency(std::string &sFrequency);

说明：该函数用于获取当前设备 CPU 的主频率，并将其存储在 sFrequency 字符串中。

参数：[OUT] sFrequency: 输出参数，返回获取到的 CPU 主频率值。

返回值：返回 0 表示成功，其他返回值表示错误。

87人脉， 】、87示例：

1
2
3
4
5
6
std::string sFrequency;
if (scl::getCpuDominantFrequency(sFrequency) < 0) {
    printf("get cpu dominant frequency failed \n");
} else {
    printf("cpu dominant frequency is %s \n", sFrequency.c_str());
}

getCpuId

定义：int getCpuId(std::string &sCpuId);

说明：该函数用于获取当前设备的 CPU ID，并将其存储在 sCpuId 字符串中。

参数：[OUT] sCpuId: 输出参数，返回获取到的 CPU ID。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
std::string sCpuId;
if (scl::getCpuId(sCpuId) < 0) {
    printf("get cpu id failed \n");
} else {
    printf("cpu id is %s \n", sCpuId.c_str());
}

USB监测相关接口类型定义

UDEV_TYPE_T：是一个枚举类型，它主要用于标识不同类别的设备。

typedef enum{
    UDEV_TYPE_UNKOWN,

    /* input device */
    UDEV_TYPE_INPUT = 100,
    UDEV_TYPE_INPUT_KEYBOARD,
    UDEV_TYPE_INPUT_MOUSE,
    UDEV_TYPE_INPUT_SCANNER,
    UDEV_TYPE_INPUT_END,

    /* block device */
    UDEV_TYPE_BLOCK = 200,
    UDEV_TYPE_BLOCK_UDISK,
    UDEV_TYPE_BLOCK_SDCARD,
    UDEV_TYPE_BLOCK_EMMC,
    UDEV_TYPE_BLOCK_END,

    /* net device */
    UDEV_TYPE_NET = 300,
    UDEV_TYPE_NET_ETH,
    UDEV_TYPE_NET_WIFI,
    UDEV_TYPE_NET_4G,
    UDEV_TYPE_NET_CAN,
    UDEV_TYPE_NET_END,

    UDEV_TYPE_MAX
}UDEV_TYPE_T;

NOTIFY_FUNCTIONS_T：包含两个函数指针，用于处理设备添加和设备移除事件的通知回调。这个结构体可以用来注册回调函数，当系统检测到用户设备的添加或移除时，可以自动调用这些回调函数来处理相应的逻辑。

int (*pfOnUserDeviceAdd)(const USER_DEVICE_INFO_T &userDeviceInfo, void *lpParameter);
int (*pfOnUserDeviceRemove)(const USER_DEVICE_INFO_T &userDeviceInfo, void *lpParameter);

USER_DEVICE_INFO_T ：它包含了三个不同类型的成员。主要用于封装与用户设备相关的信息。具体来说，它将设备事件、挂载结果以及 USB 设备信息存储在一个结构体中，方便在程序中管理和处理这些信息。

typedef struct{
    UDEV_EVENT_T    udevEvent;
    MOUNT_RESULT_T  mntResult;
    USB_DEVINFO_T   usbDevInfo;
}USER_DEVICE_INFO_T;

USB监测相关接口

subscribeEvent

定义：int subscribeEvent(vector &vecSubscribeUdevType, const string &sCallBackFuncId, const NOTIFY_FUNCTIONS_T& notifyFunctions, void *lpParameter);

说明：该函数用于订阅设备事件，注册设备类型及其对应的通知回调函数。订阅的设备类型会在发生相应事件时触发通知回调函数。

参数：[IN] vecSubscribeUdevType: 设备类型列表，表示需要订阅的设备类型。 [IN] sCallBackFuncId: 回调函数标识符，用于指定回调函数的 ID。 [IN] notifyFunctions: 用于接收设备事件的通知回调函数集合。 [IN] lpParameter: 传递给回调函数的参数。

具体数据类型请参见UDEV_TYPE_T和NOTIFY_FUNCTIONS_T

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
int OnUdiskAdd(const scl::USER_DEVICE_INFO_T& userDeviceInfo, void *lpParameter){

    printf("OnUdiskAdd sDevNode=[%s] sMountPoint=[%s] nMountExitCode=[%d]\n",
        userDeviceInfo.udevEvent.sDevNode.c_str(), 
        userDeviceInfo.mntResult.sMntPoint.c_str(), 
        userDeviceInfo.mntResult.nExitCode);

    return 0;
}
int OnUdiskRemove(const scl::USER_DEVICE_INFO_T& userDeviceInfo, void *lpParameter){

    printf("OnUdiskRemove sDevNode=[%s] sMountPoint=[%s] nMountExitCode=[%d]\n",
        userDeviceInfo.udevEvent.sDevNode.c_str(), 
        userDeviceInfo.mntResult.sMntPoint.c_str(), 
        userDeviceInfo.mntResult.nExitCode);

    return 0;
}

int nRet = 0;
scl::CUdevClient notifyClient; 
scl::NOTIFY_FUNCTIONS_T notifyFunc;
notifyFunc.pfOnUserDeviceAdd = OnUdiskAdd;
notifyFunc.pfOnUserDeviceRemove = OnUdiskRemove;

std::vector<scl::UDEV_TYPE_T> vecSubscribeUdevType(8);
std::vector<scl::USER_DEVICE_INFO_T> vecUserDeviceInfo;

vecSubscribeUdevType[0] = UDEV_TYPE_INPUT;
vecSubscribeUdevType[1] = UDEV_TYPE_INPUT_KEYBOARD;
vecSubscribeUdevType[2] = UDEV_TYPE_INPUT_MOUSE;
vecSubscribeUdevType[3] = UDEV_TYPE_INPUT_SCANNER;
vecSubscribeUdevType[4] = UDEV_TYPE_BLOCK;
vecSubscribeUdevType[5] = UDEV_TYPE_BLOCK_UDISK;
vecSubscribeUdevType[6] = UDEV_TYPE_BLOCK_SDCARD;
vecSubscribeUdevType[7] = UDEV_TYPE_BLOCK_EMMC;

std::string callbackId = "subscribeEvent";

nRet = notifyClient.subscribeEvent(vecSubscribeUdevType, callbackId, notifyFunc, nullptr);
if (nRet != 0) {
    printf("Failed to subscribe to events, error code: %d\n", nRet);
    return;
}

getExistDevices

定义：int getExistDevices(vector &vecUdevType, vector &vecUserDeviceInfo);

说明：该函数用于取消订阅已注册的设备事件。通过提供设备类型列表和回调函数标识符来取消订阅。

参数：[IN] vecSubscribeUdevType: 需要取消订阅的设备类型列表。

[IN] sCallBackFuncId: 回调函数标识符，用于指定要取消订阅的回调函数。

具体数据类型请参见UDEV_TYPE_T和USER_DEVICE_INFO_T

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
int OnUdiskAdd(const scl::USER_DEVICE_INFO_T& userDeviceInfo, void *lpParameter){

    printf("OnUdiskAdd sDevNode=[%s] sMountPoint=[%s] nMountExitCode=[%d]\n",
        userDeviceInfo.udevEvent.sDevNode.c_str(), 
        userDeviceInfo.mntResult.sMntPoint.c_str(), 
        userDeviceInfo.mntResult.nExitCode);

    return 0;
}
int OnUdiskRemove(const scl::USER_DEVICE_INFO_T& userDeviceInfo, void *lpParameter){

    printf("OnUdiskRemove sDevNode=[%s] sMountPoint=[%s] nMountExitCode=[%d]\n",
        userDeviceInfo.udevEvent.sDevNode.c_str(), 
        userDeviceInfo.mntResult.sMntPoint.c_str(), 
        userDeviceInfo.mntResult.nExitCode);

    return 0;
}

int nRet = 0;
scl::CUdevClient notifyClient; 
scl::NOTIFY_FUNCTIONS_T notifyFunc;
notifyFunc.pfOnUserDeviceAdd = OnUdiskAdd;
notifyFunc.pfOnUserDeviceRemove = OnUdiskRemove;

std::vector<scl::UDEV_TYPE_T> vecSubscribeUdevType(8);
std::vector<scl::USER_DEVICE_INFO_T> vecUserDeviceInfo;

vecSubscribeUdevType[0] = UDEV_TYPE_INPUT;
vecSubscribeUdevType[1] = UDEV_TYPE_INPUT_KEYBOARD;
vecSubscribeUdevType[2] = UDEV_TYPE_INPUT_MOUSE;
vecSubscribeUdevType[3] = UDEV_TYPE_INPUT_SCANNER;
vecSubscribeUdevType[4] = UDEV_TYPE_BLOCK;
vecSubscribeUdevType[5] = UDEV_TYPE_BLOCK_UDISK;
vecSubscribeUdevType[6] = UDEV_TYPE_BLOCK_SDCARD;
vecSubscribeUdevType[7] = UDEV_TYPE_BLOCK_EMMC;

std::string callbackId = "subscribeEvent";

nRet = notifyClient.subscribeEvent(vecSubscribeUdevType, callbackId, notifyFunc, nullptr);
if (nRet != 0) {
    printf("Failed to subscribe to events, error code: %d\n", nRet);
    return;
}

nRet = notifyClient.getExistDevices(vecSubscribeUdevType, vecUserDeviceInfo);
    if (nRet != 0) {
        printf("notifyClient.getExistDevices Error, nRet is %d\n", nRet);
        return;
    }
for (const scl::USER_DEVICE_INFO_T& deviceInfo : vecUserDeviceInfo) {
    if (scl::UDEV_ACTION_ADD == deviceInfo.udevEvent.action) {
        printf("dir %s:\n", deviceInfo.mntResult.sMntPoint.c_str());
    }
}

getExistDevices (带回调函数版本)

定义：int getExistDevices(vector &vecUdevType, const NOTIFY_FUNCTIONS_T& notifyFunctions, void *lpParameter);

说明：该函数用于获取当前系统中已存在的设备信息，遍历符合vecUdevType类型的设备，逐个触发回调函数

参数：[IN] vecUdevType: 设备类型列表，用于过滤和查询设备信息。

[IN] notifyFunctions: 用于接收设备信息变化的回调函数集合。

[IN] lpParameter: 传递给回调函数的参数。

具体数据类型请参见UDEV_TYPE_T和NOTIFY_FUNCTIONS_T

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
int OnUdiskAdd(const scl::USER_DEVICE_INFO_T& userDeviceInfo, void *lpParameter){

    printf("OnUdiskAdd sDevNode=[%s] sMountPoint=[%s] nMountExitCode=[%d]\n",
        userDeviceInfo.udevEvent.sDevNode.c_str(), 
        userDeviceInfo.mntResult.sMntPoint.c_str(), 
        userDeviceInfo.mntResult.nExitCode);

    return 0;
}

int nRet = 0;
scl::CUdevClient notifyClient; 
scl::NOTIFY_FUNCTIONS_T notifyFunc;
notifyFunc.pfOnUserDeviceAdd = OnUdiskAdd;
notifyFunc.pfOnUserDeviceRemove = OnUdiskRemove;

std::vector<scl::UDEV_TYPE_T> vecSubscribeUdevType(8);
std::vector<scl::USER_DEVICE_INFO_T> vecUserDeviceInfo;

vecSubscribeUdevType[0] = UDEV_TYPE_INPUT;
vecSubscribeUdevType[1] = UDEV_TYPE_INPUT_KEYBOARD;
vecSubscribeUdevType[2] = UDEV_TYPE_INPUT_MOUSE;
vecSubscribeUdevType[3] = UDEV_TYPE_INPUT_SCANNER;
vecSubscribeUdevType[4] = UDEV_TYPE_BLOCK;
vecSubscribeUdevType[5] = UDEV_TYPE_BLOCK_UDISK;
vecSubscribeUdevType[6] = UDEV_TYPE_BLOCK_SDCARD;
vecSubscribeUdevType[7] = UDEV_TYPE_BLOCK_EMMC;

std::string callbackId = "subscribeEvent";
nRet = notifyClient.getExistDevices(vecSubscribeUdevType, notifyFunc, nullptr);
if (nRet != 0) {
    printf("notifyClient.getExistDevices Error, nRet is %d\n", nRet);
    return;
}

Flash相关接口

getFlashEraseCount

定义：int getFlashEraseCount(int &nEraseCount);

说明：该函数用于根据设备类型查询具体的设备信息，并将设备信息返回给调用者。

参数：[OUT] nEraseCount：存储获取到的Flash擦除次数，返回时此参数将被更新为当前的擦除次数。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
int nEraseCount = 0;
if (scl::getFlashEraseCount(nEraseCount) < 0) {
    printf("get flash erase count failed\n");
} else {
    printf("flash erase count is %d\n", nEraseCount);
}

getFlashWriteCount

定义：int getFlashWriteCount(int &nWriteCount);

说明：该函数用于获取当前系统中Flash的写入次数。通过该函数可以查询并获取Flash的写入次数，写入次数影响Flash的使用寿命。

参数：[OUT] nWriteCount：存储获取到的Flash写入次数，返回时此参数将被更新为当前的写入次数。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
int nWriteCount = 0;
if (scl::getFlashWriteCount(nWriteCount) < 0) {
    printf("get flash write count failed\n");
} else {
    printf("flash write count is %d\n", nWriteCount);
}

网络相关接口类型定义

PARAMNET_NODE：用于表示网络节点的配置和状态。它包含了网络设备的基础配置信息、运行状态以及诊断参数。

std::string sDevName;//="eth0"  当前网络节点
std::string sNetType;//="ETH"   网络类型：ETH \WIFI \4G
std::string sDhcp;//使用dhcp还是静态ip配置，"enable" -- dhcp, "disable" --静态ip 
std::string sMac;//mac地址 ="E6:AA:50:02:DA:40" 
std::string sIpAddr;//ip地址 ="192.168.50.66" 
std::string sLan1Ip;//集线器，拓展的子网卡 ip 
std::string sLan2Ip;//集线器，拓展的子网卡 ip  
std::string sSubnetMask;//子网掩码="255.255.255.0" 
std::string sGateway;//网关="192.168.50.1" 
std::string sPrefDns;//域名服务器地址="192.168.32.3" 
std::string sAlterDns;//备用域名服务器地址
std::string sWifiApMode;/*wifi ap模式功能是否开启*/
std::string sSsid;//配置wifi的ssid
std::string sPasswd;//配置wifi的密码
std::string sSecureMode;//配置wifi的认证模式
std::string sFunction;//网络是否开启 --ifconfig up/down
int  nCheckErrNum{0};
int  nCheckNtpTime{1}; //检测ntp间隔次数
int  nNtpTime{0};
bool bNetNormal{false};
bool bIntranet{false};/*指示内网是否连通*/
int  nMetric;
int  nInitStartDhcp{-1};
int  nEthLinkStatus{-1}; /*指示网线是否插着 0插着，小于0 已拔出*/
int  nWifiLinkStatus{-1}; /*0 - up, 1 down, -1 无wifi设备*/
int  nWifiStatus{-1};/*指示wifi当前连接的状态信息，如:密码出错*/

NET_COMMU_PACKET_INFO：用于描述网络通信过程中与数据包传输相关的统计信息。该结构体的主要用途是监控网络通信性能，提供有关数据包延迟和丢包率的统计数据。

int nMaxPacketTransTime{-1};
int nMinPacketTransTime{9999};
int nAvgPacketTransTime{-1};
int nLostPackagePercentage{0};

FUNC_ON_GET_NETWORK_DIAGNO：代表了一类用于获取网络诊断信息的回调函数或处理函数。

using FUNC_ON_GET_NETWORK_DIAGNO  = std::function<int(std::vector<NET_DIAGNO_RESULT> &stNetDiagnoResult, void *lpParameter)>;

NET_DIAGNO_RESULT： 是一个用于表示网络诊断结果的结构体，它封装了关于设备的诊断信息，包括设备类型、名称、错误码及详细的通信信息。

std::string sDeviceType; /*诊断的设备类型*/
std::string sDeviceName; /*诊断的设备名称*/
unsigned int nErrorCode; /*错误码*/
std::string sDefaultErrorInfo;/*默认错误信息*/
NET_COMMU_PACKET_INFO stNetCommuPacketInfo; /*网卡超时信息*/

网络相关接口

registerNetInfoCallBack

定义：int registerNetInfoCallBack(const std::string &sCallBackFuncId, FUNC_ON_NET_COMMON_INFO onNetCommonInfo, void *lpParameter, bool bExeImmediate=false);

说明：该函数用于远程调用接口,获取当前网络相关信息

参数：[IN] sCallBackFuncId：该标识符用于标识回调函数，便于后续的取消注册操作。

[IN] onNetCommonInfo：一个回调函数，类型为 FUNC_ON_NET_COMMON_INFO，该函数会处理网络信息，并接收 NET_INFO 对象作为参数。

[IN] lpParameter：可以传递任何自定义的额外信息，在回调函数中使用。

[IN] bExeImmediate：表示是否立即执行回调。默认为 false，即不立即执行回调，等待网络信息更新触发回调。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
int onNetCommonInfoHandler(NET_INFO &stNetInfo, void *lpParameter) {
    std::cout << "Device Name: " << stNetInfo.sDeviceName << "\n";
    std::cout << "IP Address: " << stNetInfo.sIp << "\n";
    std::cout << "Net Mask: " << stNetInfo.sNetMask << "\n";
    std::cout << "Gateway: " << stNetInfo.sGateWay << "\n";
    std::cout << "MAC Address: " << stNetInfo.sMacAddr << "\n";
    return 0;
}
std::string callbackId = "registerNetInfoCallBack";
FUNC_ON_NET_COMMON_INFO callback = onNetCommonInfoHandler;
bool executeImmediate = true;
int result = registerNetInfoCallBack(callbackId, callback, nullptr, executeImmediate);
if (result == 0) {
    std::cout << "Callback registered successfully with ID: " << callbackId << "\n";
} else {
    std::cerr << "Failed to register callback. Error code: " << result << "\n";
}
getchar();

unRegisterNetInfoCallBack

定义：int unRegisterNetInfoCallBack(const std::string &sCallBackFuncId);

说明：该函数用于取消之前通过 registerNetInfoCallBack 注册的回调函数。通过指定回调函数的标识符来注销相应的回调。

参数：[IN] sCallBackFuncId：回调函数的唯一标识符（字符串类型）。需要取消注册的回调函数的标识符，应该与注册时使用的 sCallBackFuncId 相匹配。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
std::string callbackId = "registerNetInfoCallBack";
int  result = unRegisterNetInfoCallBack(callbackId);
if (result == 0) {
    std::cout << "Callback unregistered successfully for ID: " << callbackId << "\n";
} else {
    std::cerr << "Failed to unregister callback. Error code: " << result << "\n";
}

registerAllNetInfoCallBack

定义：int registerAllNetInfoCallBack(const std::string &sCallBackFuncId, FUNC_ON_GET_ALL_NET_INFO onGetAllNetInfo, void *lpParameter, bool bExeImmediate=false);

说明：该函数用于主动获取当前设备的全部网卡信息。

参数：[IN] listNtpServer: 一个字符串列表 (std::list)。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
int onGetAllNetInfoHandler(std::vector<PARAMNET_NODE> &stNetInfo, void *lpParameter) {
    std::cout << "Retrieved Network Information:\n";
    for (const auto &netNode : stNetInfo) {
        std::cout << "Device Name: " << netNode.sDevName << "\n";
        std::cout << "Network Type: " << netNode.sNetType << "\n";
        std::cout << "IP Address: " << netNode.sIpAddr << "\n";
        std::cout << "Subnet Mask: " << netNode.sSubnetMask << "\n";
        std::cout << "Gateway: " << netNode.sGateway << "\n";
        std::cout << "-----------------------------------\n";
    }
    return 0; 
}

std::string callbackId = "registerAllNetInfoCallBack";
int result = registerAllNetInfoCallBack(callbackId, onGetAllNetInfoHandler, nullptr, true);
if (result == 0) {
    std::cout << "Callback registered and executed immediately\n";
} else {
    std::cerr << "Failed to register callback\n";
}
getchar();

unRegisterAllNetInfoCallBack

定义：int unRegisterAllNetInfoCallBack(const std::string &sCallBackFuncId);

说明：该函数用于注销回调函数。通过指定回调函数的标识符来注销相应的回调。

参数：[IN] listNtpServer: 一个字符串列表 (std::list)。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
std::string callbackId = "registerAllNetInfoCallBack";
int result = unRegisterAllNetInfoCallBack(callbackId);
if (result == 0) {
    std::cout << "Callback unregistered successfully for ID: " << callbackId << "\n";
} else {
    std::cerr << "Failed to unregister callback. Error code: " << result << "\n";
}

getAllNetInfo

定义：int getAllNetInfo(std::vector &vecAllNetInfo);

说明：该函数用于获取当前系统中所有网络接口的信息，并将结果存储在提供的 vecAllNetInfo 容器中。每个网卡的信息会以 scl::PARAMNET_NODE 结构体的形式返回。

参数：[OUT] vecAllNetInfo: 用于存储所有网卡信息的容器，函数会填充此容器，包含每个网卡的详细信息。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
std::vector<scl::PARAMNET_NODE> allNetInfo;
int result = scl::getAllNetInfo(allNetInfo);
if (result == 0) {
    std::cout << "Successfully retrieved all network information." << std::endl;
    for (const auto &netInfo : allNetInfo) {
        std::cout << "Device Name: " << netInfo.sDevName << std::endl;
        std::cout << "Network Type: " << netInfo.sNetType << std::endl;
        std::cout << "DHCP: " << netInfo.sDhcp << std::endl;
        std::cout << "MAC Address: " << netInfo.sMac << std::endl;
        std::cout << "IP Address: " << netInfo.sIpAddr << std::endl;
        std::cout << "Lan1 IP: " << netInfo.sLan1Ip << std::endl;
        std::cout << "Lan2 IP: " << netInfo.sLan2Ip << std::endl;
        std::cout << "Subnet Mask: " << netInfo.sSubnetMask << std::endl;
        std::cout << "Gateway: " << netInfo.sGateway << std::endl;
        std::cout << "Primary DNS: " << netInfo.sPrefDns << std::endl;
        std::cout << "Alternate DNS: " << netInfo.sAlterDns << std::endl;
        std::cout << "Wifi AP Mode: " << netInfo.sWifiApMode << std::endl;
        std::cout << "SSID: " << netInfo.sSsid << std::endl;
        std::cout << "Password: " << netInfo.sPasswd << std::endl;
        std::cout << "Security Mode: " << netInfo.sSecureMode << std::endl;
        std::cout << "Function: " << netInfo.sFunction << std::endl;
        std::cout << "Check Error Number: " << netInfo.nCheckErrNum << std::endl;
        std::cout << "NTP Time Check Interval: " << netInfo.nCheckNtpTime << std::endl;
        std::cout << "NTP Time: " << netInfo.nNtpTime << std::endl;
        std::cout << "Network Normal: " << (netInfo.bNetNormal ? "Yes" : "No") << std::endl;
        std::cout << "Intranet: " << (netInfo.bIntranet ? "Yes" : "No") << std::endl;
        std::cout << "Metric: " << netInfo.nMetric << std::endl;
        std::cout << "DHCP Start Status: " << netInfo.nInitStartDhcp << std::endl;
        std::cout << "Ethernet Link Status: " << netInfo.nEthLinkStatus << std::endl;
        std::cout << "Wi-Fi Link Status: " << netInfo.nWifiLinkStatus << std::endl;
        std::cout << "Wi-Fi Status: " << netInfo.nWifiStatus << std::endl;
    }
} else {
    std::cerr << "Failed to retrieve all network information. Error code: " << result << std::endl;
}

isNetUp

定义：int isNetUp(const std::string &sDeviceName);

说明：该函数用于获取指定网卡的网络状态，判断该网卡是否处于启用状态。

参数：[IN] sDeviceName: 网络设备名称。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
8
9
std::string deviceName = "eth0";
int result = scl::isNetUp(deviceName);
if (result == 0) {
    std::cout << "Network device " << deviceName << " is up." << std::endl;
} else if (result == 1) {
    std::cout << "Network device " << deviceName << " is down." << std::endl;
} else {
    std::cerr << "Error occurred while checking network device " << deviceName << ". Error code: " << result << std::endl;
}

netDeviceUp

定义：int netDeviceUp(const std::string &sDeviceName);

说明：该函数用于开启指定网卡设备，使其启用。

参数：[IN] sDeviceName: 要开启的网卡设备名称。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
std::string deviceName = "eth0";
int result = scl::netDeviceUp(deviceName);
if (result == 0) {
    std::cout << "Network device " << deviceName << " is up successfully." << std::endl;
} else {
    std::cerr << "Error occurred while bringing up network device " << deviceName << ". Error code: " << result << std::endl;
}

netIsExist

定义：int netIsExist(const std::string &sDeviceName);

说明：该函数用于检查指定的网络设备是否存在。

参数：[IN] sDeviceName：要检查的设备名称。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
std::string deviceName = "eth0";
int result = scl::netIsExist(deviceName);
if (result == 0) {
    std::cout << "Network device " << deviceName << " exists." << std::endl;
} else {
    std::cerr << "Network device " << deviceName << " does not exist. Error code: " << result << std::endl;
}

isNetDeviceDhcp

定义：int isNetDeviceDhcp(const std::string &sDeviceName);

说明：该函数用于检查指定的网络设备是否使用 DHCP 协议。

参数：[IN] sDeviceName：要检查的设备名称。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
std::string sDeviceName = "eth0";
int nRnt = scl::isNetDeviceDhcp(sDeviceName);
switch (nRnt) {
    case 0:
        printf("ip is Dynamic\n");
        break;
    case 1:
        printf("ip is static\n");
        break;
    default:
        printf("get net status failed\n");
        break;
}

startDhcp

定义：int startDhcp(const std::string &sDeviceName);

说明：该函数用于启动指定网络设备的 DHCP 功能。

参数：[IN] sDeviceName：要检查的设备名称。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
 std::string deviceName = "eth0";
int result = startDhcp(deviceName);
if (result == 0) {
    std::cout << "DHCP started for device " << deviceName << "." << std::endl;
} else {
    std::cerr << "Error occurred while starting DHCP for device " << deviceName << ". Error code: " << result << std::endl;
}

stopDhcp

定义：int stopDhcp(const std::string &sDeviceName);

说明：该函数用于关闭指定网络设备的 DHCP 功能，切换为静态 IP 配置。

参数：[IN] sDeviceName：要关闭 DHCP 的设备名称（如 "eth0"）。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
std::string deviceName = "eth0";
int result = stopDhcp(deviceName);
if (result == 0) {
    std::cout << "DHCP stopped for device " << deviceName << "." << std::endl;
} else {
    std::cerr << "Error occurred while stopping DHCP for device " << deviceName << ". Error code: " << result << std::endl;
}

getMacAddr

定义：int getMacAddr(const std::string &sDeviceName, std::string &sMacAddr);

说明：该函数用于获取指定网络设备的 MAC 地址。

参数：[IN] sDeviceName：要查询 MAC 地址的设备名称。

[OUT] sMacAddr：返回的 MAC 地址。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
8
std::string deviceName = "eth0";
std::string macAddr;
int result = getMacAddr(deviceName, macAddr);
if (result == 0) {
    std::cout << "MAC address for device " << deviceName << " is: " << macAddr << std::endl;
} else {
    std::cerr << "Error occurred while retrieving MAC address for device " << deviceName << ". Error code: " << result << std::endl;
}

setMacAddr

定义：int setMacAddr(const std::string &sDeviceName, const std::string &sMacAddr);

说明：该函数用于设置指定网络设备的 MAC 地址。

参数：[IN] sDeviceName：要设置 MAC 地址的设备名称。

[IN] sMacAddr：要设置的 MAC 地址。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
8
std::string deviceName = "eth0";
std::string macAddr = "00:11:22:33:44:55";
int result = setMacAddr(deviceName, macAddr);
if (result == 0) {
    std::cout << "MAC address for device " << deviceName << " set to: " << macAddr << std::endl;
} else {
    std::cerr << "Error occurred while setting MAC address for device " << deviceName << ". Error code: " << result << std::endl;
}

setIp

定义：int setIp(const std::string &sDeviceName, const std::string &sIp, const std::string &sNetMask, const std::string &sGateWay);

说明：该函数用于设置设备的IP地址、子网掩码和网关。

参数：[IN] sDeviceName: 设备名称。

[IN] sIp: 需要设置的IP地址。

[IN] sNetMask: 需要设置的子网掩码。

[IN] sGateWay: 需要设置的网关地址。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
std::string deviceName = "eth0";
std::string ip = "192.168.1.100";
std::string netMask = "255.255.255.0";
std::string gateway = "192.168.1.1";
int result = setIp(deviceName, ip, netMask, gateway);
if (result == 0) {
    std::cout << "IP configuration for device " << deviceName << " set successfully." << std::endl;
} else {
    std::cerr << "Error occurred while setting IP configuration for device " << deviceName << ". Error code: " << result << std::endl;
}

getIp

定义：int getIp(const std::string &sDeviceName, std::string &sIp, std::string &sNetMask, std::string &sGateWay);

说明：该函数用于获取设备的IP地址、子网掩码和网关。

参数：[IN] sDeviceName: 设备名称。

[OUT] sIp: 返回设备的IP地址。

[OUT] sNetMask: 返回设备的子网掩码。

[OUT] sGateWay: 返回设备的网关地址。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
8
9
std::string deviceName = "eth0";
std::string ip, netMask, gateway;
int result = getIp(deviceName, ip, netMask, gateway);
if (result == 0) {
    std::cout << "IP configuration for device " << deviceName << " is:" << std::endl;
    std::cout << "IP: " << ip << ", NetMask: " << netMask << ", Gateway: " << gateway << std::endl;
} else {
    std::cerr << "Error occurred while getting IP configuration for device " << deviceName << ". Error code: " << result << std::endl;
}

getDns

定义：int getDns(const std::string &sDeviceName, std::string &sDnsPrimary, std::string &sDnsSecondary);

说明：该函数用于获取设备的DNS地址。

参数：[IN] sDeviceName: 设备名称。

[OUT] sDnsPrimary: 返回设备的主DNS地址。

[OUT] sDnsSecondary: 返回设备的次DNS地址。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
8
9
std::string deviceName = "eth0";
std::string dnsPrimary, dnsSecondary;
int result = getDns(deviceName, dnsPrimary, dnsSecondary);
if (result == 0) {
    std::cout << "DNS configuration for device " << deviceName << " is:" << std::endl;
    std::cout << "Primary DNS: " << dnsPrimary << ", Secondary DNS: " << dnsSecondary << std::endl;
} else {
    std::cerr << "Error occurred while getting DNS configuration for device " << deviceName << ". Error code: " << result << std::endl;
}

setDns

定义：int setDns(const std::string &sDeviceName, const std::string &sDnsPrimary, const std::string &sDnsSecondary);

说明：该函数用于设置设备的DNS地址。

参数：[IN] sDeviceName: 设备名称。

[IN] sDnsPrimary: 需要设置的主DNS地址。

[IN] sDnsSecondary: 需要设置的次DNS地址。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
8
9
std::string deviceName = "eth0";
std::string dnsPrimary = "8.8.8.8";
std::string dnsSecondary = "8.8.4.4";
int result = setDns(deviceName, dnsPrimary, dnsSecondary);
if (result == 0) {
    std::cout << "DNS configuration for device " << deviceName << " set successfully." << std::endl;
} else {
    std::cerr << "Error occurred while setting DNS configuration for device " << deviceName << ". Error code: " << result << std::endl;
}

定义：int checkEthCableLink(const std::string &SCARD_ATTR_DEVICE_SYSTEM_NAME);

说明：该函数用于检查以太网连接是否正常。

参数：[IN] SCARD_ATTR_DEVICE_SYSTEM_NAME: 设备名称。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
std::string deviceName = "eth0";
int result = checkEthCableLink(deviceName);
if (result == 0) {
    std::cout << "Ethernet cable is properly linked for device: " << deviceName << std::endl;
} else {
    std::cerr << "Failed to check ethernet cable link for device: " << deviceName << ". Error code: " << result << std::endl;
}

setNetServerAddr

定义：int setNetServerAddr(const std::string &sMqttAddr);

说明：该函数用于配置 MQTT 服务连接地址。

参数：[IN] sMqttAddr: MQTT 服务的连接地址。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
std::string mqttAddr = "mqtt://localhost:1883";
int result = setNetServerAddr(mqttAddr);
if (result == 0) {
    std::cout << "MQTT server address successfully set to: " << mqttAddr << std::endl;
} else {
    std::cerr << "Failed to set MQTT server address. Error code: " << result << std::endl;
}

setNetServerAddr

定义：int setNetServerAddr(const std::string &sMqttAddr);

说明：该函数用于获取mqtt服务器的地址。

参数：[IN] sMqttAddr: MQTT 服务的连接地址。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
std::string mqttAddr;
int result = getNetServerAddr(mqttAddr);
if (result == 0) {
    std::cout << "Default network server address is: " << mqttAddr << std::endl;
} else {
    std::cerr << "Failed to get the default network server address. Error code: " << result << std::endl;
}

netTping

定义：int netTping(const std::string &sDeviceName, const std::string &sDomainName, const std::string &sDestIp,NET_COMMU_PACKET_INFO &stNetCommuPacketInfo, bool bExeCmd = false,int nMaxPack = 1);

说明：该函数用于对指定设备执行 Ping 操作，并返回网络包的传输时间信息（包括最大、最小、平均时间及丢包率）。支持指定域名和目标 IP 地址进行测试。

参数：[IN] sDeviceName:表示网络设备名称（如 "eth0"）。 [IN] sDomainName:表示需要 Ping 的域名（如 "example.com"）。 [IN] sDestIp:表示需要 Ping 的目标 IP 地址（如 "192.168.1.1"）。 [OUT] stNetCommuPacketInfo:返回 Ping 包的传输信息，包括最大、最小、平均时间及丢包率。 [IN] bExeCmd:可选，表示是否执行 Ping 命令，默认为 false。 [IN] nMaxPack:可选，表示最大 Ping 包数量，默认为 1。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
NET_COMMU_PACKET_INFO netPingInfo;
std::string deviceName = "eth0";
std::string domainName = "example.com";
std::string destIp = "192.168.1.1";
bool executeCommand = true;
int maxPacket = 5;

int result = netTping(deviceName, domainName, destIp, netPingInfo, executeCommand, maxPacket);

if (result == 0) {
    std::cout << "Ping success!" << std::endl;
    std::cout << "Max Transmit Time: " << netPingInfo.nMaxPacketTransTime << " ms" << std::endl;
    std::cout << "Min Transmit Time: " << netPingInfo.nMinPacketTransTime << " ms" << std::endl;
    std::cout << "Average Transmit Time: " << netPingInfo.nAvgPacketTransTime << " ms" << std::endl;
    std::cout << "Lost Packet Percentage: " << netPingInfo.nLostPackagePercentage << " %" << std::endl;
} else {
    std::cerr << "Ping failed! Error code: " << result << std::endl;
}

getDevPriority

定义：int getDevPriority(std::string &sDeviceType);

说明：该函数用于获取当前网络上云的最高优先级网卡的设备类型。

参数：[OUT] sDeviceType:返回当前最高优先级的网络设备类型。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
std::string deviceType;
int result = getDevPriority(deviceType);
if (result == 0) {
    std::cout << "Highest priority network card: " << deviceType << std::endl;
} else {
    std::cerr << "Failed to get device priority. Error code: " << result << std::endl;
}

setDevPriority

定义：int setDevPriority(const std::string &sDeviceType);

说明：该函数用于设置当前网络上云的最高优先级网卡。需要注意，当网络切换到 4G 时，外部网络可能无法访问或 Ping 通以太网。

参数：[IN] sDeviceType:指定要设置为最高优先级的网络设备类型。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
std::string deviceType = "eth0";
int result = setDevPriority(deviceType);
if (result == 0) {
    std::cout << "Device priority successfully set to: " << deviceType << std::endl;
} else {
    std::cerr << "Failed to set device priority. Error code: " << result << std::endl;
}

getNetDeviceName

定义：int getNetDeviceName(const std::string &sDeviceType, std::vector &vecDeviceName);

说明：该函数用于根据网卡类型获取对应的节点名称列表。

参数：[IN] sDeviceType:表示网卡类型。

[OUT] vecDeviceName:返回对应网卡类型的节点名称列表。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
std::string deviceType = "ETH";
std::vector<std::string> deviceNames;
int result = getNetDeviceName(deviceType, deviceNames);
if (result == 0) {
    std::cout << "Device names for type '" << deviceType << "':" << std::endl;
    for (const auto &name : deviceNames) {
        std::cout << "- " << name << std::endl;
    }
} else {
    std::cerr << "Failed to get device names. Error code: " << result << std::endl;
}

getCurrNetDevice

定义：int getCurrNetDevice(std::string &sDeviceName);

说明：该函数用于获取当前正在使用的网络设备名称。

参数：[OUT] sDeviceName:返回对应网卡类型的节点名称列表。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
std::string currentDeviceName;
int result = getCurrNetDevice(currentDeviceName);
if (result == 0) {
    std::cout << "Current internet device: " << currentDeviceName << std::endl;
} else {
    std::cerr << "Failed to get current internet device. Error code: " << result << std::endl;
}

startEthNetDiagnoCallBackup

定义：int startEthNetDiagnoCallBackup(FUNC_ON_GET_NETWORK_DIAGNO getEthNetDiagnoFunc, void *lpParameter, bool bPing = true);

说明：该函数用于启动以太网网络故障诊断。

参数：[IN] getEthNetDiagnoFunc: 一个回调函数，当诊断完成时调用此函数处理结果。

[IN] lpParameter: 用户自定义的参数，会传递给回调函数。

[IN] bPing: 指示是否进行 Ping 测试，默认为 true，表示进行 Ping 测试。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
int endNetDiagno(std::vector<scl::NETDIAGNORESULT>& stNetDiagnoResult, void* lpParameter) {
    std::vector<scl::NETDIAGNORESULT>& vecNetDiagno = getNetDiagno();
    vecNetDiagno = stNetDiagnoResult;
    for (scl::NETDIAGNORESULT& diagnoResult : vecNetDiagno) {
        printf("============================\n");
        printf("device name:%s\nerror code:%d\nerror info:%s\n",
               diagnoResult.sDeviceName.c_str(), diagnoResult.nErrorCode, diagnoResult.sDefaultErrorInfo.c_str());
        printf("ping time info:\nMax Packet TransTime is %d\nMin Packet TransTime is %d\nAvg Packet TransTime is %d\nLost Package Percentage is %d%c\n",
               diagnoResult.stNetCommuPacketInfo.nMaxPacketTransTime,
               diagnoResult.stNetCommuPacketInfo.nAvgPacketTransTime,
               diagnoResult.stNetCommuPacketInfo.nLostPackagePercentage, '%');
    }
    return 0;
}


int nRnt = startEthNetDiagnoCallBackup(&endNetDiagno, nullptr);
if (0 != nRnt) {
    printf("error: ETH\n");
} else {
    printf("diagno succ, please wait\n");
}
getchar();

startWifiNetDiagnoCallBackup

定义：int startWifiNetDiagnoCallBackup(FUNC_ON_GET_NETWORK_DIAGNO getWifiNetDiagnoFunc, void *lpParameter, bool bPing = true);

说明：该函数用于启动 WiFi 网络故障诊断。

参数：[IN] getWifiNetDiagnoFunc: 一个回调函数，当诊断完成时调用此函数处理结果。

[IN] lpParameter: 用户自定义的参数，会传递给回调函数。

[IN] bPing: 指示是否进行 Ping 测试，默认为 true，表示进行 Ping 测试。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
int endNetDiagno(std::vector<scl::NETDIAGNORESULT>& stNetDiagnoResult, void* lpParameter) {
    std::vector<scl::NETDIAGNORESULT>& vecNetDiagno = getNetDiagno();
    vecNetDiagno = stNetDiagnoResult;
    for (scl::NETDIAGNORESULT& diagnoResult : vecNetDiagno) {
        printf("============================\n");
        printf("device name:%s\nerror code:%d\nerror info:%s\n",
            diagnoResult.sDeviceName.c_str(), diagnoResult.nErrorCode, diagnoResult.sDefaultErrorInfo.c_str());
        printf("ping time info:\nMax Packet TransTime is %d\nMin Packet TransTime is %d\nAvg Packet TransTime is %d\nLost Package Percentage is %d%c\n",
            diagnoResult.stNetCommuPacketInfo.nMaxPacketTransTime,
            diagnoResult.stNetCommuPacketInfo.nMinPacketTransTime,
            diagnoResult.stNetCommuPacketInfo.nAvgPacketTransTime,
            diagnoResult.stNetCommuPacketInfo.nLostPackagePercentage, '%');
    }
    return 0;
}

int ret = startWifiNetDiagnoCallBackup(&endNetDiagno, nullptr);
if (ret == 0) {
    std::cout << "WiFi network diagnostic started successfully!" << std::endl;
} else {
    std::cout << "WiFi network diagnostic failed to start!" << std::endl;
}
getchar();

start4gNetDiagnoCallBackup

定义：int start4gNetDiagnoCallBackup(FUNC_ON_GET_NETWORK_DIAGNO get4gNetDiagnoFunc, void *lpParameter, bool bPing = true);

说明：该函数用于启动 4G 网络故障诊断。

参数：[IN] get4gNetDiagnoFunc: 一个回调函数，当诊断完成时调用此函数处理结果。

[IN] lpParameter: 用户自定义的参数，会传递给回调函数。

[IN] bPing: 指示是否进行 Ping 测试，默认为 true，表示进行 Ping 测试。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
int endNetDiagno(std::vector<scl::NETDIAGNORESULT>& stNetDiagnoResult, void* lpParameter) {
    std::vector<scl::NETDIAGNORESULT>& vecNetDiagno = getNetDiagno();
    vecNetDiagno = stNetDiagnoResult;
    for (scl::NETDIAGNORESULT& diagnoResult : vecNetDiagno) {
        printf("============================\n");
        printf("device name:%s\nerror code:%d\nerror info:%s\n",
            diagnoResult.sDeviceName.c_str(), diagnoResult.nErrorCode, diagnoResult.sDefaultErrorInfo.c_str());
        printf("ping time info:\nMax Packet TransTime is %d\nMin Packet TransTime is %d\nAvg Packet TransTime is %d\nLost Package Percentage is %d%c\n",
            diagnoResult.stNetCommuPacketInfo.nMaxPacketTransTime,
            diagnoResult.stNetCommuPacketInfo.nMinPacketTransTime,
            diagnoResult.stNetCommuPacketInfo.nAvgPacketTransTime,
            diagnoResult.stNetCommuPacketInfo.nLostPackagePercentage, '%');
    }
    return 0;
}

int nRnt = start4gNetDiagnoCallBackup(&endNetDiagno, nullptr);
if (0 != nRnt) {
    printf("error: 4G\n");
} else {
    printf("diagno succ, please wait\n");
}

显示配置接口类型定义

SCREEN_PARAM_INFO_T：是一个结构体，定义了液晶屏幕（LCD）或显示屏的相关配置参数。它包含多个字段，用于描述屏幕的尺寸、位深、显示位置以及其他与屏幕显示相关的设置。

int nScreenWidth{800};
int nScreenHigh{480};
int nScreenBits{1};         /*位数*/
int nScreensize{1024};      /*屏幕的总大小(字节)*/
int nBytesPerLine{100};     /*计算一行的大小(LCD一行字节数量)*/
int nDisplayPosX{100};      /*显示在X坐标位置*/
int nDisplayPosY{100};      /*显示在Y坐标位置*/
bool bScale{false};         /*启用 缩放*/

DISPLAY_MODE：是一个枚举类型，定义了不同的显示模式。这个枚举类型用于标识显示设备的分辨率。

typedef enum euDisPlayMode{
    DMODE_720P  = 1,
    DMODE_1080P = 2,
}DISPLAY_MODE;

ANGLE_MODE：是一个枚举类型，表示显示屏或图像的旋转角度。

typedef enum euDisPlayMode{
    DMODE_720P  = 1,
    DMODE_1080P = 2,
}DISPLAY_MODE;

显示配置接口

showImage

定义：int showImage(const std::string &sImagePath, bool bMultiGraphLoopDisplay = false);

说明：该函数用于显示指定路径的图像文件。可以选择是否循环显示多个图像。

参数：[IN] sImagePath：要显示的图像文件路径。

[IN] bMultiGraphLoopDisplay：是否循环显示多个图像，默认为 false。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
8
std::string imagePath = "mnt/data/test.png";
bool multiGraphLoopDisplay = false; 
int result = scl::showImage(imagePath, multiGraphLoopDisplay);
if (result == 0) {
    std::cout << "showImage succeeded!" << std::endl;
} else {
    std::cout << "showImage failed with error code: " << result << std::endl;
}

loadLcdConf2Ini

定义：int loadLcdConf2Ini(const std::string &sLcdInfoFileName, const std::string &sIniFileName);

说明：该函数用于将 LCD 配置信息从指定文件加载并保存到 INI 格式的配置文件中。

参数：[IN] sLcdInfoFileName：LCD 配置信息源文件路径。

[IN] sIniFileName：目标 INI 配置文件路径。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
8
std::string lcdInfoFileName = "path/to/your/lcd_info_file.txt";
std::string iniFileName = "path/to/your/config.ini";
int result = scl::loadLcdConf2Ini(lcdInfoFileName, iniFileName);
if (result == 0) {
    std::cout << "loadLcdConf2Ini succeeded!" << std::endl;
} else {
    std::cout << "loadLcdConf2Ini failed with error code: " << result << std::endl;
}

getFbScreenParam

定义：int getFbScreenParam(SCREEN_PARAM_INFO_T &stScreenParam);

说明：该函数用于获取当前液晶显示屏的分辨率和其他参数信息。

参数：[OUT] stScreenParam：存储获取到的液晶显示屏参数信息的结构体。

具体数据类型请参见SCREEN_PARAM_INFO_T

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
scl::SCREENPARAM screenParam;
if (0 == scl::getFbScreenParam(screenParam)) {
    printf("screen width is %d\nscreen high is %d\nscreen bits is %d\nscreen size if%d\n\
number of bytes in one line of LCD is %d\nnDisplay is (%d , %d)\n", screenParam.nScreenWidth,
           screenParam.nScreenHigh, screenParam.nScreenBits,  screenParam.nScreensize, screenParam.nBytesPerLine, screenParam.nDisplayPosX,
           screenParam.nDisplayPosY);
}
else {
    printf("get LCD resolution parameters failed\n");
}

setDisplayMode

定义：int setDisplayMode(DISPLAY_MODE euDisMode, ANGLE_MODE euAngleMode = AM_0);

说明：该函数用于设置显示模式，包括分辨率和显示的旋转角度。

参数：[IN] euDisMode：要设置的显示模式。

[IN] euAngleMode：显示的旋转角度，默认为 AM_0（不旋转）。

具体数据类型请参见DISPLAY_MODE和ANGLE_MODE

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
int nDisplayMode = (int)scl::DMODE_1080P;
int nAngleMode = (int)scl::AM_0;
if (0 != scl::setDisplayMode((scl::euDisPlayMode)nDisplayMode, (scl::enAngleMode)nAngleMode)) {
    printf("set mode failed\n");
} else {
    printf("set mode succeeded\n");
}

键盘设备管理接口类型定义

UARTBAUDINFO：是一个用于配置串口（UART）通信速率、数据位、停止位和校验位的结构体。这个结构体在初始化时提供了默认的串口配置参数，方便在串口通信中快速应用这些配置。

int nBaudrate;
int nStopBit;
int nDataBit;
int nCheckBit;
uartbaudinfo_tag(){
nBaudrate = 115200;
nStopBit = 1;
nDataBit = 8;
nCheckBit = PARITY_MODE_NONE;
}

SERIALMODE：是一个枚举类型，定义了不同的串口通信模式。该枚举类型包含了多种串口模式的选项，涵盖了常见的串口通信标准，例如 RS-232、RS-485、RS-422 以及 TTL 等多种通信协议和电气接口标准。

typedef enum tag_SerialMode{
    UART_RS485      = 0,
    UART_RS422      = 1,/*The above two mode are used together with the incoming serial port path*/
    COM1_MODE_232   = 2,
    COM1_MODE_485   = 3,
    COM1_MODE_422   = 4,
    COM1_MODE_TTL   = 5,
    COM1_MODE_485_2 = 6,
    COM1_MODE_422_2 = 7,
    COM1_MODE_TTL_2 = 8,
    COM1_MODE_485_3 = 9,
    COM1_MODE_422_3 = 10,
    COM1_MODE_TTL_3 = 11,
    COM2_MODE_232   = 12,
    COM2_MODE_485   = 13,
    COM2_MODE_422   = 14,
    COM2_MODE_TTL   = 15,
    COM2_MODE_485_2 = 16,
    COM2_MODE_422_2 = 17,
    COM2_MODE_TTL_2 = 18,
    COM_TOTAL_NUM,
}SERIAL_MODE;
using SERIALMODE = SERIAL_MODE;

KEYVALUE： 是一个枚举类型，它用于表示按键的不同状态或事件类型。此枚举定义了三种常见的按键状态，分别用于描述按键的状态变化

typedef enum keyValueType_tag{
    KEY_VALUE_UP         =  0,
    KEY_VALUE_DOWN       =  1,
    KEY_VALUE_LONG_PRESS =  2,
}KEYVALUE;

键盘设备管理接口

startKeyboard

定义：int startKeyboard(const UARTBAUDINFO stUartBaudInfo, SERIALMODE emSerialMode = COM1_MODE_422_2, const std::string &sDevName = "SerialWKeyboard");

说明：该函数用于配置并启动串口键盘设备，设置键盘的速率、串口模式和设备名称。

参数：[IN] stUartBaudInfo：串口速率信息，包括波特率、数据位、停止位、校验位等。

[IN] emSerialMode：串口模式（默认为 COM1_MODE_422_2）。

[IN] sDevName：设备名称（默认为 "SerialWKeyboard"）。

具体数据类型请参见UARTBAUDINFO和SERIALMODE

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
scl::UARTBAUDINFO uartConfig;
uartConfig.nBaudrate = 9600;
uartConfig.nStopBit = 1;
uartConfig.nDataBit = 8;
uartConfig.nCheckBit = 0; 
scl::SERIAL_MODE serialMode = scl::COM1_MODE_232;
std::string devName = "SerialWKeyboard";
int result = scl::startKeyboard(uartConfig, serialMode, devName);
if (result == 0) {
    std::cout << "Keyboard initialized successfully." << std::endl;
} else {
    std::cout << "Failed to initialize keyboard. Error code: " << result << std::endl;
}

getKeyCodeStatus

定义：int getKeyCodeStatus(const int nKeyCode, KEYVALUE &emKeyValue);

说明：该函数用于获取指定按键的状态，返回按键的当前状态（按下、松开、长按等）。

参数：[IN] nKeyCode：指定的按键代码。

[OUT] emKeyValue：返回的按键状态类型，表示按键的当前状态（如按下、松开、长按）。

具体数据类型请参见KEYVALUE

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
int keyCode = 1; 
KEYVALUE keyStatus;
int result = getKeyCodeStatus(keyCode, keyStatus);
if (result == 0) {
    if (keyStatus == KEY_VALUE_UP) {
        std::cout << "Key " << keyCode << " is UP." << std::endl;
    } else if (keyStatus == KEY_VALUE_DOWN) {
        std::cout << "Key " << keyCode << " is DOWN." << std::endl;
    } else if (keyStatus == KEY_VALUE_LONG_PRESS) {
        std::cout << "Key " << keyCode << " is LONG PRESS." << std::endl;
    }
} else {
    std::cout << "Invalid key code or error occurred." << std::endl;
}

reportOriginKeyValue

定义：int reportOriginKeyValue(const bool bOriginKey);

说明：该函数用于配置是否上报原始按键值，启用时直接上报原始按键状态，关闭时上报转换后的按键值。

参数：[IN] bOriginKey：如果为 true，启用原始按键值上报；如果为 false，默认关闭，表示上报映射转换后的按键值。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
int result = reportOriginKeyValue(false);
if (result == 0) {
    std::cout << "Successfully disabled original key reporting, using mapped keys." << std::endl;
} else {
    std::cout << "Failed to disable original key reporting." << std::endl;
}

getVinputDevConfName

定义：int getVinputDevConfName(std::vector &vecVinputName);

说明：该函数用于获取当前键盘设备的配置文件名，并将配置文件名列表存储在传入的容器中。

参数：[OUT] vecVinputName：返回的键盘设备配置文件名列表。每个元素是一个字符串，表示一个配置文件的名称。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
std::vector<std::string> deviceConfNames;
int result = getVinputDevConfName(deviceConfNames);

if (result == 0) {
    std::cout << "Successfully retrieved keyboard device config names:" << std::endl;
    for (const auto &confName : deviceConfNames) {
        std::cout << confName << std::endl;
    }
} else {
    std::cout << "Failed to retrieve keyboard device config names." << std::endl;
}

盒子LED接口类型定义

lampMode：是一个枚举类型，用于定义 LED 灯的不同运行模式。

enum lampMode{
    MODE_5,
    MODE_8,
    MODE_MAX,
};

lampRunType：举定义了 LED 灯的多种运行状态，适用于标识不同的系统和设备状态。

enum lampRunType {
    Type_Business_Online,               //business is normal of box
    Type_Business_Online_Hmi,           //business is normal of hmi
    Type_Business_Offline,              //business is`n normal
    Type_Business_System,               //business of system

    Type_Mqtt_Online,                   //mqtt is online
    Type_Mqtt_Offline,                  //mqtt is offline
    Type_MqttAndNet_Offline,            //mqtt is offline and net is`n normal

    Type_Net_NoReg,                     //error: net is not register
    Type_Net_NoSim,                     //error: Sim card is not inserted
    Type_Net_NoSignal,                  //error: net is not signal

    Type_Signal_1,                      //signal strength 1
    Type_Signal_2,                      //signal strength 2
    Type_Signal_3,                      //signal strength 3
    Type_Signal_4,                      //signal strength 4

    Type_Reset_Start,                   //reset button is press
    Type_Reset_Stop,                    //reset button is up
    Type_Reset_Success,                 //reset is success

    Type_AllTwinkle,                    //twinkle all lamp exclude net and com
    Type_ChangeMode,                    //change lamp show mode

    Type_Test_Project,                  //project test all lamp group lamp
    Type_Test_AllTwinkle,               //project test all lamp twinkle
    Type_Test_Stop,                     //project test all lamp twinkle dark
    Type_FaultTypeMax
};

盒子LED接口

setLedLampMode

定义：int setLedLampMode(const lampMode & tagMode);

说明：该函数用于设置盒子LED灯的运行模式。

参数：[IN] tagMode：LED灯的运行模式，类型为 lampMode 枚举，定义了不同的LED灯模式。

具体数据类型请参见lampMode

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
8
scl::lampMode mode = scl::MODE_8;
int ret = scl::setLedLampMode(mode);
if (ret != 0) {
    printf("Failed to set LED lamp mode, error code: %d\n", ret);
}
else {
    printf("Successfully set LED lamp mode.\n");
}

setLedLampStatus

定义：int setLedLampStatus(const lampRunType & tagStatus);

说明：该函数用于设置盒子LED灯的运行状态。

参数：[IN] tagStatus：LED灯的运行状态，类型为 lampRunType 枚举，定义了LED灯的不同运行状态。

具体数据类型请参见lampRunType

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
8
scl::lampRunType status = scl::Type_AllTwinkle;
ret = scl::setLedLampStatus(status);
if (ret != 0) {
    printf("Failed to set LED lamp status, error code: %d\n", ret);
}
else {
    printf("Successfully set LED lamp status.\n");
}

协议数据打包与解包接口

package

定义：int package(const std::string& sProto, std::string& sPackage);

说明： 该函数用于将协议数据（字符串形式）打包成一个新的字符串。

参数：[IN] sProto: 协议数据的字符串。

[OUT] sPackage: 打包后的数据字符串。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
scl::CProtoFrame protoFrame;
std::string originalProto = "ExampleProtocolData";
std::string packagedData;
int ret = protoFrame.package(originalProto, packagedData);
if (ret != 0) {
    printf("Failed to package data (string input), error code: %d\n", ret);
}
else {
    printf("Successfully packaged data (string input): %s\n", packagedData.c_str());
}

unpackage

定义：int unpackage(const std::string& sPackage, std::string& sProto);

说明：该函数用于将接收到的打包数据（字符串形式）进行解包，转换成协议数据。

参数：[IN] sPackage: 接收到的打包数据字符串。

[OUT] sProto: 解包后的协议数据字符串。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
scl::CProtoFrame protoFrame;
std::string packagedData;
std::string unpackedProto;  
ret = protoFrame.unpackage(packagedData, unpackedProto);
if (ret != 0) {
    printf("Failed to unpackage data (string input), error code: %d\n", ret);
}
else {
    printf("Successfully unpackaged data (string input): %s\n", unpackedProto.c_str());
}

package

定义：int package(const unsigned char *pProto, int nSize, std::string& sPackage);

说明：该函数用于将协议数据打包成一个字符串。

参数：[IN] pProto: 指向协议数据的指针。

[IN] nSize: 协议数据的大小。

[OUT] sPackage: 打包后的数据字符串。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
scl::CProtoFrame protoFrame;
std::string originalProto = "ExampleProtocolData";
std::string packagedData;
ret = protoFrame.package(reinterpret_cast<const unsigned char*>(originalProto.c_str()), originalProto.size(), packagedData);
if (ret != 0) {
    printf("Failed to package data (byte array input), error code: %d\n", ret);
}
else {
    printf("Successfully packaged data (byte array input): %s\n", packagedData.c_str());
}

unpackage

定义：int unpackage(const unsigned char *pPackage, int nSize, std::string& sProto);

说明：该函数用于将接收到的打包数据进行解包，转换成协议数据。

参数：[IN] pPackage: 指向接收到的打包数据的指针。

[IN] nSize: 打包数据的大小。

[OUT] sProto: 解包后的协议数据字符串。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
scl::CProtoFrame protoFrame;
std::string packagedData;
std::string unpackedProto;
ret = protoFrame.unpackage(reinterpret_cast<const unsigned char*>(packagedData.c_str()), packagedData.size(), unpackedProto);
if (ret != 0) {
    printf("Failed to unpackage data (byte array input), error code: %d\n", ret);
}
else {
    printf("Successfully unpackaged data (byte array input): %s\n", unpackedProto.c_str());
}

触摸事件与按压信息管理接口类型定义

TOUCH_PRESS_TIME：是一个用于定义触摸屏四个角按压时间的结构体。通过设置不同的时间值，可以为触摸屏的左上角、右上角、左下角、右下角分别指定按压时间（单位：毫秒）。

int nLeftTopTimeMs{5000};
int nRightTopTimeMs{5000};
int nLeftBottonTimeMs{5000};
int nRightBottonTimeMs{5000};

FUNC_ON_GET_PRESS_INFO：是一个类型别名，用于定义触摸按压信息的回调函数类型。它通过 std::function 封装，允许用户定义具体的回调函数逻辑，用于获取触摸屏的按压信息。

using FUNC_ON_GET_PRESS_INFO = std::function<int(std::string &GetPressInfo, void *lpParameter)>;

触摸事件与按压信息管理接口

getTouchEvent

定义：int getTouchEvent(std::string &sTouchEventPath);

说明：该函数用于获取触摸事件的设备节点路径。

参数：[OUT] sTouchEventPath: 返回触摸事件设备的路径字符串。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
std::string sTouchEventPath;
if (scl::getTouchEvent(sTouchEventPath) < 0) {
    printf("getTouchEvent failed\n");
} else {
    printf("Touch event path is: %s\n", sTouchEventPath.c_str());
}

simulateTouchCoordinates

定义：int simulateTouchCoordinates(const int nLcdX, const int nLcdY);

说明：该函数用于模拟点击显示屏的特定坐标位置。

参数：[IN] nLcdX: 要模拟点击的X坐标。

[IN] nLcdY: 要模拟点击的Y坐标。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
int nLcdX = 150;
int nLcdY = 250;
if (scl::simulateTouchCoordinates(nLcdX, nLcdY) < 0) {
    printf("simulateTouchCoordinates failed\n");
} else {
    printf("Simulated touch at LCD coordinates (%d, %d)\n", nLcdX, nLcdY);
}

initTouchPressTime

定义：int initTouchPressTime(const scl::TOUCH_PRESS_TIME stTouchPressTime);

说明：该函数用于初始化触摸按压的时间设置。

参数：[IN] stTouchPressTime: 设置触摸按压时间的结构体，包括按压时间的相关配置。

具体数据类型请参见TOUCH_PRESS_TIME

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
scl::TOUCH_PRESS_TIME stTouchPressTime;
stTouchPressTime.nLeftTopTimeMs = 1000;
stTouchPressTime.nRightTopTimeMs = 1500;
stTouchPressTime.nLeftBottonTimeMs = 2000;
stTouchPressTime.nRightBottonTimeMs = 2500;

if (scl::initTouchPressTime(stTouchPressTime) < 0) {
    printf("initTouchPressTime failed\n");
} else {
    printf("Initialized touch press times:\n");
    printf("  Left Top: %d ms\n", stTouchPressTime.nLeftTopTimeMs);
    printf("  Right Top: %d ms\n", stTouchPressTime.nRightTopTimeMs);
    printf("  Left Bottom: %d ms\n", stTouchPressTime.nLeftBottonTimeMs);
    printf("  Right Bottom: %d ms\n", stTouchPressTime.nRightBottonTimeMs);
}

getPressInfoCallBack

定义：int getPressInfoCallBack(const std::string &sCallBackFuncId, FUNC_ON_GET_PRESS_INFO onGetPressInfo, void *lpParameter);

说明：该函数用于注册回调函数，用于获取按压信息。

参数：[IN] sCallBackFuncId: 回调函数的标识符。

[IN] onGetPressInfo: 回调函数，获取按压信息。

[IN] lpParameter: 回调函数的参数，用于传递额外信息。

具体数据类型请参见FUNC_ON_GET_PRESS_INFO

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
int pressInfoCallback(std::string &GetPressInfo, void *lpParameter) {
    printf("Press info received: %s\n", GetPressInfo.c_str());
    return 0; 
}
std::string sCallBackFuncId = "getPressInfoCallBack";
if (scl::getPressInfoCallBack(sCallBackFuncId, pressInfoCallback, nullptr) < 0) {
    printf("getPressInfoCallBack failed\n");
} else {
    printf("Registered press info callback successfully\n");
}

下载线连接状态检测接口

getUsbDeviceCableStatus

定义：int getUsbDeviceCableStatus(int &nUsbCableStatus);

说明：该函数用于获取USB下载线的连接状态。

参数：[OUT] nUsbCableStatus：返回USB下载线的连接状态。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
int nUsbCableStatus = 0;
if (scl::getUsbDeviceCableStatus(nUsbCableStatus) < 0) {
    printf("get usb status failed\n");
}
printf("usb status is %d\n", nUsbCableStatus);

shell相关接口

mount

定义：int mount(const string& sDevNode, const string& sMntDir, int nWritalbe = true);

说明：该函数用于挂载指定的设备节点到目标目录。

参数：[IN] sDevNode: 要挂载的设备节点路径（如 /dev/sda）。

[IN] sMntDir: 目标挂载目录路径（如 /mnt）。

[IN] nWritalbe: 是否以可写模式挂载，默认为 true（可写）。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
std::string sDevNode = "/dev/sda";
std::string sMntDir = "/mnt/test";
int nWritable = 1;

int result = mount(sDevNode, sMntDir, nWritable);
if (result == 0) {
    std::cout << "Mount success!" << std::endl;
} else {
    std::cout << "Mount failed with error code: " << result << std::endl;
}

remount

定义：int remount(const string& sMntDir, bool bWritalbe = true);

说明：该函数用于重新挂载指定的目录，更新其挂载模式（如只读或可写）。

参数：[IN] sMntDir: 需要重新挂载的目录路径。

[IN] bWritalbe: 是否以可写模式重新挂载，默认为 true（可写）。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
8
std::string sMntDir = "/mnt/test";
bool bWritable = 1;
int result = remount(sMntDir, bWritable);
if (result == 0) {
    std::cout << "Remount success!" << std::endl;
} else {
    std::cout << "Remount failed with error code: " << result << std::endl;
}

umount

定义：int umount(const string& sPath);

说明：该函数用于卸载指定的挂载点或设备。

参数：[IN] sPath: 要卸载的挂载点路径或设备节点路径。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
std::string sPath = "/mnt/test";
int result = umount(sPath);
if (result == 0) {
    std::cout << "Unmount success!" << std::endl;
} else {
    std::cout << "Unmount failed with error code: " << result << std::endl;
}

format

定义：int format(const string& sDevNode);

说明：该函数用于格式化指定的设备节点。

参数：[IN] sDevNode: 需要格式化的设备节点路径（如 /dev/sdb）。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
std::string sDevNode = "/dev/sda1";
int result = format(sDevNode);
if (result == 0) {
    std::cout << "Format success!" << std::endl;
} else {
    std::cout << "Format failed with error code: " << result << std::endl;
}

remoteShell

定义：int remoteShell(const string& sCmd, vector *pvecOutput, int nTimeout = 6000);

说明：该函数用于通过远程 Shell 执行指定的命令并获取输出结果。

参数：[IN] sCmd: 要执行的远程命令字符串。

[OUT] pvecOutput: 指向存储命令执行结果输出的字符串向量指针。

[IN] nTimeout: 执行超时时间（单位：毫秒），默认为 6000ms。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
std::string sCmd = "ls -l /";
std::vector<std::string> vecOutput;
int nTimeout = 5000;
int result = remoteShell(sCmd, &vecOutput, nTimeout);
if (result == 0) {
    std::cout << "Remote shell command executed successfully!" << std::endl;
    for (const auto &line : vecOutput) {
        std::cout << line << std::endl;
    }
} else {
    std::cout << "Remote shell command failed with error code: " << result << std::endl;
}

WIFI相关接口类型定义

FUNC_ON_WIFI_LIST_INFO：是一个函数对象，其主要用途是处理 WiFi 列表信息的回调函数。

using FUNC_ON_WIFI_LIST_INFO =
std::function<int(std::list<scl::AP_INFO_T> &stApInfo, void *lpParameter)>;

AP_INFO_T：用于存储单个 WiFi 接入点（AP）的详细信息。

```FUNC_ON_WIFI_LIST_INFO：是一个函数对象，其主要用途是处理 WiFi 列表信息的回调函数。 unsigned int nFrequency{0}; /* frequency / int nSignal{0}; / 信号强度 signal level / std::string sSsid{""}; / ssid / std::string sFlags{""}; / flags / int apSecureType{AP_SECURE_NONE}; / 访问安全类型 / std::string sPasswdSave{""}; / ssid连接成功过的密码保存 / int nSsidStatus{0}; /扫码到的ssid状态 0:未连接，1:之前成功连接过,已保存，2:当前正在连接*/ 

**FUNC_ON_WIFI_AP_INFO**：是一个**函数对象类型**，定义了处理单个 WiFi 接入点（AP）的回调函数接口。

```bash
using FUNC_ON_WIFI_AP_INFO =
std::function<int(scl::AP_INFO_T &stApInfo, void *lpParameter)>;

WIFI_STATE_T：是一个枚举类型，用于表示 WiFi 的连接状态。

typedef enum{
    WIFI_STATE_DISCONNECT,          /* 连接断开 */
    WIFI_STATE_START_CONNECT,       /* 开始连接 */
    WIFI_STATE_SERVER_ERROR,        /* 服务端错误 */
    WIFI_STATE_CONNECTING,          /* 连接中 */
    WIFI_STATE_CONFIG_ERROR,        /* 配置错误 */
    WIFI_STATE_KEY_INCORRECT,       /* 密码错误 */
    WIFI_STATE_CONNECT_ERROR,       /* 连接错误 */
    WIFI_STATE_CONNECT_COMPLETED,   /* 连接完成 */
}WIFI_STATE_T;

*USER_INFO *：用于存储用户输入的 WiFi 网络配置，如 SSID 和密码，以及与 WiFi 连接相关的状态。

std::string sSsid{""};
std::string sPassWord{""};
AP_SECURE_T apSecureType{AP_SECURE_WPA2};
int     nSsidInList{-1}; //-1 =ssid不在扫描列表中，0 = 在扫描列表中
int     nWifiState{-1};/*获取当前连接的状态 WIFI_STATE_T*/

FUNC_ON_WIFI_STATUS：是一个函数对象类型，用于处理 WiFi 连接状态的变化。

using FUNC_ON_WIFI_AP_INFO =
std::function<int(scl::AP_INFO_T &stApInfo, void *lpParameter)>;

WIFI相关接口

registerWifiApListCallBack

定义：int registerWifiApListCallBack(const std::string &sCallBackFuncId, FUNC_ON_WIFI_LIST_INFO onWifiListInfoFunc, void *lpParameter);

说明：该函数用于注册一个回调函数，用于获取 WiFi AP 列表。当 WiFi 扫描列表更新时，回调函数会被调用，将扫描到的 AP 列表传递给应用层。

参数：[IN] sCallBackFuncId：回调函数的标识符，用于区分不同的回调函数。

[IN] onWifiListInfoFunc：回调函数指针，当 WiFi AP 列表更新时，调用此函数并传递扫描到的 AP 列表信息。

[IN] lpParameter：额外的参数，回调函数可以使用此参数传递自定义数据。

具体数据类型请参见FUNC_ON_WIFI_LIST_INFO

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
std::string callbackId = "registerWifiApListCallBack";
FUNC_ON_WIFI_LIST_INFO onWifiListInfo = [](std::list<scl::AP_INFO_T> &stApInfo, void *lpParameter) -> int {
    std::cout << "Received WiFi AP List:\n";
    for (const auto &ap : stApInfo) {
        std::cout << "SSID: " << ap.sSsid << ", Signal Strength: " << ap.nSignal << "\n";  // 修改字段名
    }
    return 0;
};
int result = registerWifiApListCallBack(callbackId, onWifiListInfo, nullptr);
if (result == 0) {
    std::cout << "WiFi AP List Callback Registered Successfully\n";
} else {
    std::cout << "Failed to Register WiFi AP List Callback\n";
}
getchar();

unRegisterWifiApListCallBack

定义：int unRegisterWifiApListCallBack(const std::string &sCallBackFuncId);

说明：该函数用于注销 WiFi AP 列表的回调函数。调用此函数后，系统将不再调用相应的回调函数。

参数：[IN] sCallBackFuncId：回调函数的标识符，指定要注销的回调函数。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
std::string callbackId = "registerWifiApListCallBack";
int result = unRegisterWifiApListCallBack(callbackId);
if (result == 0) {
    std::cout << "WiFi AP List Callback Unregistered Successfully\n";
} else {
    std::cout << "Failed to Unregister WiFi AP List Callback\n";
}

registerWifiApInfoCallBack

定义：int registerWifiApInfoCallBack(const std::string &sCallBackFuncId, FUNC_ON_WIFI_AP_INFO getWifiApInfoFunc, void *lpParameter);

说明：该函数用于注册一个回调函数，用于获取 WiFi AP 的详细信息。当 WiFi AP 信息更新时，回调函数会被调用，将 WiFi AP 的详细信息传递给应用层。

参数：[IN] sCallBackFuncId：回调函数的标识符，用于区分不同的回调函数。

[IN] getWifiApInfoFunc：回调函数指针，当 WiFi AP 信息更新时，调用此函数并传递当前的 AP 信息。

[IN] lpParameter：额外的参数，回调函数可以使用此参数传递自定义数据。

具体数据类型请参见FUNC_ON_WIFI_AP_INFO

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
std::string callbackId = "registerWifiApInfoCallBack";
FUNC_ON_WIFI_AP_INFO onWifiApInfo = [](scl::AP_INFO_T &stApInfo, void *lpParameter) -> int {
    std::cout << "Received WiFi AP Info:\n";
    std::cout << "SSID: " << stApInfo.sSsid << ", Signal Strength: " << stApInfo.nSignal << "\n";  // 修改字段名
    return 0;
};

int result = registerWifiApInfoCallBack(callbackId, onWifiApInfo, nullptr);
if (result == 0) {
    std::cout << "WiFi AP Info Callback Registered Successfully\n";
} else {
    std::cout << "Failed to Register WiFi AP Info Callback\n";
}
getchar();

unRegisterWifiApInfoCallBack

定义：int unRegisterWifiApInfoCallBack(const std::string &sCallBackFuncId);

说明：该函数用于注销 WiFi AP 信息的回调函数。调用此函数后，系统将不再调用相应的回调函数。

参数：[IN] sCallBackFuncId：回调函数的标识符，指定要注销的回调函数。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
std::string callbackId = "registerWifiApInfoCallBack";
int result = unRegisterWifiApInfoCallBack(callbackId);
if (result == 0) {
    std::cout << "WiFi AP Info Callback Unregistered Successfully\n";
} else {
    std::cout << "Failed to Unregister WiFi AP Info Callback\n";
}

getSignal

定义：int getSignal();

说明：该函数用于获取当前 WiFi 信号的强度值。

参数：无

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
int signalStrength = getSignal();
std::cout << "WiFi Signal Strength: " << signalStrength << std::endl;

getStatus

定义：int getStatus(WIFI_STATE_T &nWifiStat);

说明：该函数用于获取当前 WiFi 的连接状态。

参数：[OUT] nWifiStat：返回 WiFi 当前的连接状态。

具体数据类型请参见WIFI_STATE_T

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
WIFI_STATE_T wifiState;
int result = getStatus(wifiState);
if (result == 0) {
    std::cout << "WiFi Status: " << wifiState << std::endl;
} else {
    std::cout << "Failed to get WiFi status." << std::endl;
}

getConnectInfo

定义：int getConnectInfo(USERINFO &stUserInfo);

说明：该函数用于获取当前已连接的 WiFi 用户信息，包括 SSID、密码及认证方式等。

参数：[OUT] stUserInfo：返回当前已连接的 WiFi 用户信息。

具体数据类型请参见USERINFO

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
USER_INFO userInfo;
int result = getConnectInfo(userInfo);
if (result == 0) {
    std::cout << "WiFi User Info - SSID: " << userInfo.sSsid 
        << ", Password: " << userInfo.sPassWord
        << ", Auth Method: ";
    switch (userInfo.apSecureType) {
        case AP_SECURE_NONE:
            std::cout << "None";
            break;
        case AP_SECURE_WEP_OPEN:
            std::cout << "WEP Open";
            break;
        case AP_SECURE_WEP_SHARED:
            std::cout << "WEP Shared";
            break;
        case AP_SECURE_WPA:
            std::cout << "WPA";
            break;
        case AP_SECURE_WPA2:
            std::cout << "WPA2";
            break;
        default:
            std::cout << "Unknown";
            break;
    }
    std::cout << std::endl;
} else {
    std::cout << "Failed to get WiFi connection info." << std::endl;
}

getAPCacheList

定义：int getAPCacheList(std::list &listApInfo);

说明：该函数用于获取缓存的 WiFi AP 列表。

参数：[OUT] listApInfo：返回存储缓存 AP 信息的列表，使用 AP_INFO_T 结构体表示。

具体数据类型请参见AP_INFO_T

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
std::list<AP_INFO_T> apInfoList;
int result = getAPCacheList(apInfoList); 
if (result == 0) {
    std::cout << "AP Cache List: " << std::endl;
    for (const auto& ap : apInfoList) {
        std::cout << "SSID: " << ap.sSsid 
            << ", Signal Strength: " << ap.nSignal 
            << ", Security Type: ";
        switch (ap.apSecureType) {
            case AP_SECURE_NONE:
                std::cout << "None";
                break;
            case AP_SECURE_WEP_OPEN:
                std::cout << "WEP Open";
                break;
            case AP_SECURE_WEP_SHARED:
                std::cout << "WEP Shared";
                break;
            case AP_SECURE_WPA:
                std::cout << "WPA";
                break;
            case AP_SECURE_WPA2:
                std::cout << "WPA2";
                break;
            default:
                std::cout << "Unknown";
                break;
        }

        std::cout << ", SSID Status: " << ap.nSsidStatus << std::endl;
    }
} else {
    std::cout << "Failed to get AP Cache list." << std::endl;
}

getAPList

定义：int getAPList(std::list &listApInfo);

说明：该函数用于获取当前可用的 WiFi AP 列表。

参数：[OUT] listApInfo：返回当前可用的 WiFi AP 列表，使用 AP_INFO_T 结构体表示。

具体数据类型请参见AP_INFO_T

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
std::list<AP_INFO_T> apInfoList;
int result = getAPList(apInfoList);
if (result == 0) {
    std::cout << "AP List: " << std::endl;
    for (const auto& ap : apInfoList) {
        std::cout << "SSID: " << ap.sSsid 
            << ", Signal Strength: " << ap.nSignal 
            << ", Security Type: ";
        switch (ap.apSecureType) {
            case AP_SECURE_NONE:
                std::cout << "None";
                break;
            case AP_SECURE_WEP_OPEN:
                std::cout << "WEP Open";
                break;
            case AP_SECURE_WEP_SHARED:
                std::cout << "WEP Shared";
                break;
            case AP_SECURE_WPA:
                std::cout << "WPA";
                break;
            case AP_SECURE_WPA2:
                std::cout << "WPA2";
                break;
            default:
                std::cout << "Unknown";
                break;
        }

        std::cout << ", SSID Status: " << ap.nSsidStatus << std::endl;
    }
} else {
    std::cout << "Failed to get AP list." << std::endl;
}

connectwifi

定义：int connectwifi();

说明：该函数用于根据已保存的 WiFi 用户信息进行连接。

参数：无

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
int result = connectwifi();
if (result == 0) {
    std::cout << "WiFi connection successful!" << std::endl;
} else {
    std::cout << "WiFi connection failed!" << std::endl;
}

getWifiOperastatus

定义：int getWifiOperastatus();

说明：该函数用于获取当前 WiFi 的连接操作状态。

参数：无

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
8
int status = getWifiOperastatus();
if (status < 0) {
    std::cout << "WiFi operation failed." << std::endl;
} else if (status == 0) {
    std::cout << "WiFi connected to hotspot." << std::endl;
} else if (status == 1) {
    std::cout << "WiFi disconnected from hotspot." << std::endl;
}

openWifiHotSpot

定义：int openWifiHotSpot();

说明：该函数用于开启 WiFi 热点，默认设置 SSID 和密码。

参数：无

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
int ret = openWifiHotSpot();
if (ret == 0) {
    std::cout << "WiFi hotspot opened successfully!" << std::endl;
} else {
    std::cout << "Failed to open WiFi hotspot. Error code: " << ret << std::endl;
}

closeWifiHotSpot

定义：int closeWifiHotSpot();

说明：该函数用于关闭 WiFi 热点。

参数：无

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
int ret = closeWifiHotSpot();
if (ret == 0) {
    std::cout << "WiFi hotspot closed successfully!" << std::endl;
} else {
    std::cout << "Failed to close WiFi hotspot. Error code: " << ret << std::endl;
}

wifiHotSpotSsid

定义：int wifiHotSpotSsid(const std::string &sSSid);

说明：该函数用于修改 WiFi 热点的 SSID 名称。

参数：[IN] sSSid：新的 SSID 名称。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
std::string newSsid = "MyHotSpot";
int ret = wifiHotSpotSsid(newSsid);
if (ret == 0) {
    std::cout << "WiFi hotspot SSID updated successfully to: " << newSsid << std::endl;
} else {
    std::cout << "Failed to update WiFi hotspot SSID. Error code: " << ret << std::endl;
}

wifiHotSpotPasswd

定义：int wifiHotSpotPasswd(const std::string &sPassWd);

说明：该函数用于修改 WiFi 热点的密码。

参数：[IN] sPassWd：新的 WiFi 热点密码。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
std::string newPasswd = "SecurePassword123";
int ret = wifiHotSpotPasswd(newPasswd);
if (ret == 0) {
    std::cout << "WiFi hotspot password updated successfully to: " << newPasswd << std::endl;
} else {
    std::cout << "Failed to update WiFi hotspot password. Error code: " << ret << std::endl;
}

registerWifiStatusCallBack

定义：int registerWifiStatusCallBack(const std::string &sCallBackFuncId, FUNC_ON_WIFI_STATUS onWifiStatusFunc, void *lpParameter);

说明：该函数用于注册 WiFi 状态变化的回调函数，当 WiFi 状态发生变化时，回调函数会被调用。

参数：[IN] sCallBackFuncId：回调函数的标识符，用于区分不同的回调函数。

[IN] onWifiStatusFunc：回调函数指针，当 WiFi 状态变化时，调用此函数并传递当前的用户信息。

[IN] lpParameter：额外的参数，回调函数可以使用此参数传递自定义数据。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
std::string callbackId = "wifiStatusCallback";
FUNC_ON_WIFI_STATUS onWifiStatusFunc = [](USER_INFO &stUserInfo, void *lpParameter) -> int {
    std::cout << "WiFi Status Callback Triggered!" << std::endl;
    std::cout << "SSID: " << stUserInfo.sSsid << std::endl;
    std::cout << "Password: " << stUserInfo.sPassWord << std::endl;
    std::cout << "Security Type: " << stUserInfo.apSecureType << std::endl;
    std::cout << "SSID In List: " << stUserInfo.nSsidInList << std::endl;
    std::cout << "WiFi State: " << stUserInfo.nWifiState << std::endl;
    return 0;
};
void *lpParameter = nullptr;
int ret = registerWifiStatusCallBack(callbackId, onWifiStatusFunc, lpParameter);
if (ret == 0) {
    std::cout << "WiFi status callback registered successfully!" << std::endl;
} else {
    std::cout << "Failed to register WiFi status callback. Error code: " << ret << std::endl;
}
getchar();

unRegisterWifiStatusCallBack

定义：int unRegisterWifiStatusCallBack(const std::string &sCallBackFuncId);

说明：该函数用于注销 WiFi 状态变化的回调函数，停止接收 WiFi 状态变化通知。

参数：[IN] sCallBackFuncId：回调函数的标识符，指定要注销的回调函数。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
std::string callbackId = "wifiStatusCallback";
int ret = unRegisterWifiStatusCallBack(callbackId);
if (ret == 0) {
    std::cout << "WiFi status callback unregistered successfully!" << std::endl;
} else {
    std::cout << "Failed to unregister WiFi status callback. Error code: " << ret << std::endl;
}

startWifiConnect

定义：int startWifiConnect(const std::string &sSsid, const std::string &sPasswd);

说明：该函数用于开始连接 WiFi。根据给定的 SSID 和密码进行连接。

参数：[IN] sSsid：WiFi 的 SSID 名称。

[IN] sPasswd：WiFi 的密码。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
USER_INFO userInfo;
userInfo.sSsid = "WECON-WLAN";
userInfo.sPassWord = "xiaoniuniu";
userInfo.apSecureType = AP_SECURE_WPA2;
int result = startWifiConnect(userInfo.sSsid, userInfo.sPassWord);
if (result == 0) {
    std::cout << "WiFi connection started successfully!" << std::endl;
} else {
    std::cout << "Failed to start WiFi connection!" << std::endl;
}

stopWifiConnect

定义：int stopWifiConnect();

说明：该函数用于停止 WiFi 连接操作，断开当前连接。

参数：无

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
int result = stopWifiConnect();
if (result == 0) {
    std::cout << "WiFi connection stopped successfully!" << std::endl;
} else {
    std::cout << "Failed to stop WiFi connection!" << std::endl;
}

removeSsidSaveRecode

定义：int removeSsidSaveRecode(const std::string &sSsid);

说明：该函数用于移除指定 SSID 的掉电保存记录，清除存储的 WiFi 配置信息。

参数：[IN] sSsid：需要移除的 SSID。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
std::string ssid = "MyHotspot";
int ret = removeSsidSaveRecode(ssid);
if (ret == 0) {
    std::cout << "SSID record removed successfully for: " << ssid << std::endl;
} else {
    std::cout << "Failed to remove SSID record. Error code: " << ret << std::endl;
}

4G相关接口类型定义

FUNC_ON_4G_GET_AT_INFO：是一个函数对象，通过回调函数来异步处理4G模块返回的AT指令信息

using FUNC_ON_4G_GET_AT_INFO = 
std::function<int(scl::AT_INFO &stAtInfo, void *lpParameter)>;

*APN_INFO_T *：表示与APN（接入点名称）相关的信息。

std::string sApnName{""};
std::string sApnNum{""};
std::string sApnUsr{""};
std::string sApnPasswd{""};
std::string sFunction{""};

FUNC_ON_4G_GET_NETWORK_DIAGNO：是一个函数对象，其主要用途是用于处理网络诊断结果。

using FUNC_ON_4G_GET_NETWORK_DIAGNO = 
std::function<int(scl::NETWORKDIAGNOSTICSRESULT &stNetworkDiagnosticsResult, void *lpParameter)>;

AT_INFO_T：用于存储与4G模块相关的各种信息。

std::string sIccid{""};         // SIM卡ICCID
std::string sManufacturer{""};  // 模块制造商
std::string sModel{""};         // 模块型号
std::string sRevision{""};      // 模块版本号
std::string sImei{""};          // 模块IMEI唯一识别码

std::string sCops{""};       // SIM卡运营商信息 +COPS: 0,2,"46011",7
std::string sSimStat{""};    // SIM卡插入状态(存在:READY . 不存在:ERROR)
std::string sLongitude{""};  // 经度
std::string sLatitude{""};   // 纬度

int nSignal{-1};  // 信号值 （99：模块异常无效值.  正常值:0~31）
int nReg{-1};     // 驻网状态 ()
int nLac{-1};     // 基站号
int nCellId{-1};  // 小区号
int nNetRegistStatus{-1};      // 注册网络状态 1-- 正常，其它值异常
std::string sServingcell{""};  // 网络类型及状态
int nOperator{-1};             // sim卡运营商信息

4G相关接口

get4gCsqSignal

定义：int get4gCsqSignal();

说明：该函数用于直接设备端获取信号值。

参数：无

返回值：返回值：[OUT] 返回信号强度值。

示例：

1
2
int result = get4gCsqSignal();
printf("real signal is %d\n", result);

get4gIccid

定义：get4gIccid(std::string &sIccidResp);

说明：该函数用于从设备端获取4G模块SIM卡的ICCID。

参数：[OUT] sIccidResp: 用于接收ICCID结果的字符串。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
std::string iccid;
int result = get4gIccid(iccid);
if (result == 0) {
    std::cout << "4G ICCID: " << iccid << "\n";
} else {
    std::cout << "Failed to Retrieve 4G ICCID\n";
}

get4gImei

定义：int get4gImei(std::string &sImei);

说明：该函数用于从设备端获取4G模块的IMEI。

参数：[OUT] sImei: 用于接收IMEI结果的字符串。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
std::string imei;
int result = get4gImei(imei);
if (result == 0) {
    std::cout << "4G IMEI: " << imei << "\n";
} else {
    std::cout << "Failed to Retrieve 4G IMEI\n";
}

getCsqSignal

定义：int getCsqSignal();

说明：该函数用于获取当前信号强度值。

参数：无

返回值：[OUT] 返回信号强度值。

示例：

1
2
int result = getCsqSignal();
printf("real signal is %d\n", result);

getCCID

定义：int getCCID(std::string &sIccidResp);

说明：该函数用于获取SIM卡的CCID。

参数：[OUT] sIccidResp: 用于接收CCID结果的字符串。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
std::string sIccidResp;
int result = getCCID(sIccidResp);
if (result == 0) {
    std::cout << "SIM card CCID: " << sIccidResp << "\n";
} else {
    std::cout << "Failed to get SIM card CCID. Error code: " << result << "\n";
}

register4gAtInfoCallBack

定义：int register4gAtInfoCallBack(const std::string &sCallBackFuncId, FUNC_ON_4G_GET_AT_INFO get4gAtInfoFunc, void *lpParameter);

说明：该函数用于注册一个回调函数，以异步接收4G模块的AT信息。

参数：[IN] sCallBackFuncId: 回调函数的标识符。

[IN] get4gAtInfoFunc: 回调函数，用于处理4G AT信息。

[IN] lpParameter: 附加参数，将传递给回调函数。

具体数据类型请参见FUNC_ON_4G_GET_AT_INFO

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
std::string callbackId = "register4gAtInfoCallBackDemo";
FUNC_ON_4G_GET_AT_INFO on4gAtInfo = [](scl::AT_INFO &stAtInfo, void *lpParameter) -> int {
    std::cout << "Received 4G AT Info:\n";
    std::cout << "ICCID: " << stAtInfo.sIccid << "\n";
    std::cout << "Manufacturer: " << stAtInfo.sManufacturer << "\n";
    std::cout << "Model: " << stAtInfo.sModel << "\n";
    std::cout << "IMEI: " << stAtInfo.sImei << "\n";
    std::cout << "Signal Strength: " << stAtInfo.nSignal << "\n";
    std::cout << "Network Registration Status: " << stAtInfo.nNetRegistStatus << "\n";
    return 0;
};
int result = register4gAtInfoCallBack(callbackId, on4gAtInfo, nullptr);
if (result == 0) {
    std::cout << "4G AT Info Callback Registered Successfully\n";
} else {
    std::cout << "Failed to Register 4G AT Info Callback\n";
}
getchar();

unRegister4gAtInfoCallBack

定义：int unRegister4gAtInfoCallBack(const std::string &sCallBackFuncId);

说明：该函数用于注销之前注册的4G模块AT信息回调函数。

参数：[IN] sCallBackFuncId: 要注销的回调函数标识符。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
std::string callbackId = "register4gAtInfoCallBackDemo";
int result = unRegister4gAtInfoCallBack(callbackId);
if (result == 0) {
    std::cout << "4G AT Info Callback Unregistered Successfully\n";
} else {
    std::cout << "Failed to Unregister 4G AT Info Callback\n";
}

resetDevice

定义：int resetDevice();

说明：该函数用于复位4G模块设备，类似于设备重启。

参数：无

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
int result = resetDevice();
if (result == 0) {
    std::cout << "resetDevice succeeded." << std::endl;
} else {
    std::cout << "resetDevice failed with error code: " << result << std::endl;
}

get4gAtInfo

定义：int get4gAtInfo(AT_INFO_T &stAtInfo);

说明：该函数用于获取4G模块的基础信息，包括IMEI、IMSI等相关内容。

参数：[OUT] stAtInfo: 用于接收基础信息的结构体。

具体数据类型请参见AT_INFO_T

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
AT_INFO_T atInfo;
int result = get4gAtInfo(atInfo);
std::cout << "get4gAtInfo() result: " << result << "\n"
    << "IMEI: " << atInfo.sImei << "\n"
    << "Manufacturer: " << atInfo.sManufacturer << "\n"
    << "Signal: " << atInfo.nSignal << std::endl;

setApn

定义：int setApn(const APN_INFO_T &stApnInfo);

说明：该函数用于一次性配置APN的接入点名称、用户名和密码。

参数：[IN] stApnInfo: 包含APN名称、用户名和密码的结构体。

具体数据类型请参见APN_INFO_T

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
APN_INFO_T apnInfo;
apnInfo.sApnName = "internet_apn";
apnInfo.sApnNum = "*99#";
apnInfo.sApnUsr = "user";
apnInfo.sApnPasswd = "password";
apnInfo.sFunction = "default_function";
int result = setApn(apnInfo);
if (result == 0) {
    std::cout << "setApn succeeded." << std::endl;
} else {
    std::cout << "setApn failed with error code: " << result << std::endl;
}

setApnName

定义：int setApnName(const std::string &sApnName);

说明：该函数用于单独配置APN的接入点名称。

参数：[IN] sApnName: 要设置的APN名称字符串。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
std::string apnName = "internet_apn";
int result = setApnName(apnName);
if (result == 0) {
    std::cout << "setApnName succeeded." << std::endl;
} else {
    std::cout << "setApnName failed with error code: " << result << std::endl;
}

setApnNum

定义：int setApnNum(const std::string &sApnNum);

说明：该函数用于单独配置APN拨号时使用的号码。

参数：[IN] sApnNum: 要设置的拨号号码字符串。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
std::string apnNum = "*99#";
int result = setApnNum(apnNum);
if (result == 0) {
    std::cout << "setApnNum succeeded." << std::endl;
} else {
    std::cout << "setApnNum failed with error code: " << result << std::endl;
}

setApnUsr

定义：int setApnUsr(const std::string &sApnUsr);

说明：该函数用于单独配置APN的用户名。

参数：[IN] sApnUsr: 要设置的用户名字符串。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
std::string apnUsr = "user";
int result = setApnUsr(apnUsr);
if (result == 0) {
    std::cout << "setApnUsr succeeded." << std::endl;
} else {
    std::cout << "setApnUsr failed with error code: " << result << std::endl;
}

setApnPasswd

定义：int setApnPasswd(const std::string &sApnPasswd);

说明：该函数用于单独配置APN的密码。

参数：[IN] sApnPasswd: 要设置的密码字符串。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
std::string apnPasswd = "password";
int result = setApnPasswd(apnPasswd);
if (result == 0) {
    std::cout << "setApnPasswd succeeded." << std::endl;
} else {
    std::cout << "setApnPasswd failed with error code: " << result << std::endl;
}

setApnFunction

定义：int setApnFunction(const bool &bEnable);

说明：该函数用于启用或关闭APN功能。

参数：[IN] bEnable: 设置为true表示启用，设置为false表示关闭。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
bool enable = true;
int result = setApnFunction(enable);
if (result == 0) {
    std::cout << "setApnFunction succeeded." << std::endl;
} else {
    std::cout << "setApnFunction failed with error code: " << result << std::endl;
}

getApn

定义：int getApn(APN_INFO_T &stApnInfo);

说明：该函数用于获取当前配置的APN名称、用户名和密码信息。

参数：[OUT] stApnInfo: 用于接收APN信息的结构体。

具体数据类型请参见APN_INFO_T

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
APN_INFO_T apnInfo;
int result = getApn(apnInfo);
std::cout << "APN Name: " << apnInfo.sApnName << "\n"
    << "APN User: " << apnInfo.sApnUsr << "\n"
    << "APN Password: " << apnInfo.sApnPasswd << std::endl;

if (result == 0) {
    std::cout << "getApn succeeded." << std::endl;
} else {
    std::cout << "getApn failed with error code: " << result << std::endl;
}

register4gModuleDiagnoCallBack

定义：int register4gModuleDiagnoCallBack(const std::string &sCallBackFuncId, FUNC_ON_4G_GET_NETWORK_DIAGNO get4gNetDiagnoFunc, void *lpParameter);

说明：该函数用于注册一个回调函数，以接收4G模块的网络故障诊断结果。

参数：[IN] sCallBackFuncId: 回调函数的标识符。

[IN] get4gNetDiagnoFunc: 回调函数，用于处理网络诊断结果。

[IN] lpParameter: 附加参数，将传递给回调函数。

具体数据类型请参见FUNC_ON_4G_GET_NETWORK_DIAGNO

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
const std::string callbackId = "register4gModuleDiagnoCallBack";
    int result = register4gModuleDiagnoCallBack(callbackId,
        [](scl::NETWORKDIAGNOSTICSRESULT &stNetworkDiagnosticsResult, void *lpParameter) -> int {
            std::cout << "Received Network Diagnosis Result:\n";
            std::cout << "Device Status: " << stNetworkDiagnosticsResult.nDeviceStatus << "\n";
            std::cout << "SIM Card Status: " << stNetworkDiagnosticsResult.nSimCardStatus << "\n";
            std::cout << "Signal Strength: " << stNetworkDiagnosticsResult.nSignal << "\n";
            std::cout << "Error Code: " << stNetworkDiagnosticsResult.nErrorCode << "\n";
            std::cout << "Diagnostics Result: " << stNetworkDiagnosticsResult.sDiagnosticsResult << "\n";
            return 0;  // Return 0 to indicate success
        },
        nullptr);
if (result == 0) {
    std::cout << "Successfully registered 4G module diagnosis callback.\n";
} else {
    std::cout << "Failed to register callback. Error code: " << result << "\n";
}
getchar();

unRegister4gModuleDiagnoCallBack

定义：int unRegister4gModuleDiagnoCallBack(const std::string &sCallBackFuncId);

说明：该函数用于注销之前注册的4G模块网络故障诊断回调函数。

参数：[IN] sCallBackFuncId: 要注销的回调函数标识符。

返回值：返回 0 表示成功，其他返回值表示错误。

示例：

1
2
3
4
5
6
7
const std::string callbackId = "register4gModuleDiagnoCallBack";
int result = unRegister4gModuleDiagnoCallBack(callbackId);
if (result == 0) {
    std::cout << "Successfully unregistered 4G module diagnosis callback.\n";
} else {
    std::cout << "Failed to unregister callback. Error code: " << result << "\n";
}