HarmonyOS参赛作品-智能打蒜器，全解密！-打蒜器原理

与去年不同，今年第二届HarmonyOS创新大赛要求很显然要求是比较高的，要想获得比较大的青睐，可能需要软硬件结合，南北向通吃的作品，而且最好是可以商业化落地的产品级解决方案。

这个挑战很大。

个人的想法是，寻找真正有商业价值的，可以结合现有HarmonyOS和Open Harmony技术特征的东西。幸运的是，我找到了这样的切入口，智能打蒜器。

缘由非常简单，平时喜欢吃水饺，虽然是南方人，不过偏爱北方的蘸酱和蒜泥吃法。这就遇到一个问题，蒜泥如何制作，用刀切太累了。。。作为一个程序员和纯种的懒人，就合计着如何自动化这一点。

打开拼多多，搜索蒜泥，搜到一大把的打蒜器。有手动的、有电动的，都下单买了来，居然销量超过10w+，这玩意这么受欢迎的吗?

使用情况：

1.手动反复拉的那种，用了几次感觉比刀切还累，这就尴尬了。花费20。

2.电动蒜泥机，要一直按着开关，然后手就很酸，按了几次居然失灵了还是某个大牌电器(做电冰箱起家的)，然后洗了一下，居然进水。前后用坏了5个蒜泥机，花费30×5=150。

6个月内，直接损失了170元。受不了啦，直接投降。

我来做一个App遥控的吧，这样总不会坏了吧。可能遇到此情况的用户很多，如果能做得出来，是不是也可以占领一小部分市场份额，从拼多多上那么大的销量算来，看起来挺有前景。

废话少说，经过对比，发现Neptune模块比Hi3861的成本更低，而且很容易购买，仅9.9元。嵌入一块Neptune到购买来的蒜泥原型机(主要含直流电机、3.7v电池、充放电模块)。电路设计比较简单，但暂时不会画电路图所以无法制作自定义PCB电路板，先使用简单的导线连接。

在这里感谢董昱老师的大力帮助。主要控制代码如下：

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include "ohos_init.h"
#include "cmsis_os2.h"
#include "wifiiot_gpio.h"
#include "wifiiot_gpio_ex.h"
#include "wifiiot_i2c.h"
#include "wifiiot_gpio_w800.h"
#include "net_params.h"
#include "wifi_connecter.h"
#include "net_common.h"
#include <errno.h>
#define LED_TASK_STACK_SIZE 512
#define LED_TASK_PRIO 25
enum LedState
{
    LED_ON = 0,
    LED_OFF,
    LED_SPARK,
};
enum LedState g_ledState = LED_SPARK;

static void *GpioTask(const char *arg)
{
    (void)arg;
    while (1)
    {
        switch (g_ledState)
        {
        case LED_ON:
            printf(" LED_ON! \n");
            GpioSetOutputVal(WIFI_IOT_GPIO_PB_00, WIFI_IOT_GPIO_VALUE0);
            osDelay(1500);
            break;
        case LED_OFF:
            printf(" LED_OFF! \n");
            GpioSetOutputVal(WIFI_IOT_GPIO_PB_00, WIFI_IOT_GPIO_VALUE1);
            osDelay(1500);
            break;
        case LED_SPARK:
            printf(" LED_SPARK! Low \n");
            GpioSetOutputVal(WIFI_IOT_GPIO_PB_00, WIFI_IOT_GPIO_VALUE0);
            osDelay(1500);
            printf(" LED_SPARK! High \n");
            GpioSetOutputVal(WIFI_IOT_GPIO_PB_00, WIFI_IOT_GPIO_VALUE1);
            osDelay(1500);
            break;
        default:
            osDelay(1500);
            break;
        }
    }
    return NULL;
}
static void GpioIsr(char *arg)
{
    (void)arg;
    enum LedState nextState = LED_SPARK;

    printf(" GpioIsr entry\n");

    GpioSetIsrMask(WIFI_IOT_GPIO_PB_09, 0);
    switch (g_ledState)
    {
    case LED_ON:
        nextState = LED_OFF;
        break;
    case LED_OFF:
        nextState = LED_ON;
        break;
    case LED_SPARK:
        nextState = LED_OFF;
        break;
    default:
        break;
    }
    g_ledState = nextState;
}
void Broardcast(void *arg)
{
    (void)arg;
    int retval = 0;

    // 建立UDP连接，这里充当了UDP的客户端

    int sockfd = socket(AF_INET, SOCK_DGRAM, 0); // UDP socket

    struct sockaddr_in toAddr = {0};
    toAddr.sin_family = AF_INET;
    toAddr.sin_port = htons(PARAM_SERVER_PORT); // 端口号，从主机字节序转为网络字节序

    if (inet_pton(AF_INET, PARAM_SERVER_ADDR, &toAddr.sin_addr) <= 0)
    { // 将主机IP地址从“点分十进制”字符串 转化为 标准格式（32位整数）
        printf("inet_pton failed!\r\n");
        goto do_cleanup;
    }

    // Broadcast me is online
    while (1)
    {

        // 将online数据作为UDP的消息发送给手机
        static char udpmessage[] = "live";

        // UDP socket 是 “无连接的” ，因此每次发送都必须先指定目标主机和端口，主机可以是多播地址
        retval = sendto(sockfd, udpmessage, sizeof(udpmessage), 0, (struct sockaddr *)&toAddr, sizeof(toAddr));
        if (retval < 0)
        {
            printf("sendto failed!\r\n");
            goto do_cleanup;
        }
        printf("send online message {%s} %ld done!\r\n", udpmessage, retval);

        // 延时1秒
        osDelay(1000);
    }
do_cleanup:
    printf("do_cleanup...\r\n");
    close(sockfd);
}
void Server(void *arg)
{
    (void)arg;
    int retval = 0;
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0); // UDP socket
    struct sockaddr_in clientAddr = {0};
    socklen_t clientAddrLen = sizeof(clientAddr);
    struct sockaddr_in serverAddr = {0};
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_port = htons(PARAM_SERVER_PORT);
    serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);

    retval = bind(sockfd, (struct sockaddr *)&serverAddr, sizeof(serverAddr));
    if (retval < 0)
    {
        printf("bind failed, %ld!\r\n", retval);
        goto do_cleanup;
    }
    printf("bind to port %d success!\r\n", PARAM_SERVER_PORT);

    static char message[2] = {0};
    while (1)
    {
        retval = recvfrom(sockfd, message, sizeof(message), 0, (struct sockaddr *)&clientAddr, &clientAddrLen);
        printf("recv end\r\n");
        if (retval < 0)
        {
            printf("recvfrom failed, %ld!\r\n", retval);
            goto do_cleanup;
        }
        printf("recv message {%s} %ld done!\r\n", message, retval);
        printf("peer info: ipaddr = %s, port = %d\r\n", inet_ntoa(clientAddr.sin_addr), ntohs(clientAddr.sin_port));

        if (strcmp(message, "on") == 0)
        {
            printf(" LED_ON! \n");

            GpioSetOutputVal(WIFI_IOT_GPIO_PB_01, WIFI_IOT_GPIO_VALUE0);
            // GpioSetOutputVal(WIFI_IOT_GPIO_PB_08, WIFI_IOT_GPIO_VALUE0);
        }

        if (strcmp(message, "of") == 0)
        {
            printf(" LED_OFF! \n");

            GpioSetOutputVal(WIFI_IOT_GPIO_PB_01, WIFI_IOT_GPIO_VALUE1);
            // GpioSetOutputVal(WIFI_IOT_GPIO_PB_08, WIFI_IOT_GPIO_VALUE1);
        }

        retval = sendto(sockfd, message, strlen(message), 0, (struct sockaddr *)&clientAddr, sizeof(clientAddr));
        if (retval <= 0)
        {
            printf("send failed, %ld!\r\n", retval);
            goto do_cleanup;
        }
        printf("send message {%s} %ld done!\r\n", message, retval);
    }
do_cleanup:
    printf("do_cleanup...\r\n");

    close(sockfd);
}
void connectWiFI()
{
    WifiDeviceConfig config = {0};

    // 准备AP的配置参数， 连接WiFi
    strcpy(config.ssid, PARAM_HOTSPOT_SSID);
    strcpy(config.preSharedKey, PARAM_HOTSPOT_PSK);
    config.securityType = PARAM_HOTSPOT_TYPE;

    osDelay(100);
    int netId = ConnectToHotspot(&config);
}
void HT30Test(void)
{
    GpioInit();

    // GpioSetDir(WIFI_IOT_GPIO_PB_08, WIFI_IOT_GPIO_DIR_OUTPUT); // output is 0 PB08 control led
    // GpioSetOutputVal(WIFI_IOT_GPIO_PB_08, WIFI_IOT_GPIO_VALUE0);
    GpioSetDir(WIFI_IOT_GPIO_PB_01, WIFI_IOT_GPIO_DIR_OUTPUT);
    GpioSetOutputVal(WIFI_IOT_GPIO_PB_01, WIFI_IOT_GPIO_VALUE1); //High level to block elec
    GpioSetDir(WIFI_IOT_GPIO_PB_09, WIFI_IOT_GPIO_DIR_INPUT); // input is PB09
    IoSetPull(WIFI_IOT_GPIO_PB_09, WIFI_IOT_GPIO_ATTR_PULLHIGH);
    GpioRegisterIsrFunc(WIFI_IOT_GPIO_PB_09, WIFI_IOT_INT_TYPE_EDGE, WIFI_IOT_GPIO_EDGE_FALL_LEVEL_LOW, GpioIsr, NULL);
    connectWiFI();
    // Broardcast UDP 线程
    osThreadAttr_t attr;

    attr.name = "Broardcast";
    attr.attr_bits = 0U;
    attr.cb_mem = NULL;
    attr.cb_size = 0U;
    attr.stack_mem = NULL;
    attr.stack_size = 4096;
    attr.priority = osPriorityNormal;

    if (osThreadNew(Broardcast, NULL, &attr) == NULL)
    {
        printf("[Broardcast] Failed to create Broardcast!\n");
    }
    // Server UDP 线程
    osThreadAttr_t attrRecv;
    attrRecv.name = "Server";
    attrRecv.attr_bits = 0U;
    attrRecv.cb_mem = NULL;
    attrRecv.cb_size = 0U;
    attrRecv.stack_mem = NULL;
    attrRecv.stack_size = 4096;
    attrRecv.priority = osPriorityNormal;

    if (osThreadNew(Server, NULL, &attrRecv) == NULL)
    {
        printf("[Server] Failed to create Server!\n");
    }
    // GPIO闪烁线程
    osThreadAttr_t attr2;

    attr2.name = "GpioTask";
    attr2.attr_bits = 0U;
    attr2.cb_mem = NULL;
    attr2.cb_size = 0U;
    attr2.stack_mem = NULL;
    attr2.stack_size = 4096;
    attr2.priority = osPriorityNormal;

    // if (osThreadNew(GpioTask, NULL, &attr2) == NULL)
    // {
    //     printf("[GpioTask] Failed to create GpioTask!\n");
    // }
}

APP_FEATURE_INIT(HT30Test);

代码解析如下，使用UDP协议分别在Neptune上建立Server和Client两个端，Server用于监听从UDP广播地址(手机App)发送来的蒜泥机控制消息(开和关)。Client用于向UDP广播地址发送蒜泥机的在线活动信号，以便让手机App“发现”设备。

连接WiFi使用的是固定数字，真正做到产品可以开启热点和DHCP服务器，让手机主动连接设备的热点即可。

这里遇到的坑很大，主要是Neptune的控制代码，一定要从润和官方的gitee上下载，使用DevEco Tools自带的代码是无法开启Wifi热点和连接到Wifi的。

手机App端：

因为ArkUI的js和ets接口在HarmonyOS 2.0上均不支持UDP通讯，所以必须要用Java来进行桥接。出于ets目前的稳定性，暂时舍弃使用，改用JS来写UI。

这里要感谢Soon_L的大力帮助。

主要代码如下：

// 定义常量 0-Ability、1-Internal Ability
const ABILITY_TYPE_EXTERNAL = 0;//Ability调用方式
const ABILITY_TYPE_INTERNAL = 1;//Internal Ability调用方式
// 接口调用同步或者异步
const ACTION_SYNC = 0;//同步方式
const ACTION_ASYNC = 1;//异步方式
// 业务码
const ACTION_MESSAGE_UDP_UPDATE = 1001;// 主动更新
const ACTION_MESSAGE_UDP_SUBSCRIBE = 1002;// 订阅Subscribe
const ACTION_MESSAGE_UDP_UNSUBSCRIBE = 1003;// 取消订阅Unsubscribe
const ACTION_MESSAGE_UDP_SEND_ORDER = 1004;// 发送命令
const SUCCESS = 0;
var timer = null;
export default {
    data: {
        title: "",
        message: "",
        connected: false,
        on: false,
    },
    environmentStatus: function () {
        this.getEnvironmentStatus();
    },
    environmentStatusSubscribe: function () {
        this.startEnvironmentStatusSubscribe();
    },
    environmentStatusUnSubscribe: function () {
        this.startEnvironmentStatusUnSubscribe();
    },
    sendOrder: async function (order) {
        var action = {};
        action.bundleName = "com.example.mixerjs";
        action.abilityName = "com.example.mixerjs.UpdateDataServiceAbility";
        action.messageCode = ACTION_MESSAGE_UDP_SEND_ORDER
        action.data = order;
        action.abilityType = ABILITY_TYPE_EXTERNAL;
        action.syncOption = ACTION_SYNC;

        var result = await FeatureAbility.callAbility(action);
        var ret = JSON.parse(result);
        if (ret.code == 0) {
            console.info('发送UDP命令结果:' + JSON.stringify(ret.abilityResult));
        } else {
            console.error('发送UDP命令错误:' + JSON.stringify(ret.code));
        }
    },
    switchMixer(){
        if (this.on) {
            this.sendOrder("of")
        } else {
            this.sendOrder("on")
        }
        this.on = !this.on
    },
    initAction: function (code) {
        var actionData = {};
        var action = {};
        action.bundleName = "com.example.mixerjs";
        action.abilityName = "com.example.mixerjs.UpdateDataServiceAbility";
        action.messageCode = code;
        action.data = actionData;
        action.abilityType = ABILITY_TYPE_EXTERNAL;
        action.syncOption = ACTION_SYNC;
        return action;
    },
    onInit() {
        console.info('Demo App onInit')
        this.environmentStatusSubscribe();
    },
    onDestroy(){
        console.info('Demo App onDestroy')
        this.environmentStatusUnSubscribe();
    },
    getEnvironmentStatus: async function() {
        var action = this.initAction(ACTION_MESSAGE_UDP_UPDATE); //给封装好的初始化函数传递操作码，确定要调用的业务
        var result = await FeatureAbility.callAbility(action);
        var ret = JSON.parse(result);

        if (ret.code == SUCCESS) {
            this.message = ret.message;
            console.info('getEnvironmentStatus message is:' + JSON.stringify(ret.message));
        } else {
            this.message = "NA";
            console.error('getEnvironmentStatus error code:' + JSON.stringify(ret.code));
            this.connected = false
        }
    },
    startEnvironmentStatusSubscribe: async function () {
        try {
            var action = this.initAction(ACTION_MESSAGE_UDP_SUBSCRIBE); //给封装好的初始化函数传递操作码，确定要调用的业务
            var that = this;//that没改变之前仍然是指向当时的this，这样就不会出现找不到原来的对象
            var result = await FeatureAbility.subscribeAbilityEvent(action,function (requestEnvironmentStatus) { //调用订阅服务API
                var envInfo = JSON.parse(requestEnvironmentStatus).data;  //将Json字符串转换为对象，并获取接口返回数据
                that.message = envInfo.message;
                let str = that.message.substring(0,4)
                console.info('startEnvironmentStatusSubscribe message is:' + JSON.stringify(str));

                if( str == 'live'  ) {
                    that.connected = true
                }
            });
            console.info("startEnvironmentStatusSubscribe result = " + result);
        } catch (pluginError) {
            console.error("startEnvironmentStatusSubscribe error : result= " + result + JSON.stringify(pluginError));
        }
    },
    startEnvironmentStatusUnSubscribe: async function () {
        try {
            var action = this.initAction(ACTION_MESSAGE_UDP_UNSUBSCRIBE);
            var result = await FeatureAbility.unsubscribeAbilityEvent(action);
            FeatureAbility.callAbility(action);
        } catch (pluginError) {
            console.error("startEnvironmentStatusUnSubscribe error : " + JSON.stringify(pluginError));
        }
    }
}

Java端的代码如下：

package com.example.mixerjs;

// ohos相关接口包

import ohos.aafwk.ability.Ability;
import ohos.aafwk.content.Intent;
import ohos.aafwk.content.Operation;
import ohos.event.commonevent.*;
import ohos.hiviewdfx.HiLog;
import ohos.hiviewdfx.HiLogLabel;
import ohos.rpc.*;
import ohos.utils.zson.ZSONObject;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;

public class UpdateDataServiceAbility extends Ability {
    private static final HiLogLabel LABEL = new HiLogLabel(HiLog.LOG_APP, 0, "Mixer UpdateDataServiceAbility");

    private MyRemote remote = new MyRemote();
    private CommonEventSubscriber subscriber;

    public static String recv_string;
    private DatagramSocket server_sock;
    private DatagramSocket client_sock;

    private DatagramPacket pac;
    private byte recv_buffer[];
    private byte send_buffer[];
    private String message;
    private String order;  //待发送的命令 on/of
    private static final int DEFAULT_TYPE = 0;
    private static final String COMMON_UDP_INFO_CHANGED = "UDP_INFO_CHANGED";
    @Override
    protected void onStart(Intent intent) {
        HiLog.info(LABEL, "DemoApp onStart");

        UpdateDataServiceAbility.GetStatusInfo getstatusinfo = new UpdateDataServiceAbility.GetStatusInfo();
        Thread t = new Thread(getstatusinfo, "getstatusinfoThread");
        t.start();
        HiLog.info(LABEL, "线程开始执行--> " + t.isAlive());//判断是否启动
        super.onStart(intent);
    }
    // FA在请求PA服务时会调用Ability.connectAbility连接PA，连接成功后，需要在onConnect返回一个remote对象，供FA向PA发送消息
    @Override
    protected IRemoteObject onConnect(Intent intent) {
        super.onConnect(intent);
        return remote.asObject();
    }
    class MyRemote extends RemoteObject implements IRemoteBroker {
        private static final int SUCCESS = 0;
        private static final int ERROR = 1;
        private static final int ACTION_MESSAGE_UDP_UPDATE = 1001;
        private static final int ACTION_MESSAGE_UDP_SUBSCRIBE = 1002;
        private static final int ACTION_MESSAGE_UDP_UNSUBSCRIBE = 1003;
        private static final int ACTION_MESSAGE_UDP_SEND_ORDER = 1004;

        MyRemote() {
            super("MyService_MyRemote");
        }

        @Override
        public boolean onRemoteRequest(int code, MessageParcel data, MessageParcel reply, MessageOption option) {
            switch (code) {
                case ACTION_MESSAGE_UDP_UPDATE: {
                    reply.writeString(getEnvironmentInfo());
                    break;
                }
                case ACTION_MESSAGE_UDP_SEND_ORDER: {
                    order = data.readString();

                    HiLog.info(LABEL, "发送命令--> " + order);
                    try {
                        HiLog.info(LABEL, "发送广播数据");
                        client_sock = new DatagramSocket();
                        client_sock.setBroadcast(true);

                        InetAddress addr1 = InetAddress.getByName("255.255.255.255");
                        pac = new DatagramPacket(order.getBytes(), order.getBytes().length, addr1, 63060);//构造一个packet
                        client_sock.send(pac);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }

                    // 返回结果当前仅支持String，对于复杂结构可以序列化为ZSON字符串上报
                    Map<String, Object> result = new HashMap<String, Object>();
                    result.put("code", SUCCESS);
                    result.put("abilityResult", order);
                    reply.writeString(ZSONObject.toZSONString(result));
                    break;
                }
                case ACTION_MESSAGE_UDP_SUBSCRIBE: {
                    subscribeEvent(data, reply, option);
                    break;
                }
                case ACTION_MESSAGE_UDP_UNSUBSCRIBE: {
                    unSubscribeEnvironmentEvent(reply);
                    break;
                }
                default: {
                    Map<String, Object> result = new HashMap<String, Object>();
                    result.put("abilityError", ERROR);
                    reply.writeString(ZSONObject.toZSONString(result));
                    return false;
                }
            }
            return true;
        }
        private void subscribeEvent(MessageParcel data, MessageParcel reply, MessageOption option) {
            MatchingSkills matchingSkills = new MatchingSkills();
            matchingSkills.addEvent(COMMON_UDP_INFO_CHANGED);
            IRemoteObject notifier = data.readRemoteObject();
            CommonEventSubscribeInfo subscribeInfo = new CommonEventSubscribeInfo(matchingSkills);
            subscriber = new CommonEventSubscriber(subscribeInfo) {
                @Override
                public void onReceiveEvent(CommonEventData commonEventData) {
                    replyMsg(notifier);
                }
            };
            if (option.getFlags() == MessageOption.TF_SYNC) {
                reply.writeString("subscribe common event success");
            }
            try {
                CommonEventManager.subscribeCommonEvent(subscriber);
                reply.writeString(" subscribe common event success");
            } catch (RemoteException e) {
                HiLog.info(LABEL, "%{public}s", "RemoteException in subscribeNotificationEvents!");
            }
        }

        private void replyMsg(IRemoteObject notifier) {
            MessageParcel notifyData = MessageParcel.obtain();
            notifyData.writeString(getEnvironmentInfo());
            try {
                notifier.sendRequest(DEFAULT_TYPE, notifyData, MessageParcel.obtain(), new MessageOption());
            } catch (RemoteException exception) {
                HiLog.info(LABEL, "%{public}s", "replyMsg RemoteException !");
            } finally {
                notifyData.reclaim();
            }
        }
        private String getEnvironmentInfo() {
            // 返回结果当前仅支持String，对于复杂结构可以序列化为ZSON字符串上报
            Map<String, Object> result = new HashMap<String, Object>();
            result.put("code", SUCCESS);
            result.put("message", message);

            return ZSONObject.toZSONString(result);
        }
        private void unSubscribeEnvironmentEvent(MessageParcel reply) {
            try {
                CommonEventManager.unsubscribeCommonEvent(subscriber);
                reply.writeString("Unsubscribe common event success!");
            } catch (RemoteException | IllegalArgumentException exception) {
                reply.writeString("Unsubscribe failed!");
                HiLog.info(LABEL, "%{public}s", "Unsubscribe failed!");
            }
            subscriber = null;
        }

        @Override
        public IRemoteObject asObject() {
            return this;
        }
    }

    class GetStatusInfo implements Runnable {
        @Override
        public void run() {
            try {
                //监听端口
                server_sock = new DatagramSocket(63060);
                recv_buffer = new byte[1024];//接收缓冲区，byte型
                pac = new DatagramPacket(recv_buffer, recv_buffer.length);//构造一个packet
                recv_string = "offline";
                HiLog.info(LABEL, "开始等待消息 ");
                //循环接受数据
                while (true) {
                    server_sock.receive(pac);//阻塞式接收数据
                    //将byte[]转化成string
                    recv_string = new String(recv_buffer, 0, pac.getLength());
                    HiLog.info(LABEL, "接受到UDP数据：" + recv_string + "长度：" + recv_string.length());
//                    if (recv_string.length() >= 0) {
                        System.out.println("Received UDP：" + recv_string);
                        message = recv_string;
                        HiLog.info(LABEL, "message：" + message);
                        try {
                            Intent intent = new Intent();
                            Operation operation = new Intent.OperationBuilder()
                                    .withAction(COMMON_UDP_INFO_CHANGED)//自定义字符串类型的action
                                    .build();
                            intent.setOperation(operation);
                            intent.setParam("result", "commonEventData");
                            intent.setParam("isCommonEvent", true);
                            CommonEventData eventData = new CommonEventData(intent);
                            CommonEventManager.publishCommonEvent(eventData);
                            HiLog.info(LABEL, "PublishCommonEvent SUCCESS");
                        } catch (RemoteException e) {
                            HiLog.info(LABEL, "Exception occurred during publishCommonEvent invocation.");
                        }
//                    }
                }
            } catch (IOException e) {
                System.out.println("Socket Exception");
                e.printStackTrace();
            }
        }
    }
}

最终实现了这个我期待已久的智能打蒜器1.0，也作为本地大赛的参赛作品提交，希望有机会走到商业化的阶段。本人也是因为这个小项目，从头开始学硬件、电路、甚至回忆Java有关的知识，确实遭遇了巨大的困难和挫折，不过好在坚持下来，虽然很菜，但也略有信心了。

还需要进行的工作，去除导线连接Neptune模块，使用自定义的电路板，以便小型化，USB充电口改造成磁吸式(西安的同学提出的建议)。代码全部附上，希望大家也能积极开始，构建自己心目中有用的商业化产品，丰富HarmonyOS和Open Harmony商业生态。

想了解更多关于开源的内容，请访问：

51CTO 开源基础软件社区

https://ost.51cto.com。