华为智能家居可以加盟吗_华为智能家居加盟官网

信息来源：互联网发布时间：2024-10-08

本文分享自华为云社区《华为云IoT+OpenHarmony的智能家居开发【华为云IoT+鸿蒙】华为云IoT+鸿蒙-云社区-华为云》，作者：袁睿。一、选题说明1. 选题为基于OpenHarmony的智能家居，应用场景为户用，受益人群为住户。2

本文分享自华为云社区《华为云IoT+OpenHarmony的智能家居开发【华为云IoT+鸿蒙】华为云IoT+鸿蒙-云社区-华为云》，作者：袁睿一、选题说明1. 选题为基于OpenHarmony的智能家居，应用场景为户用，受益人群为住户。

2. 开发的软件设备为智能门锁，储物精灵，软硬件开发都有的是光伏逆变器3. 解决的问题：传统的智能家居：智能单品，需要手动加入场景，无网不能智能控制创新的智能家居：空间智能，自发现后融入场景，分布式软总线控制。

4. 关键功能点：智能门锁：密码解锁，NFC解锁，数字管家控制，服务卡片控制储物精灵：密码解锁，NFC解锁，防火帘控制，分布式软总线控制逆变器：单相逆变，隔离拓扑，组件小型化，高转换率与低总谐波失真二、竞赛开发平台

1. 操作系统：OpenHarmony 3.02. 开发软件：VS code（Deveco studio tool），DevEco Studio3. 开发板：深开鸿KHDVK-3861B，润和DAYU200，润和hispark AI Camera

3. 关于环境：操作系统：Ubuntu 编译构建：Python包管理工具：HPM NPM 环境：Node.js烧录软件：Hiburn USB串口驱动：CH341SER.exe本地ssh：finalshell ssh文件对比：Beyond Conpare

4. 虚拟机（1）虚拟机环境Ubuntu（华为的硬件开发一般都在此linux环境下进行）虚拟机Vmware：下载之后使用上述提到的华为云中国镜像下载VS code的Linux版与OpenHarmony3.0源码。

（2）虚拟机环境：将Ubuntu Shell环境修改为bash：ls -l /bin/sh在下载VS code后下载华为硬件编制插件（Device tool）（3） HB编译插件：安装：python3 -m pip install --user ohos-build

变量：vim ~/.bashrc复制粘贴到.bashrc的最后一行：export PATH=~/.local/bin:$PATH更新变量：source ~/.bashrc检查：pip install ohos-build

5. 逆变器的主要硬件选材：（1）选材方案（选型依据）Diode（二极管）：高频检波电路，小型化，配对二极管不混组Inductor（感应器）：标称电感值，自共振频率（与互感值成正比）直流电阻（尽可能小），额定电流，直流重叠允许电流，温度上升允许电流。

Resistor（电阻器）：贴片电阻，根据稳定性需求选择薄膜或厚膜SPICE NMOS：封装尺寸，基本上封装越大越好，能承受的电流就越大；导通电压Vgs，尽量选择比实际电路中可提供的控制电压小的；导通电阻Rds，越小越好相应的导通电阻越小、分压越小、发热也越小。

寄生电容Cgs，会影响mos的打开速度寄生电容太大，方波会失真Rds越小，Cgs越大（2）主要选材

半导体选材：国产半导体RX65T125PS2A电源IC选材：国产IC芯片ID7s625DSP处理器：洞察到STM32系列软合了DSP处理器的功能三、方案详述（一）储物精灵（1）用户角度：先从用户角度考虑需求与如何使用，再从技术层面解析。

（具体用户使用方法这里不多赘述，详细内容直接看下午开发内容）（2）实现原理：（下文的步骤会详细介绍，在这里先介绍初期设想）① 关于Mqtt协议在华为云的打通（设备在线激活）：使用mqttX或mqttfx。

② 华为云：根据提示创建并获取密钥等信息，获取ClientID等身份识别信息，然后在云端的Topic（事件主题）中自定义订阅与发布，对产品进行定义③ AppGallery Connect网站：创建并注册HarmonyOS产品，根据提示流程。

④ 设备开发具体解析：每个设备都是一个子节点，实现了基于OpenHarmony设备的L0、L1、L2设备之间的互联互通主控程序基于 OpenHarmony JS应用程序框架设计实现，并使用MQTT物联网通信协议接入华为云IOT平台，同时可将控制指令发送至华为云IOT平台，供云端处理。

DAYU开发板（软件+硬件）具体实现为中控MQTT通信过程处于内核态驱动程序，JS应用通过发起接口调用后，进入用户态调用内核态接口的流程，并且JS应用会将所需要向云端发送的MQTT协议主题内容直接传入内核态，内核态不作数据处理和解析，直接将数据发布至云端，这样设计的目的是为了在添加设备的时候，仅需改变JS应用的数据结构，并不需要修改设备的代码，完成了解耦合。

NFC录入与记录：使用NFC扩展板录入，详细请见下方软总线设备通讯链接⑤ 智能识别对比：识别对象的数据库，这里的识别作为单一的照片识别vuforia 的服务器制作该 target 的识别数据库，该数据库要下载并绑定工程到target。

图片由摄像头获取视频逐帧比对（3）设备侧第一步：网络连接使设备接电后自动联网我们会在代码中预置热点名称与密码在创建包后新建mqtt_entry.c用于存放热点自连代码的地址：/home/open/Downloads/code-v3.0-LTS/OpenHarmony/applications/sample/wifi-iot/app/mqtt_demo

{ int ret; errno_t rc; hi_wifi_assoc_request assoc_req = {0}; /* 拷贝SSID到assoc的req *//* copy SSID to assoc_req */

rc = memcpy_s(assoc_req.ssid, HI_WIFI_MAX_SSID_LEN + 1, "rui666", 8); //热点名/* WPA-PSK. CNcomment: 认证类型:WPA2-PSK.CNend */

if (rc != EOK) { return-1; } //热点加密方式 assoc_req.auth = HI_WIFI_SECURITY_WPA2PSK; memcpy

(assoc_req.key, "88888888", 11); //热点的密码 ret = hi_wifi_sta_connect(&assoc_req); if (ret != HISI_OK) {

return-1; } return0; } //预置热点名和密码在设备通电后会自连这里把原有的ability等量代换成了自发现热点。

*OpenHarmony_ability的碰一碰自发现与自配网见下述第二步：上报订阅与下发，在此包内创建main函数/home/open/Downloads/code-v3.0-LTS/OpenHarmony/applications/sample/wifi-iot/app/mqtt_demo。

voidmqtt_callback(MessageData *msg_data){ size_t res_len = 0; uint8_t *response_buf =

NULL; char topicname[45] = { "$crsp/" }; LOS_ASSERT(msg_data); printf("topic %.*s receive a message\r\n"

, msg_data->topicName->lenstring.len, msg_data->topicName->lenstring.data); printf("message is %.*s\r\n"

, msg_data->message->payloadlen, msg_data->message->payload); } intmqtt_connect

(void){ int rc = 0; NetworkInit(&n); NetworkConnect(&n, "a161fa3144.iot-mqtts.cn-north-4.myhuaweicloud.com"

, 1883); buf_size = 4096+1024; onenet_mqtt_buf = (unsignedchar *) malloc(buf_size); onenet_mqtt_readbuf = (

unsignedchar *) malloc(buf_size); if (!(onenet_mqtt_buf && onenet_mqtt_readbuf)) {

printf("No memory for MQTT client buffer!"); return-2; } MQTTClientInit(&mq_client, &n,

1000, onenet_mqtt_buf, buf_size, onenet_mqtt_readbuf, buf_size); MQTTStartTask(&mq_client); data.keepAliveInterval =

30; data.cleansession = 1; data.clientID.cstring = "61f6e729de9933029be57672_88888888_0_0_2022020905"

; data.username.cstring = "61f6e729de9933029be57672_88888888"; data.password.cstring =

"43872acc0b1e6aa7bf9e6a69f12aa9b1ebc07daffb67e18cf905c847a594f813"; data.cleansession = 1; mq_client.defaultMessageHandler = mqtt_callback;

//连接服务器 rc = MQTTConnect(&mq_client, &data); //订阅消息，设置回调函数 MQTTSubscribe(&mq_client,

"porsche", 0, mqtt_callback); while(1) { MQTTMessage message; message.qos = QOS1; message.retained =

0; message.payload = (void *)"openharmony"; message.payloadlen = strlen("openharmony"

); //上报if (MQTTPublish(&mq_client, "hi3861", &message) < 0) { printf

("MQTTPublish faild !\r\n"); } IoTGpioSetOutputVal(9, 0); //9gpio 0 light on

usleep(1000000); } return0; } 第三步：储物精灵保险模式&舵机开门舵机开锁：int servoID =

0; voidMy_servo(uint8_t servoID,int angle){ int j=0; int k=2000/200; angle = k*angle;

for (j=0;j<5;j++){ IoTGpioSetOutputVal(servoID, 1); hi_udelay(angle); IoTGpioSetOutputVal(servoID,

1); hi_udelay(20000-angle); } } 保险模式：staticintDealSetPassword(cJSON *objCmd){ int

ret = -1; char *pstr = NULL; cJSON *objParas = NULL; cJSON *objPara = NULL; CommandParamSetPsk setLockPskParam;

memset(&setLockPskParam, 0x00, sizeof(CommandParamSetPsk)); if ((objParas = cJSON_GetObjectItem(objCmd,

"paras")) == NULL) { RaiseLog(LOG_LEVEL_ERR, "Paras not exist"); return ret; } if

((objPara = cJSON_GetObjectItem(objParas, "PskId")) != NULL) { char *id = cJSON_GetStringValue(objPara);

//密码标识（string型）if (id == NULL || strlen(id) > LOCK_ID_LENGTH) { RaiseLog(LOG_LEVEL_ERR, "check lock id failed!"

); return-1; } strncpy(setLockPskParam.id, id, strlen(id)); } else {

return ret; } if ((objPara = cJSON_GetObjectItem(objParas, "Option")) != NULL) { char *option = cJSON_GetStringValue(objPara);

printf("option = %c \n", *option); //三个命令（string型）if (*option == A) { setLockPskParam.option = OPTION_ADD;

//新增密码 } elseif (*option == U) { setLockPskParam.option = OPTION_UPDATE; //更新密码

} elseif (*option == D) { setLockPskParam.option = OPTION_DELETE; //删除密码 }

else { RaiseLog(LOG_LEVEL_ERR, "no such option(%c)!", *option); return-1; } }

else { return ret; } if ((objPara = cJSON_GetObjectItem(objParas, "LockPsk")) != NULL

) { char *psk = cJSON_GetStringValue(objPara); if (psk == NULL || strlen(psk) > LOCK_PSK_LENGTH) { RaiseLog(LOG_LEVEL_ERR,

"check psk failed!"); return-1; } strncpy(setLockPskParam.password, psk,

strlen(psk)); } else { return ret; } ret = IotProfile_CommandCallback(CLOUD_COMMAND_SETPSK, &setLockPskParam);

return ret; } 第四步：标注GPIO口识别GPIO口与接入（这里要注意一个接的是正极一个是接地还有一个为信号传输口）voidmqtt_test(void) { IoTGpioInit

(9); IoTGpioSetDir(9, IOT_GPIO_DIR_OUT); mqtt_connect(); } 第五步：吊起mqtt协议（build.gn版）与主函数平行的Build.gn，吊起函数与第三方库的内容：

sources = [ "mqtt_test.c", "mqtt_entry.c" ] include_dirs = [ "//utils/native/lite/include"

, "//kernel/liteos_m/components/cmsis/2.0", "//base/iot_hardware/interfaces/kits/wifiiot_lite"

, "//vendor/hisi/hi3861/hi3861/third_party/lwip_sack/include", "//foundation/communication/interfaces/kits/wifi_lite/wifiservice"

, "//third_party/pahomqtt/MQTTPacket/src", "//third_party/pahomqtt/MQTTClient-C/src",

"//third_party/pahomqtt/MQTTClient-C/src/liteOS", "//kernel/liteos_m/kal/cmsis", "//base/iot_hardware/peripheral/interfaces/kits"

, ] deps = [ "//third_party/pahomqtt:pahomqtt_static", //吊起MQTT协议 ] }

Build.gn：与APP并列的build.gn用于指出要编译的主函数，可以使用startup后面跟要编译的主包也可以直接features进行选中，在这里可以把不需要参与编译的项目通过#给注释掉在start_up里的builld.gn：。

import("//build/lite/config/component/lite_component.gni") lite_component("app") { features = [

"mqtt_demo:mqtt_test", //标注主函数，指定位置编译 ] 储物精灵Pro版（识别功能版）：（使用第三方平台：Vuforia）我们的原理就是上传画面到云端，然后逐帧分解比对（此功能目前还在完善）

（4）软件侧（偏向软件，但是还是嵌入式开发）步骤一：接收服务器的存储代码exports.i***ta2=function(req,res){ console.log("iot_data:"

,req) const url = new URL("Get the URL provided by HUAWEI CLOUD"+req.url) //The address configured inside the forwarding destination

let properties = JSON.stringify(req.body.notify_data.body.services) console.log("Store data:"

,properties) let addArr = [properties] var addSql = INSERT INTO sesnor_Record(properties) VALUES (?)

var callBack = function(err,data){ console.log("error:"+err) console.log(

"Property insertion result:"+JSON.stringify(data)) res.send(data) } sqlUtil.sqlContent(addSql,addArr,callBack) }

步骤二：射频贴纸&复旦卡拉取本地方案写入复旦卡请用第三方的软件，NFC射频贴纸使用应用调试助手（华为应用市场可下载）voidRC522_Config( void ){ 。

uint8_t ucStatusReturn; //Returns the status uint8_t flag_station =

1; //Leave the flag bit of the functionwhile ( flag_station ) { /* Seek cards (method: all in the range), the first search fails again, and when the search is successful, the card sequence is passed into the array ucArray_ID*/

if ( ( ucStatusReturn = PcdRequest ( PICC_REQALL, ucArray_ID ) ) != MI_OK ) ucStatusReturn = PcdRequest ( PICC_REQALL, ucArray_ID );

if ( ucStatusReturn == MI_OK ) { /* An anti-collision operation in which the selected sequence of cards is passed into an array ucArray_ID */

if ( PcdAnticoll ( ucArray_ID ) == MI_OK ) { if ( PcdSelect ( ucArray_ID ) == MI_OK ) {

printf ("\nRC522 is Ready!\n"); flag_station = 0; } } } } }

步骤三：智能窗帘轨解决方案因为马达可以无限前后方向的对窗帘轨进行拉动所以选择马达来进行拉动另外要注意马达的功率来判断是否加入继电器，详情请移步源码仓（购买马达时要向供应商索要相关数据，同时向开发板供应商索要已公开的脚位置图）。

staticvoid RtcTimeUpdate(void) { externint SntpGetRtcTime(int localTimeZone, struct tm *rtcTime);

struct tm rtcTime; SntpGetRtcTime(CONFIG_LOCAL_TIMEZONE,&rtcTime); RaiseLog(LOG_LEVEL_INFO,

"Year:%d Month:%d Mday:%d Wday:%d Hour:%d Min:%d Sec:%d", \ rtcTime.tm_year + BASE_YEAR_OF_TIME_CALC, rtcTime.tm_mon +

1, rtcTime.tm_mday,\ rtcTime.tm_wday, rtcTime.tm_hour, rtcTime.tm_min, rtcTime.tm_sec);

if (rtcTime.tm_wday > 0) { g_appController.curDay = rtcTime.tm_wday - 1; } else { g_appController.curDay = EN_SUNDAY; } g_appController.curSecondsInDay = rtcTime.tm_hour *

CN_SECONDS_IN_HOUR + \ rtcTime.tm_min * CN_SECONDS_IN_MINUTE + rtcTime.tm_sec + 8; // add 8 ms offset

} static uint32_t Time2Tick(uint32_t ms) { uint64_t ret; ret = ((uint64_t)ms * osKernelGetTickFreq()) /

CN_MINISECONDS_IN_SECOND; return (uint32_t)ret; } #define CN_REACTION_TIME_SECONDS 1staticvoid

BoardLedButtonCallbackF1(char *arg) { static uint32_t lastSec = 0; uint32_t curSec = 0; RaiseLog(LOG_LEVEL_INFO,

"BUTTON PRESSED"); curSec = g_appController.curSecondsInDay; if((curSec) < (lastSec + CN_REACTION_TIME_SECONDS

)) { RaiseLog(LOG_LEVEL_WARN, "Frequecy Pressed Button"); return; } lastSec = curSec; g_appController.curtainStatus =

CN_BOARD_SWITCH_ON; g_appController.pwmLedDutyCycle = \ g_appController.pwmLedDutyCycle >

0 ? g_appController.pwmLedDutyCycle:CONFIG_LED_DUTYCYCLEDEFAULT; osEventFlagsSet(g_appController.curtainEvent,

CN_LAMP_EVENT_SETSTATUS); return; } staticvoid BoardLedButtonCallbackF2(char *arg) { uint32_t lastSec =

0; uint32_t curSec = 0; RaiseLog(LOG_LEVEL_INFO, "BUTTON PRESSED"); curSec = g_appController.curSecondsInDay;

if ((curSec) < (lastSec + CN_REACTION_TIME_SECONDS)) { RaiseLog(LOG_LEVEL_WARN, "Frequecy Pressed Button"

); return; } lastSec = curSec; g_appController.curtainStatus = CN_BOARD_SWITCH_OFF

; osEventFlagsSet(g_appController.curtainEvent, CN_LAMP_EVENT_SETSTATUS); return; } #define

CURTAIN_MOTOR_GPIO_IDX 8#define WIFI_IOT_IO_FUNC_GPIO_8_GPIO 0#define WIFI_IOT_IO_FUNC_GPIO_14_GPIO 4

#define MOTOR_WORK_SECOND 6staticvoid E53SC1_MotorInit(void) { IoTGpioInit(CURTAIN_MOTOR_GPIO_IDX); IoTGpioSetFunc(CURTAIN_MOTOR_GPIO_IDX, WIFI_IOT_IO_FUNC_GPIO_8_GPIO); IoTGpioSetDir(CURTAIN_MOTOR_GPIO_IDX, IOT_GPIO_DIR_OUT);

//设置GPIO_8为输出模式return; } staticvoid E53SC1_SetCurtainStatus(int curtainStatus) { if ((curtainStatus ==

CN_BOARD_CURTAIN_OPEN) || (curtainStatus == CN_BOARD_CURTAIN_CLOSE)) { IoTGpioSetOutputVal(CURTAIN_MOTOR_GPIO_IDX,

1); //设置GPIO_8输出高电平打开电机 sleep(MOTOR_WORK_SECOND); IoTGpioSetOutputVal(CURTAIN_MOTOR_GPIO_IDX,

0); //设置GPIO_8输出低电平关闭电机 } return; } staticvoid DataCollectAndReport(constvoid *arg) { (void

)arg; uint32_t curtainEvent; uint32_t waitTicks; waitTicks = Time2Tick(CONFIG_SENSOR_SAMPLE_CYCLE);

while (1) { curtainEvent = osEventFlagsWait(g_appController.curtainEvent, CN_CURTAIN_EVENT_SETSTATUS

, \ osFlagsWaitAny, waitTicks); if (curtainEvent & CN_CURTAIN_EVENT_SETSTATUS) { RaiseLog(LOG_LEVEL_INFO,

"GetEvent:%08x", curtainEvent); E53SC1_SetCurtainStatus(g_appController.curtainStatus); } (

void) IotProfile_Report(g_appController.curtainStatus); } return; } staticint UpdateShedule(CommandParamSetShedule *shedule) {

if (shedule->num == 1 && shedule->day[0] == 0) { // set the one time schedule to current weekday

shedule->day[0] = (g_appController.curDay + 1); } switch (shedule->option) {

caseA: IOT_ScheduleAdd(shedule->scheduleID, shedule->day, shedule->num, shedule->startHour *

CN_SECONDS_IN_HOUR +\ shedule->startMinute * CN_SECONDS_IN_MINUTE, shedule->duration, shedule->shedulecmd.cmd,

0); break; caseU: IOT_ScheduleUpdate(shedule->scheduleID, shedule->day, shedule->num, shedule->startHour *

CN_SECONDS_IN_HOUR +\ shedule->startMinute * CN_SECONDS_IN_MINUTE, shedule->duration, shedule->shedulecmd.cmd,

0); break; caseD: IOT_ScheduleDelete(shedule->scheduleID, shedule->day, shedule->num, shedule->startHour *

CN_SECONDS_IN_HOUR +\ shedule->startMinute * CN_SECONDS_IN_MINUTE, shedule->duration, shedule->shedulecmd.cmd,

0); break; default: RaiseLog(LOG_LEVEL_ERR, "the schedule has no such option!\n"

); break; } return0; } void CurrentTimeCalcTimerHander(){ g_appController.curSecondsInDay ++; }

#define TimeCalcTicks_NUMBER 100#define CN_MINISECONDS_IN_1000MS 1000staticvoid CurtainShedule(void) {

int startSecondInDay = 0; int endSecondInDay = 0; int settingCmd = 0; int executeTaskTime =

0; // indicate the do something busy osTimerId_t CurrentTimeCalc_id; CurrentTimeCalc_id = osTimerNew(CurrentTimeCalcTimerHander, osTimerPeriodic,

NULL, NULL); osTimerStart(CurrentTimeCalc_id, TimeCalcTicks_NUMBER); while (1) { osDelay(Time2Tick(

CN_MINISECONDS_IN_1000MS)); if (g_appController.curSecondsInDay >= CN_SECONS_IN_DAY) { g_appController.curSecondsInDay =

0; g_appController.curDay++; if (g_appController.curDay >= EN_DAYALL) { g_appController.curDay = EN_MONDAY; } IOT_ScheduleSetUpdate(

1); } // check if we need do some task hereif (IOT_ScheduleIsUpdate(g_appController.curDay, g_appController.curSecondsInDay)) {

if (executeTaskTime > 0) { executeTaskTime = 0; if (g_appController.curtainStatus ==

CN_BOARD_CURTAIN_OPEN) { g_appController.curtainStatus = CN_BOARD_CURTAIN_CLOSE; osEventFlagsSet(g_appController.curtainEvent,

CN_CURTAIN_EVENT_SETSTATUS); } } startSecondInDay = IOT_ScheduleGetStartTime(); endSecondInDay = startSecondInDay + IOT_ScheduleGetDurationTime(); IOT_ScheduleGetCommand(&settingCmd,

NULL); } RaiseLog(LOG_LEVEL_INFO, "start:%d end:%d cur:%d",startSecondInDay, endSecondInDay, g_appController.curSecondsInDay);

if ((endSecondInDay == startSecondInDay) && (g_appController.curSecondsInDay == endSecondInDay)) {

if (g_appController.curtainStatus != settingCmd) { RaiseLog(LOG_LEVEL_INFO, "Triggering"

); g_appController.curtainStatus = settingCmd; osEventFlagsSet(g_appController.curtainEvent,

CN_CURTAIN_EVENT_SETSTATUS); } IOT_ScheduleSetUpdate(1); } }

return; } int IotProfile_CommandCallback(int command, void *buf) { CommandParamSetShedule setSheduleParam; CommandParamSetCurtain setCurtainParam;

//CommandParamSetDutyCycle setDutyCycleParam;CLOUD_CommandType cmd = (CLOUD_CommandType)command;

if (cmd == CLOUD_COMMAND_SETCURTAIN_STATUS) { setCurtainParam = *(CommandParamSetCurtain *)buf; g_appController.curtainStatus = setCurtainParam.status; RaiseLog(LOG_LEVEL_INFO,

"setCurtainParam.status:%d\r\n", setCurtainParam.status); osEventFlagsSet(g_appController.curtainEvent,

CN_LAMP_EVENT_SETSTATUS); return0; } elseif (cmd == CLOUD_COMMAND_SETSHEDULE) { setSheduleParam = *(CommandParamSetShedule *)buf; RaiseLog(LOG_LEVEL_INFO,

"setshedule:day:%d hour:%d minute:%d duration:%d \r\n", \ setSheduleParam.day,setSheduleParam.startHour,setSheduleParam.startMinute, setSheduleParam.duration);

return UpdateShedule(&setSheduleParam); } return-1; } staticint IotWifiInfo_get(char *ssid,

int id_size, char *pwd, int pd_size) { int retval = UtilsGetValue(SID_KEY, ssid, id_size); if

(retval <= 0) { RaiseLog(LOG_LEVEL_ERR, "no such ssid stored! \n"); return0; }

if ( UtilsGetValue(PWD_KEY, pwd, pd_size) < 0) { RaiseLog(LOG_LEVEL_INFO, "ssid(%s) no password stored! \n"

, ssid); } else { RaiseLog(LOG_LEVEL_INFO, "ssid : %s, pwd : %s! \n", ssid, pwd); }

return1; } staticvoid IotWifiInfo_set(char *ssid, char *pwd) { if (UtilsSetValue(SID_KEY, ssid) !=

0) { RaiseLog(LOG_LEVEL_ERR, "store ssid failed! \n"); return; } if (UtilsSetValue(PWD_KEY, pwd) !=

0) { RaiseLog(LOG_LEVEL_ERR, "store password failed! \n"); UtilsDeleteValue(SID_KEY);

return; } RaiseLog(LOG_LEVEL_INFO, "store password success! \n"); } staticvoid IotMainTaskEntry(

constvoid *arg) { osThreadAttr_t attr; NfcInfo nfcInfo; (void)arg; char ssid[BUFF_SIZE] = {

0}; char pwd[BUFF_SIZE] = {0}; int ret = 0; g_appController.pwmLedDutyCycle = CONFIG_LED_DUTYCYCLEDEFAULT; BOARD_InitPwmLed(); BOARD_InitWifi(); E53SC1_MotorInit(); IOT_ScheduleInit(); ret = Board_IsButtonPressedF2(); osDelay(MAIN_TASK_DELAY_TICKS); LedFlashFrequencySet(CONFIG_FLASHLED_FRENETCONFIG); nfcInfo.deviceID =

"6136ceba0ad1ed02866fa3b2_Curtain01"; nfcInfo.devicePWD = "12345678"; if (ret) { RaiseLog(LOG_LEVEL_INFO,

"Netconfig Button has pressed! \n"); if (BOARD_NAN_NetCfgStartConfig(SOFTAP_NAME, ssid, sizeof

(ssid), pwd, sizeof(pwd)) < 0) { RaiseLog(LOG_LEVEL_ERR, "BOARD_NetCfgStartConfig failed! \n"

); return; } else { ret = AFTER_NETCFG_ACTION; } } else { ret = IotWifiInfo_get(ssid,

sizeof(ssid), pwd, sizeof(pwd)); if (ret == 0) { if (BOARD_NAN_NetCfgStartConfig(SOFTAP_NAME, ssid,

sizeof(ssid), pwd, sizeof(pwd)) < 0) { RaiseLog(LOG_LEVEL_ERR, "BOARD_NetCfgStartConfig failed! \n"

); return; } else { ret = AFTER_NETCFG_ACTION; } } } LedFlashFrequencySet(CONFIG_FLASHLED_FREWIFI);

if (BOARD_ConnectWifi(ssid, pwd) != 0) { RaiseLog(LOG_LEVEL_ERR, "BOARD_ConnectWifi failed! \n"

); if (ret == AFTER_NETCFG_ACTION) { NotifyNetCfgResult(NETCFG_DEV_INFO_INVALID); } hi_hard_reboot(HI_SYS_REBOOT_CAUSE_CMD);

return; } if (ret == AFTER_NETCFG_ACTION) { RaiseLog(LOG_LEVEL_DEBUG, "Connect wifi success ! \n"

); NotifyNetCfgResult(NETCFG_OK); osDelay(MAIN_TASK_DELAY_TICKS); RaiseLog(LOG_LEVEL_DEBUG,

"StopNetCfg wifi success ! \n"); StopNetCfg(); IotWifiInfo_set(ssid, pwd); } LedFlashFrequencySet(CONFIG_FLASHLED_FRECLOUD); RtcTimeUpdate();

if (CLOUD_Init() != 0) { return; } if (CLOUD_Connect(nfcInfo.deviceID, nfcInfo.devicePWD, \ CONFIG_CLOUD_DEFAULT_SERVERIP, CONFIG_CLOUD_DEFAULT_SERVERPORT) !=

0) { return; } LedFlashFrequencySet(CONFIG_FLASHLED_WORKSWELL); attr.attr_bits =

0U; attr.cb_mem = NULL; attr.cb_size = 0U; attr.stack_mem = NULL; attr.stack_size = CONFIG_TASK_DEFAULT_STACKSIZE; attr.priority = CONFIG_TASK_DEFAULT_PRIOR; attr.name =

"DataCollectAndReport"; if (osThreadNew((osThreadFunc_t)DataCollectAndReport, NULL, (const osThreadAttr_t *)&attr) ==

NULL) { return; } attr.name = "CurtainShedule"; if (osThreadNew((osThreadFunc_t)CurtainShedule,

NULL, (const osThreadAttr_t *)&attr) == NULL) { return; } return; } staticvoid IotMainEntry(

void) { osThreadAttr_t attr; RaiseLog(LOG_LEVEL_INFO, "DATA:%s Time:%s \r\n",__FUNCTION__, __DATE__, __TIME__); g_appController.curtainEvent = osEventFlagsNew(

NULL); if ( g_appController.curtainEvent == NULL) { return; } // Create the IoT Main task

attr.attr_bits = 0U; attr.cb_mem = NULL; attr.cb_size = 0U; attr.stack_mem = NULL; attr.stack_size = CONFIG_TASK_MAIN_STACKSIZE; attr.priority = CONFIG_TASK_MAIN_PRIOR; attr.name =

"IoTMain"; (void) osThreadNew((osThreadFunc_t)IotMainTaskEntry, NULL, (const osThreadAttr_t *)&attr);

return; } 步骤四：无感配网解决方案（重要ability）OpenHarmony设备之间的信息传递利用特有的NAN协议实现利用手机和智能设备之间的WiFi 感知订阅、发布能力，实现了数字管家与设备之间的互联。

在完成设备间的认证和响应后，即可发送相关配网数据同时还支持与常规SoftAP配网方式共存相关代码： teamX/common/iot_wifi/libs/libhilinkadapter_3861.a

// 无感配网相关库文件 teamX/common/iot_wifi/libs/libnetcfgdevicesdk.a // 无感配网相关库文件 teamX/common/inc/iot_netcfg_nan.h teamX/common/inc/network_config_service.h

// 无感配网相关头文件 teamX/common/iot_wifi/iot_wifi.c// 相关联网接口 teamX/common/iot_wifi/iot_netcfg_nan.c// 无感配网相关实现

数字管家可以在gitee下载源码，在下载的team_X中查看详细介绍步骤五：第三方平台接入储物精灵Pro版（识别功能版）：（使用第三方平台：Vuforia）我们的原理就是上传画面到云端，然后逐帧分解比对（此功能目前还在完善）

第六步：实时摄像功能与智能检测光照值功能（正在实验中）intGetLightAverageVal(unsignedchar cnt){ unsigned short readVal = 0;

unsignedint totalVal = 0, totalCnt = 0; for(unsignedchar i=0; i

50000); } return (totalVal/totalCnt); } enum ENV_LIGHT_STATE GetEnvLightState(void){ enum

ENV_LIGHT_STATE lightState = LIGHT_DAY; int lightVal = GetLightAverageVal(5); if(lightVal > ENV_LIGHT_LEVEL_LOWEST) { lightState = LIGHT_NIGHT; }

elseif(lightVal > ENV_LIGHT_LEVEL_LOW) { lightState = LIGHT_DUSK; } else { lightState = LIGHT_DAY; }

return lightState; } 第七步：分布式检索功能（实验中）传统的分布式使用的是Elasticsearch进行，鉴于OpenHarmony能力所以需要开发出对口的abilityisCreateIfMissing。

() //分布式数据库创建、打开、关闭和删除setCreateIfMissing(boolean isCreateIfMissing) //数据库不存在时是否创建

isEncrypt() //获取数据库是否加密setEncrypt(boolean isEncrypt) //设置数据库是否加密getStoreType() //获取分布式数据库的类型

setStoreType(KvStoreType storeType) //设置分布式数据库的类型KvStoreType.DEVICE_COLLABORATION//设备协同分布式数据库类型KvStoreType

.SINGLE_VERSION//单版本分布式数据库类型getKvStore(Options options, String storeId) //根据Options配置创建和打开标识符为 storeId 的分布式数据库

closeKvStore(KvStore kvStore) //关闭分布式数据库getStoreId() //分布式数据增、删、改、查subscribe(SubscribeType subscribeType, KvStoreObserver observer) 。

//订阅sync(List deviceIdList, SyncMode mode) 数据同步开发说明：（包括OH分布式文件）1. 构造分布式数据库管理类（创建 KvManagerConfig 对象）

Contextcontext;...KvManagerConfigconfig = new KvManagerConfig(context);KvManagerkvManager = KvManagerFactory.getInstance().createKvManager(config);

2. 获取/创建单版本分布式数据库（声明需要创建的单版本分布式数据库ID说明）Options CREATE = new Options(); CREATE.setCreateIfMissing(true

).setEncrypt(false).setKvStoreType(KvStoreType.SINGLE_VERSION); String storeID = "testApp"; SingleKvStore singleKvStore = kvManager.getKvStore(

CREATE, storeID);3. 订阅分布式数据更改（客户端需要实现KvStoreObserver接口&结构并注册KvStoreObserver实例）classKvStoreObserverClient

implementsKvStoreObserver() { publicvoidonChange(ChangeNotification notification){ List insertEntries = notification.getInsertEntries(); List updateEntries = notification.getUpdateEntries(); List deleteEntries = notification.getDeleteEntries(); } } KvStoreObserver kvStoreObserverClient =

new KvStoreObserverClient(); singleKvStore.subscribe(SubscribeType.SUBSCRIBE_TYPE_ALL, kvStoreObserverClient);

4. 构造需要写入单版本分布式数据库的Key和Value（将键值数据写入单版本分布式数据库）String key = "todayWeather"; String value = "Sunny"; singleKvStore.putString(key,

value); 5. 构造需要从单版本分布式数据库快照中查询的Key（数据取自单版本分布式数据库快照）String key = "todayWeather";String value = singleKvStore.getString(key);

6. 获取设备列表与同步数据（PUSH_ONLY）List deviceInfoList = kvManager.getConnectedDevicesInfo(DeviceFilterStrategy.NO_FILTER); List

deviceIdList = new ArrayList<>(); for (DeviceInfo deviceInfo : deviceInfoList) { deviceIdList.add(deviceInfo.getId()); } singleKvStore.sync(deviceIdList, SyncMode.PUSH_ONLY);

7. 首先get到设备数据交换权限ohos.permission.DISTRIBUTED_DATASYNC requestPermissionsFromUser(new String[]{"ohos.permission.DISTRIBUTED_DATASYNC"

}, 0); //然后在AbilitySlice中声明数据库并使用即可，这里不多赘述9. 关于API的开放能力请详见官方文档，这里不再赘述10. 怼相关接口（正在实验的内容）SearchAbility searchAbility = 。

new SearchAbility(context); CountDownLatch lock = new CountDownLatch(1); searchAbility.connect(new ServiceConnectCallback() { @

Override publicvoidonConnect() { lock.countDown(); } @Override publicvoidonDisconnect

() { } }); lock.await(3000, TimeUnit.MILLISECONDS); 11. 设置搜索属性与插入索引和重构查询等将会在下一次提交中进行补充（二）智能门锁（上面的储物精灵源码也包括智能门锁的功能实现，这里补充介绍开发）。

1. 环境搭建：(1) 需要手动配置在deveco tool里的用户组件

(2) 接舵机的Gpio口这里要注意一个接的是正极一个是接地还有一个为信号传输口(3) 云端配置首先在华为云官方获取Client ID等身份识别信息，然后在云端的Topic中自定义订阅与发布。

在初次开发时可以使用MQTTX软件进行了命令的订阅与下发实验，显示在线成功接收到上报和订阅的消息。

这样华为云的配置就成功了

如有需要还要进行产品定义与多功能的增加与实验2.关于编译：(1) 在VS code编译

点击build就可以生成json文件啦，编译成功后upload就可以直接烧录进去（注意：在编译之后如果要再编译必须点击clean以删除build产生的json文件避免报错）(2)在Ubuntu通过命令行编译。

hb set //这是用于产生json文件的hb build //这是用于编译的，编译后则会在源码的out文件夹中产生bin文件hb clean //在build一次以后如果如果要再build那就必须进行此命令来删除json文件

在build成功后开发者就会发现在源码中的out文件夹中看到allinone.bin，然后发送到windows下使用Hiburn进行烧录即可（波特兰最大3000000,否则会烧坏板子)下图为HiBurn的配置方法，点击Connect即可烧录。

3.碰一碰卡片（原子化服务）数字管家需要通过在APPGallery Connect中创建项目后添加应用从而获取Json文件，然后放在码云中下在的DistSchedule\netconfig\src\main\resources中。

然后按照文档开发UI界面，点击构建的Generate Key and CSR创建用户名与密钥进行签名用户操作界面：在slice目录下新建 xxxSlice.java文件，通过addActionRoute方法为此AbilitySlice配置一条路由规则，并且在在应用配置文件（config.json）中注册。

在resources/base/layout下新建对应xml布局文件，在上述两个文件中编写相应的UI数字管家数据处理：从slice获取deviceId：在onStart中通过调用DeviceID等，获取设备的名称等方便数字管家识别设备。

从slice页面获取状态：开关锁可以直接调用intent.getBooleanParam来确定是进行开关锁还是对门锁的日程进行编排编写设备控制命令的解析：在CommandUtil中根据具体设备定义profile，来新增获取命令和解析命令的方法，用于设备在本地调用sendCommand来发送命令和解析。

配置设备端信息：在DeviceData的initData中，根据设备ProductID添加设备图片ID、跳转的action参数和解析方法，配置完成后设备列表页、用户页面等都能通过该配置进行图片加载、路由跳转和解析。

最后进行接口对接与NFC写入就可以了（通过应用调试助手写入NFC识别详细用于快速让手机识别到设备从而吊起数字管家实现鸿蒙的Ability）(三)逆变器1. 拓扑图

设计的单相逆变器，拥有隔离拓扑，通过控制GaN（HEMT）的高频开关实现逆变关于桥臂：两个半桥产生中性点电压，另外两个半桥产生线电压，最后一个半桥作为有源滤波器2.现在STM32f407兼容了OpenHarmony 3.2 bata版，因为f4系列软合了dsp处理所以无需另外使用dsp从处理器。

考虑到尽量减少直流侧输入电流纹波，输出的正弦波尽可能的平滑与减小总谐波失真，设计了一种并联有源滤波器，它比在输入端使用批量电容更有效地补偿纹波3.考虑到大部分EDA的元件库原件都不全，我在kicad按照厂家提供的数据手册画了个原件，并按照例出的参数进行了标注。

4. 关于电流与电压的总谐波失真等：有源滤波器工作在更高的电压变化下将相应的能量存储在陶瓷电容器中，陶瓷电容器的电容随着电压的降低而增加通过算法保持Vin稳定同时允许有源滤波器产生大的波纹输出电流结合电磁屏蔽的开环霍尔传感器形成非常紧凑的测量装置提供电流解耦并降低对共模和寄生感应噪声的敏感性。

特定的GaN控制调制降低了滤波器电感中的电流可以在不达到饱和水平的情况下降低其核心尺寸5. 关于硬件选材：在上文的二.竞赛开发平台的逆变器中有介绍

6.通讯部分(1)分布式软总线基于UDP的coap协议，OpenHarmony特有分布式软总线编程步骤： 1.创建socket；2.设置socket属性，用函数setsockopt();3.绑定IP地址、端口等信息到socket上，用函数bind();。

4.循环接收/发送数据，用函数recvfrom&sendto;5.关闭网络连接创建一个socket，无论是客户端还是服务器端都需要创建一个socket该函数返回socket文件描述符，类似于文件描述符socket是一个结构体，被创建在内核中。

classUdpClient { private DatagramSocket client; public String sendAndReceive(String ip, int port, String msg

) { String responseMsg = ""; try { //Create a client-side DatagramSocket object without having to pass in addresses and objects

client = new DatagramSocket(); byte[] sendBytes = msg.getBytes();

//Encapsulates the address of the destination to be sent InetAddress address = InetAddress.getByName(ip);

//Encapsulates the object to send the DatagramPacket DatagramPacket sendPacket = new DatagramPacket(sendBytes,sendBytes.length,address,port);

try { //sent Data client.send(sendPacket); }catch (Exception e){

// e.printStackTrace(); } byte[] responseBytes = newbyte[2048]; //Create a DatagramPacket object for the response information

DatagramPacket responsePacket = new DatagramPacket(responseBytes,responseBytes.length);

try { //Waiting for the response information, as on the server side, the client blocks at this step until it receives a packet

client.receive(responsePacket); }catch (Exception e){ // e.printStackTrace();

} //Parse the packet contents responseMsg = new String(responsePacket.getData(),

0,responsePacket.getLength()); }catch (Exception e){ // e.printStackTrace(); }

finally { //Close the clientif(client != null){ client.close(); client =

null; } } return responseMsg; } } DatagramSocket类代表一个发送和接收数据包的插座该类是遵循 UDP协议实现的一个Socket类

#define _PROT_ 8800 //UDP server port number#define _SERVER_IP_ "666.66.66.666"#define TCP_BACKLOG 5

#define IP_LEN 16#define WIFI_SSID "rui666"//WiFi name#define WIFI_PASSWORD "1145141919810"//WIFI oassword

开发板的IP与端口号publicvoidperformClassification() { int res = classifier.getResult(accelMeasurements, gyroMeasurements); TaskDispatcher uiTaskDispatcher =

this.getContext().getUITaskDispatcher(); String lab = classes[res]; result = lab; TaskDispatcher globalTaskDispatcher = getContext().getGlobalTaskDispatcher(TaskPriority.DEFAULT); globalTaskDispatcher.asyncDispatch(

new Runnable() { publicvoidrun() { HiLog.warn(label, udpClient.sendAndReceive(

"666.66.66.666", 8800, result)); } }); 相关参数意义（注意要手搓的定义内容）：sin_family //Refers to protocol families, which can only be AF_INET in socket programming sin_port //Storage port number (using network byte order) sin_addr //Store the IP address and

use the in_addr this data structure sin_zero //Emptybytesare reserved inordertokeep sockaddr and sockaddr_in two

data structures the same size fd //socket buf //UDP datagram buffer (contains datato be sent)

len //The lengthof the UDP datagram flags //Invocation operation mode (typically setto0) addr //A

struct that points to the host address information that receives the data (type conversion required sockaddr_in) alen //The

lengthof the structure referred toby addr nfds //Represents the rangeofallfile descriptors in a collection readfds //

Select monitors a collection of readable file handles、 writefds //A collection of writable file handles that

select monitors exceptfds //A collection ofexceptionfile handles that select monitors timeout //The

timeoutendtimeofselect() this time, NULL means permanentwait测试客户端的成功方法：通过UDP软件进行相关的发送与接收，并查看打印信息因为与下文介绍的MQTTX软件使用原理差不多所以这里不多赘述。

(2) MQTTMqtt是用于设备与服务器通讯的一种协议，使设备可以上报订阅下发信息需要下载此协议并存放在thirdparty（第三方库），并在头文件中吊起从开发板厂商官网下载实验demo进行实验因为目前大多数厂商使用的都是OpenHarmony 1.0代码作为演示，不同的源码版本在编译规则和文件名上都会不同，所以在下载的源码中的头文件吊起等也要修改才能接入mqtt协议。

Mqtt最重要要吊起的功能文件在 /home/open/Downloads/code_v3.0LTS/OpenHarmony/third_party/pahomqtt/MQTTClient-C/src里，特别是liteOS中。

7.服务卡片(1)服务卡片原理

(2)APPGallery Connect①数字管家：数字管家需要通过在APPGallery Connect中创建项目后添加应用从而获取Json文件，在完成下述的2后把此文件放在码云中下载的FA源码的：

DistSchedule\netconfig\src\main\resources中然后按照文档开发UI界面，点击构建的Generate Key and CSR创建用户名与密钥进行签名官网在我的项目中创建项目，选择harmonyOS平台等完成填写。

https://developer.huawei.com/consumer/cn/service/josp/agc/index.html#/②逻辑处理：(i)用户操作界面：在slice目录下新建 xxxSlice.java文件，通过addActionRoute方法为此AbilitySlice配置一条路由规则，并且在在应用配置文件（config.json）中注册。

在resources/base/layout下新建对应xml布局文件，在上述两个文件中编写相应的UI(ii)数字管家数据处理：从slice获取deviceId：在onStart中通过调用DeviceID等，获取设备的名称等方便数字管家识别设备。

从slice页面获取状态：开关锁可以直接调用intent.getBooleanParam来确定是进行开关锁还是对门锁的日程进行编排(iii)编写设备控制命令的解析：在CommandUtil中根据具体设备定义profile，来新增获取命令和解析命令的方法，用于设备在本地调用sendCommand来发送命令和解析。

(iv)配置设备端信息：在DeviceData的initData中，根据设备ProductID添加设备图片ID、跳转的action参数和解析方法，配置完成后设备列表页、用户页面等都能通过该配置进行图片加载、路由跳转和解析。

(v) NFC写入：最后进行接口对接与NFC写入就可以了（通过应用调试助手写入NFC识别详细用于快速让手机识别到设备从而吊起数字管家实现鸿蒙的Ability）可以写到开发板的NFC预存区，也可以写在huawei share的碰一碰卡片上。

（目前这两种写法都可以写无数次，在下一次写入时会自动清除上一次所写的）③开发方式：(i) 用户操作界面：通过桌面可以在卡片中点击相关服务，卡片中可以呈现一个或多个服务(ii)工作原理：通过嵌入到UI界面拉起那款应用的服务（可以通过缓存实现快速打开）从而起到交互功能的原子化服务。

(iii)生命周期管理：对设备使用方的 RPC 对象进行管理，请求进行校验以及对更新后的进行回调处理(iv)卡片尺寸：目前官方有四种尺寸，可以在new中自己选中喜欢的尺寸(v)上手开发：新建一个服务卡片。