蜂鸟离线方案开发指导手册: ReleaseNote

蜂鸟离线方案开发指导手册 v1.0.3
ReleaseNote

版本历史记录

版本：V1.0.3，发布时间：2020/7/22

适配环境：

  • 硬件：蜂鸟离线开发板
  • 软件：udp_v2.3.1

修改记录：

  1. “获取源码”章节中增加开放平台上新功能的描述。
    1）设备开发平台增加产品品类，提升具体产品的开发效率及语音识别性能
    2）模型训练平台录音采集功能优化

版本：V1.0.2，发布时间：2020/6/19

适配环境：

  • 硬件：蜂鸟离线开发板
  • 软件：udp_v2.2.5

修改记录：

  1. 更新对设备开放平台新增功能描述
  2. 声音模型定制功能覆盖蜂鸟、蜂鸟M两种引擎
  3. 增加对修改固件配置文件的方法指导
  4. 产品创建中增加“模型训练平台介绍”章节

版本：V1.0.1，发布时间：2020/5/14

适配环境：

  • 硬件：蜂鸟离线开发板
  • 软件：udp_v2.1.1

修改记录：

  1. 更新云知声串口协议说明页面

版本：V1.0.0，发布时间：2020/5/8

适配环境：

  • 硬件：蜂鸟离线开发板
  • 软件：udp_v3.0.0

修改记录：

  1. 第一版发布


蜂鸟离线方案开发指导手册: 1、简介

1、简介

1. 引言

云知声总部位于北京，在上海、深圳、厦门设有全资子公司。是一家专注物联网人工智能服务、拥有完全自主知识产权的世界顶尖的智能语音识别和语义理解技术的高新技术企业。自2012年由智能语音技术起家，云知声多年来不断拓展技术边界，技术能力不仅涵盖了感知、认知、交互等方面的人工智能语音语义技术，更是在突破了 AI 芯片设计技术后，一举打造出了自主研发、自主知识产权、自主可控的全栈式人工智能技术链条（深度学习算法+大数据+超级计算+芯片能力）。

以强大的计算平台为基础，云知声构建了“云端芯”生态体系，提供跨硬件平台、跨应用场景的软硬件一体化云端+本地智能的芯片终端解决方案。目前云知声是迄今为止行业内唯一实现芯片落地应用的公司、国内白色家电领域领先AI芯片供应商、国内首家推出医疗云服务并完成数百家医院系统测试的语音服务商、我国后装车机市场占有量行业第一、教育云社会化口语评测服务市场占有量第一。还在智慧生活（家居、车载、机器人等）和智慧服务（医疗、教育、司法等）等多个垂直场景均有落地应用。

2. 产品简介

云知声提供标准化软硬件一体离线语音解决方案，支持双麦阵列、前端降噪、语音唤醒、离线识别等。用户使用方案中的标准化硬件模组配合云知声设备平台与相关工具，快速定制语音产品，为空调、冰箱、灯具、开关等家居设备赋能，无需联网即可使其具备智能语音交互能力。

- 硬件：基于云知声蜂鸟芯片为核心的标准硬件模块板，集成离线识别算法

- 设备平台：可进行语音相关配置并生成软件版本的云知声智能设备平台

- 软件与源码：可直接使用，也可修改代码进行二次编译的软件版本

- 文档与工具：使用指南与技术开发文档，配套测试工具


蜂鸟离线方案开发指导手册: 2、产品说明

2、产品说明

1. 硬件说明

蜂鸟芯片采用 CPU+DSP+NPU 三核架构，内置基于人工智能语音识别算法的NN硬件加速核，通过神经网络对音频信号进行训练学习，提高语音信号的识别能力。

蜂鸟芯片具有丰富的系统外设，包括 UART, I2C, SPI, PWM, RTC, Timer, ADC等，支持RC-5和NEC红外协议，是一款低功耗高性能，主控级别的离线语音识别芯片。

蜂鸟芯片与标准核心板

蜂鸟芯片主要特性：

配置 | 规格
蜂鸟芯片 | 内存 1.5MB
 | FLASH 8MB
mic数量 | 2
AEC | 1
VAD | 有
TF卡 | 调试
UART通信接口 | 4路
LED接口 | 有
音频接口 | PDM, I2S
控制接口 | SPI, UART, I2C, GPIO, PWM等

2. 软件功能

序号

功能

功能描述

1

双mic降噪及AEC
  • 2mic线性麦克风阵列
  • 支持回声消除、去混响及用户打断
  • 支持家居场景5m的远讲

2

声源定位

可定位说话人方位 (±10°)

3

语音唤醒
  • 高性能唤醒引擎
  • 低功耗
  • 支持带口音的普通话
  • 低误唤醒率 (< 1 false in 48 hours)

4

离线识别
  • 支持本地150条控制指令识别

5

随时打断

支持AEC，可随时使用唤醒词打断进行中的对话，进行下一次对话。

6

多种发音人音色

提供标准女声、甜美女声、可爱女声、台湾女声、标准男声、女童声、男童声七种音色可选

7

UART主板对接

云知声提供标准UART协议，也支持对接用户自有协议

8

加密保护

支持secure boot，提供更加完善加密保障。

9

智能设备平台

云知声设备平台提供：在线技能配置，设备画像配置，麦克间距配置，唤醒词自定义，命令词自定义，回复播报语自定义，发音人音色选择等产品自定义配置


蜂鸟离线方案开发指导手册: 3、产品创建

3、产品创建

1. 前期准备

1.1 账号创建

• 进入云知声开放平台： http://dev.hivoice.cn/

• 点击右上角的 登陆/注册，弹出如下窗口：

• 如无账号，请点击 去注册；

• 注册方式有“手机账号注册”、“邮箱账号注册”两种方式

• 如已有云知声开发账号请忽略本步骤；

• 选择邮箱账号注册需点击激活邮件后才能正常登陆

1.2 完善资料

注册成功后，为确保账号可用，请登陆云知声账号；

登陆后，点击右上角的 完善资料，输入相关必填信息。

1.3 开通权限

1. 联系云知声商务，申请开通云知声智能设备平台权限，获取离线标准开发板；

2. 开通权限后，产品控制台入口可见，在控制台-产品接入下。

2. 配置并生成产品版本

2.1 创建产品

（1）用户登陆云知声开放平台（ http://dev.hivoice.cn/ ），点击导航栏中的 控制台，点击 产品接入 进入产品接入控制台。

（2）进入产品控制台后，点击 创建产品。

（3）云知声智能设备平台提供不同场景，用以定制不同语音产品形态，此处选择智能家居（纯离线）

（4）选择系统与芯片平台，选择 蜂鸟芯片

该页面点击芯片旁的？按钮，可以获取蜂鸟芯片产品手册。

选择设备类型：

1） 选择具体产品，云知声针对细分的终端产品类型进行了初始功能定义，提供了更准确的语音识别性能与预置的控制指令。

联系商务，获取具体产品方案权限。

2） 选择通用，根据开发者需求，自主合成终端产品能力 ，覆盖的使用场景更加广泛。

（5）填写产品信息，包括名称与描述

（6）确认所选项无问题，点击 保存且下一步，即初步创建产品成功

2.2 产品版本开发

2.2.1 创建产品版本

（1）创建产品版本，填写版本号及版本信息，点击下一步

• 产品创建成功后，系统会自动为该产品分配Appkey与AppSecret，此为该产品唯一识别ID和密匙

• 一个产品可维护多个版本，可通过版本号与版本描述来区分

2.2.2 配置终端能力

（1）前端信号处理相关配置

麦克风间距配置

• 麦克风配置默认为2mic，默认麦克间距为70mm

• 建议麦克间距为60mm - 120mm，对超过产品支持的间距有输入限制；

• 如产品无特殊的麦克分布要求，请使用默认推荐值，以便采集的语音获得最优算法的降噪处理

• 点击 问号，可以看到麦克间距的具体定义

识别距离配置：

根据产品的使用场景选择合适的识别距离，麦克风在收音的过程中会根据选择，对声音做优化处理。

AEC（回声消除）配置

• 默认AEC配置打开，可将麦克风接收到的设备自噪声成分（设备自己播放的内容）消除掉。

• 如果关闭此项，设备将难以区分自噪声与外部声音，在音乐播放、TTS播报等过程中将难以被唤醒词打断。

AEC原理解释：

经过功放（PA）后的模拟信号，一路传给喇叭进行播放，另外一路需要经过A/D转换后进行保存。此时经过喇叭播放的信号会经过空气传播重新被mic所采集到，另外一路经过A/D后保存的信号则作为参考信号，供AEC算法使用。

（2） 自定义产品唤醒词，以及唤醒回复语

• 支持3-5个字的唤醒词自定义配置，最多支持10组唤醒词的添加；

• 为保证语音产品有最佳唤醒体验，平台针对唤醒词的发音提供打分功能，并会提供具体指导信息；

• 评分不通过的唤醒词则不可使用；

• 支持按照产品使用场景自定义唤醒灵敏度；

• 自定义设置唤醒回复语，唤醒回复最多支持10条，设置后将随机播报。

（3）按照规则填写命令词与应答语

如下图所示，左部分为语法格式说明与规则介绍，右部分则为输入框，可以在页面内直接输入命令词与应答语的定义，如不满足语法格式要求平台则会进行实时提示。

语法格式说明与规则介绍

为方便产品构建，平台定义了一套语法格式，语法格式组成为：

action=命令词1|命令词2...@回复语

举例：TempSet15=设置十五度|十五度@已设为十五度

action 为一个控制指令的唯一标识，用户对着设备说出“设置十五度”“十五度”并被语义理解时，如已对接设备，语义理解模块会将TempSet15传给设备。

命令词 为想要定义的语音话术，用户必须按照定义的话术说出才有效。如用户可以使用“设置十五度”“十五度”来实现同一个设置温度15度的控制。

回复语 为针对该条控制指令的设备回复播报。

action、命令词、回复语均由用户定义。等号前的action为唯一值；等号后的命令词可输入多个，以 | 符号分割；@后为回复语，每个控制指令可以定义对应的回复。

点击语法格式后的 问号，可看到语法格式要求：

Ø action由英文、下划线“_”和数字组成，必须英文开头，不区分大小写，15个字符内

Ø 命令词最多支持100条，每条限 2 - 10 个字符，仅支持中文

Ø 一个action仅支持一条回复语，回复语总字数不得超过500个字符，支持中文、数字、逗号、句号、问号

点击语法句式后的 问号，可以看到针对回复播报特殊读音的标签使用说明：

Ø <py>：需要对单个汉字的发音进行纠正的场合。

注：拼音声调范围为 1 - 5，1 - 4 对应一声到四声，5对应轻声。

例：已调<py>tiao2</py>至中<py>zhong1</py>风档

播报为：已调(tiao2)至中(zhong1)风档

Ø <value>：需要将数字按照数值读法播报

例：已设为<value>15</value>度

播报为：已设为十五度

Ø <code>：需要将数字按照数字串逐位播报

例：已设为<code>15</code>度

播报为：已设为一五度

开发者注意：

1. 产品默认支持音量大小调节，音量调节控制默认句式如下：

 volumeUpUni=增大音量

 volumeDownUni=减小音量

如需自定义音量的控制话术与应答播报，可在语法文件内添加以上控制句式，只需保持=号前的action不变，修改=后的内容即可。

举例如下：

volumeUpUni=大声一点|调大声点@已为您调高音量

volumeDownUni=减小音量@好的，音量已减小

2. 产品内置音量等级三档控制逻辑，默认不开启。如需使用该逻辑，可在定义离线命令词与播报语处，添加词条后生效：

 最大音量 volumeMaxUni

 中等音量 volumeMidUni

 最小音量 volumeMinUni

如希望添加最大音量调节，可参考下方举例添加句式：

volumeMaxUni=最大音量|音量调到最大@已调至最大音量

3. 用户可以在离线命令词自定义部分，指定特定的action，定义非语音交互的应答语播报，用于非正常语音交互的情景。

开发者需从指定文件夹获取此部分定制的语音音频文件，并根据产品定义修改源码。可参见文内 5.3 播报逻辑开发。

格式如下：

Special_Replies@回复语1|回复语2|回复语3

如警报播报：以智能烧水壶为例，产品内传感器检测到缺水状态，自动语音警报；

如极限播报：空调指令“升高温度”，正常播报为“温度已升高”；当温度到上限时，播报“温度已调至最高”。

举例如下：

Special_Replies@内胆干烧|水壶缺水|没水啦|主人请加水

4. 用户可以在离线命令词自定义部分，指定特定的竞争词（可理解为无效命令词），防止一定概率的误识别。

格式如下：

Special_Gabages=命令词1|命令词2|命令词3|...

以空调产品为例，并没有高于32度的温控指令，用户说出“三十六度”时，不希望空调识别到“十六度”；
以空调产品为例，没有自动风的指令，当用户说说出“自动风”时，不希望空调识别到“自然风”（如果阈值设置较低）。

举例如下：

举例：Special_Gabages=三十六度|四十六度|五十六度|六十六度

（4）免唤醒命令词

无需唤醒，说出命令词即可控制设备，此处的免唤醒命令词，需先在离线命令词定制模块设定后，方可进行选择配置。

免唤醒命令词生效后，设备会处于待唤醒状态。

免唤醒命令词 与 唤醒词 可同时存在，也可单一存在，两者数量之和不可超过10个。如针对某些特定语音产品，可只使用免唤醒命令词来替代唤醒词。

（5）选择语音识别模型

蜂鸟芯片方案支持对声学模型进行选择，默认为云知声针对蜂鸟芯片定制的经过算法优化的通用声学模型，即“系统默认”。

如当前系统默认的声学模型性能无法满足用户需求时（注：此处用户需求，指经过语音性能量化测试的明确指标），可以使用云知声模型训练平台，采集特定离线命令词的语音训练数据并进行模型定制。可点击选择框右侧文字跳转至模型训练平台。

（6）针对产品定位，选择适合产品形态的发音人

• 活泼可爱的萱萱和KiYo，童真童趣的糖糖和天天，温柔可亲的玲玲，庄重严肃的小雯与小峰，七种音色可供选择；

• 可调节音量与语速；

• 提供在线试听，方便用户进行决策；

（7）其它配置

1) 开机音配置

系统自带默认开机铃声，可在页面点击试听。

如需进行开机欢迎语的自定义，也可以选择自定义内容，产品则会在开机后自动进行播报，欢迎语播报自定义限中文，可输入30个字符；也可选择不使用开机音。

2) 识别状态退出相关配置

语音产品为保证用户体验，唤醒后一段时间内无语音输入产品会主动退出识别状态，如需输入命令词，则需再次唤醒。

此段等待用户输入语音命令的有效时间，即为“唤醒超时退出时间”。

• 为确保产品有较好的用户体验，支持5s – 15s的超时退出时间设置，默认为10秒

• 超时退出回复最多可设置2条

当用户想要结束对话时，也可以主动要求退出识别状态。

• 默认退出命令为“退下”“再见”，可根据产品定义修改，最多可设置3条

• 主动退出回复最多可设置2条

如配置完成，则可点击下一步，进入版本发布页面。

2.2.3 下载版本

（1）产品配置开发完成，进入发布页面后，可点击 立即发布

（2）产品发布需要一定时间，可以有两种方法获取到发布成功的产品

• 发布界面下，版本发布成功后，会有下载提示

• 也可以直接返回产品详情，或关闭页面一段时间再进入智能设备平台的产品详情，页面中的版本列表处点击下载

2.3 产品版本维护

产品详情页面可以查看已创建的产品，可以查看每个版本的配置信息，也可以对已发布成功的版本进行下载或者删除操作

2.3.1 开发新版本

同一个产品如有新需求的修改或迭代，可在产品详情页面点击 +开发新版本，后续的操作步骤同创建产品版本时的流程一致。

提供选择任一历史版本进行迭代开发的选项，默认为基于最新修改的版本，也可根据需求进行其它版本的选择。

3. 模型训练平台介绍

蜂鸟芯片方案支持通过云知声模型训练平台对声学模型进行定制。

当系统默认的声学模型性能无法满足用户需求时（注：此处用户需求，指经过语音性能量化测试的明确指标），可以使用模型训练平台，采集特定离线命令词的语音训练数据，进行模型快速定制，可有效提升语音识别准确率。

目前模型训练平台（ https://atp.hivoice.cn/ ）尚未正式在云知声开放平台中开放入口，仅在蜂鸟方案产品详情里，与配置终端能力里可进入。

产品详情入口：

配置终端能力入口：

正常的声学模型的流程为：

3.1 新建模型

进入训练平台首页，点击 +新建声学模型

进入基础信息填写页面，需输入模型名称与模型描述。

注：一经确认无法修改

填写完毕后，点击下一步，进入训练模型页面。

由于新建模型尚未配置训练数据（即录音文件），页面显示为空，点击 +添加录音，进入添加录音页面。

如果该账号下从未采集过任何录音，则显示“暂无数据”。

需要首先采集录音，点击 去新建录音任务

3.2 创建录音任务

录音任务的创建可以在创建模型过程中跳转进入，如 1. 新建模型 中所述。也可以在首页处点击录音任务，进入录音任务页面。

点击 +新建录音任务，进入录音任务的创建。

此处配置的录音任务，可通过录音APP获取进行采集。

进入新建录音任务页面，进行录音任务的配置。

3.2.1 录音任务基础信息

输入任务名称与任务描述，建议输入清晰明确的任务信息。

3.2.2 录音配置

语速配置：

默认仅勾选正常语速，如产品对于快语速或慢语速的唤醒与识别有要求，则可根据需求勾选。

详细语速要求可点击 ？号了解，目前系统定义的语速要求如下：

快语速 | 正常语速 | 慢语速
2个字：≤700ms 3个字：≤800ms 4个字：≤900ms 5个字：≤1000ms 6个字：≤1100ms 7个字：≤1200ms 8个字：≤1400ms 9个字：≤1600ms 10个字：≤1800ms | 2个字：≥750ms 3个字：≥850ms 4个字：≥950ms 5个字：≥1100ms 6个字：≥1200ms 7个字：≥1400ms 8个字：≥1500ms 9个字：≥1700ms 10个字：≥1900ms | 慢语速对录音时长无限制

默认语速设置不符合目标用户群体特征，可以通过自定义语速去调整语速要求：

采样率：

目前仅支持16000HZ。

录音次数：

支持1-3次的配置，通常采集3次。

3.2.3 录音词条选择

当前训练平台支持导入云知声开放平台内创建的产品词条，也支持自选词条的任务上传。

1） 选择直接“上传词条”，可按照模板格式直接上传内容为录音词条的Excel表格；

2） 选择“来自 UNIOS开放平台产品的唤醒词和命令词”，系统会根据产品名称与版本同步词表。

最后，选择录音任务的分配策略，系统为了减轻录音人员单次采集的压力，支持录音分组下发。

完毕后点击 确定，即可发布录音任务。

点击确定后，跳转至录音任务列表页面

此时任务尚未开始，还可对创建的录音任务进行编辑。

如任务确认无误，可开始收集录音，则点击 开始采集。此时任务状态将切换为 进行中；此时任务只可查看，不可编辑。

开始采集后，录音邀请码生效，点击变蓝的邀请码，将一键复制邀请码与录音APP下载链接，目前仅支持安卓APP。

对语音采集人发布任务时，只需粘贴，即可发送。

邀请文字如下：

录音邀请码：eaRmhEZf，通过链接：https://unios-udp.oss-cn-beijing.aliyuncs.com/unione/unisound_record_tool.apk 下载安装录音APP, 进入 APP 后跟随引导输入录音邀请码，即可进行录音采集，快来试试吧~

3.3 收集录音文件

3.3.1 APP使用

录音人可通过链接可下载APP工具，下载安装成功后，图标如下：

打开后，同意所有权限。

第一步，输入邀请码，点击确认。


蜂鸟离线方案开发指导手册: 4、烧录固件

4、烧录固件

1 烧录工具包介绍

• 产品的软件烧录包下载成功后，解压文件，可以看到如下方文件目录

• 如想直接使用，体验语音功能，请打开image_demo文件夹，右键单击烧录工具UniOneDownloadTool.exe，“以管理员身份运行”打开

2 烧录指南

2.1 烧录前准备

开始烧录之前，需要准备：

- Micro USB连接线，用于供电

- UART转接头与串口线，用于烧录

2.2 进入烧录模式

找到调试串口附近的短接按钮，按住不放，同时使用USB连接线给开发板上电，即接入电源。可直接接电脑，或者任意5V电源适配器（如手机充电器）。

上电完毕后松开烧录按钮，此时开发板进入烧录模式。

烧录按钮示意图

2.3接入UART

开发板上调试串口有：GND，RXD，TXD三路，而UART转接头上同样GND，RXD，TXD是我们需要使用的。当串口线与UART转接头接入时，RXD TXD需交叉对接，即GND-GND，RXD-TXD，TXD-RXD，如下图所示：

UART口反接示意图

打开烧录工具UniOneDownloadTool.exe，串口线连接上UART转接头与开发板后，转接头插入电脑，烧录工具会如下图显示：

烧录工具检测到COM3

如未显示则表示未识别到COM口，请检查：

① 串口线是否接好

② 串口线是否反接

③ 是否安装UART对应驱动。

2.4 烧录版本

正常烧录版本，直接点击烧录按键，对应COM号链接的设备即开始烧录，最多支持12台设备同时烧录。

烧录中的设备处于黄色选中状态，且设备状态实时更新烧录进展。

工具烧录中显示

烧录完成，烧录成功的设备将为绿色显示，如下图：

设备烧录成功

而烧录失败设备将处于红色显示，如下图：

设备烧录失败

如烧录失败，请检查：

① 开发板是否供电

② 开发板串口是否接好

③ 串口线是否按照要求反接，确认后请回到步骤1重新短接上电，重新进入烧录模式。

④ COM口是否超过了COM16，如果超过，请调整驱动使com口编号小于16

⑤ 其他问题，请参考以下QA

固件烧录QA：

(1) 烧写过程中卡住不动怎么办？

解决方案: 按下图修改配置文件unionedebug.ini，将下载波特率降低为921600，然后重启工具，再次尝试烧录，可能可以修复此问题。

(2) 如出现如下图set rate 1500000 failed 怎么办？

解决方案:从电脑 设备管理器中检查串口驱动版本，目前已知Silicon Labs CP210x 10.x.x版本的驱动会有此问题，请更新驱动到6.x.x版本即可。

(3) 遇到通讯失败怎么办？

解决方案：这种大概率是进入烧录模式失败引起，打开串口调试工具（如SecureCRT），再次按照二.1方法让板子上电，确保出现了开机选项，并且按2可以正常回显。

然后断开串口调试工具，点击烧录即可正常通讯进入烧录了。

3 配置文件的使用

用户点击了烧录按键后，烧录工具会解压flash_all.bin为一个addtion的文件夹，里边包含所有的需要烧录的bin文件，其中一个名为config.bin的文件，支持修改来进行相关配置。

如需进行配置，请进行如下操作：

① 打开config.bin进行修改并保存，正常的文本编辑工具即可，如记事本、写字板，推荐使用Notepad++；

② 将烧录工具的文件输入栏中的flash_all.bin清空，或者删除flash_all.bin后再打开工具（如删除请记得备份）。

具体每个参数如何配置，请见下方介绍。

3.1 lasr本地语音识别相关配置

（1）lasr_wkp 本地语音识别：唤醒

 "std_threshold"：唤醒阈值，未进行语音性能测试确定阈值前，不建议修改

 "lp_threshold"：二次唤醒阈值，未进行语音性能测试确定阈值前，不建议修改

 "sleep_std_threshold"：深度休眠唤醒阈值，未进行语音性能测试确定阈值前，不建议修改

 "sleep_lp_threshold"：深度休眠二次唤醒阈值，未进行语音性能测试确定阈值前，不建议修改

（2） lasr_asr 本地语音识别：识别

 "timeout"：识别模式退出带唤醒模式超时时间，单位为秒（也可平台进行配置）

 "std_threshold"：识别阈值，未进行语音性能测试确定阈值前，不建议修改

 "lp_threshold"：二次识别阈值，未进行语音性能测试确定阈值前，不建议修改

3.2 log设置

 "enable"：默认关闭。0：关闭log输出；1：打开log输出

 "set_level"：默认为一般调试信息。可选择范围0 ~ 6，值越大打印等级越高，log输出越多。0：输出error log，1：输出warning log，2：输出一般调试信息，3：输出debug信息

 "arpt_enable"：默认关闭。0：关闭ARPT工具对应log输出；1：打卡ARPT工具对应log输出。该功能不受log.enable影响，一般打开ARPT信息时应禁用log输出，避免输出信息错乱

3.3 record 录音配置

 "enable"：默认关闭。0：关闭录音保存到SD卡功能；1：将录音保存到SD

 "save_asr_only"：默认保存全部录音数据。0：录音保存4路全部数据；1：录音仅保存SSP处理后数据

3.4 hvad 硬件人声检测配置

该部分不建议进行修改。

 "enable"：默认开启HAVD。0：关闭HVAD功能；1：打开HVAD功能

 "time_to_sleep"：进入HVAD低功耗模式超时时间，单位为秒

 "eage_det"：HVAD检测行为阈值，不建议修改

 "energy_threshold"：HVAD触发音量值，值越大唤醒所需音量越大

 "trig_num"：HVAD触发持续度阈值，值越大唤醒越困难


蜂鸟离线方案开发指导手册: 5、搭建开发环境

5、搭建开发环境

1 环境准备

（1）下载编译工具

推荐使用Ubuntu 1604 / centos7以上版本作为开发环境。

交叉编译工具下载地址： https://pan.baidu.com/s/15xPkCTDAn5PyFHQxlEVdxA 提取码：nah9

下载交叉编译工具并解压到开发环境中；

交叉编译工具层次图

（2）已下载的版本里除了可直接烧录使用的image_demo外，另外一个ree_unione_lite_app文件夹则为产品方案源码，如下图所示：

复制rtt_unione_lite_app文件夹至开发环境中；

（3）修改rtconfig.py中交叉工具链的路径为实际解压到的工具路径；

（4）安装scons软件构造工具sudo apt-get install scons
（5）安装python环境：sudo apt-get install python
（6）安装lame音频处理工具：sudo apt-get install lame

2 编译

(1) 执行编译

执行./build.sh，编译成功会看到如下信息：

(2) output目录下可以看到编译生成的完整固件，使用章节3中的下载工具即可进行烧录使用：

release对应正式量产版本，整体性能最佳；

debug对应研发版本，实时输出调试log；

(3) output/debug_flash_bin_creater或者output/release_flash_bin_creater目录下app.bin即对应当前源码编译出的应用固件，可参考 章节3 中的指导手册进行单独app.bin烧录，减少烧录时间，方便开发。


蜂鸟离线方案开发指导手册: 6、软件架构

6、软件架构

1.软件架构

蜂鸟芯片源码框架采用分层设计，各个层次完成特定的功能封装，最终为二次开发提供user层功能接口，基本框架结构如下图所示：

各个层次功能描述如下：

ü HAL层：提供包括线程调度、内存管理、信号量系统级统一接口，以及Audio、Record、GPIO、Timer、I2C等外设驱动统一接口；

ü UTILS层：提供常用的工具集代码，包括如：事件队列、Ring Buffer、List、状态机、Hash运算、Json解析等，供SDK集应用层使用；

ü SDK层：提供核心功能接口，如：Audio Play、MP3 解码、语音识别等；

ü APP层：语音识别基础业务功能实现，其核心由一个事件调度和状态机构成，将语音识别业务抽象成wakeup、settings、music、watchdog等不同的session，每个session维护一个状态机，根据SDK层的识别结果事件驱动状态机运行，最终实现语音识别、播报业务逻辑；

ü USER层：提供用户二次开发接口，包括语音识别、音频播放的控制接口，以及GPIO、UART、Flash、I2C、Timer等常用的外设驱动接口，还提供了UCP通用串口协议。

2.源码目录结构

源码各个文件功能如下所示：

.

├── applications -------------------------------> 架构代码文件夹

│ ├── app ------------------------------------> APP层代码文件夹

│ │ ├── inc

│ │ └── src

│ │ ├── main.c -------------------------> 系统启动主程序，main函数入口

│ │ ├── sessions -----------------------> sessions代码文件夹

│ │ │ ├── uni_setting_session.c ------> setting类事件处理session

│ │ │ ├── uni_wakeup_session.c -------> wakeup类事件处理session

│ │ │ └── uni_watchdog_session.c -----> watchdog事件处理session

│ │ ├── uni_record_save.c --------------> 录音保存功能实现

│ │ ├── uni_session.c ------------------> 创建释放session对象

│ │ ├── uni_session_manage.c -----------> 管理session注册

│ │ └── uni_user_meeting.c -------------> APP层与USER层交互接口

│ ├── hal ------------------------------------> HAL层实现代码

│ ├── sdk ------------------------------------> SDK层实现代码

│ │ ├── audio ------------------------------> Audio播放器

│ │ ├── easyflash --------------------------> 一套简单的flash读写操作接口

│ │ ├── idle_detect ------------------------> 设备空闲计时管理

│ │ ├── player -----------------------------> MP3解码器

│ │ └── vui --------------------------------> 语音识别功能

│ └── utils ----------------------------------> UTILS层实现代码

│ ├── arpt -------------------------------> ARPT自动化测试工具

│ ├── auto_string ------------------------> 变长字符串

│ ├── base64 -----------------------------> base64算法

│ ├── bitmap -----------------------------> 二值状态变量集合

│ ├── black_board ------------------------> 系统状态管理

│ ├── cJSON ------------------------------> JSON格式解析

│ ├── config -----------------------------> config.bin文件内容解析

│ ├── crc16 ------------------------------> CRC16算法

│ ├── data_buf ---------------------------> 一个不用互斥锁管理的Ring Buffer

│ ├── event ------------------------------> 创建事件对象

│ ├── event_list -------------------------> 事件队列

│ ├── event_route ------------------------> 事件分发

│ ├── float2string -----------------------> 浮点转字符串，用于无float类型打印能力的printf

│ ├── fsm --------------------------------> 状态机

│ ├── hash -------------------------------> 一个简易HASH算法

│ ├── interruptable_sleep ----------------> 非阻塞的sleep方式

│ ├── list -------------------------------> 通用链表

│ ├── log --------------------------------> 带等级控制的LOG输出接口

│ ├── md5sum -----------------------------> MD5值算法

│ ├── string -----------------------------> 一套简易的string操作接口

│ ├── timer ------------------------------> 基于RTOS系统的Timer

│ └── uart -------------------------------> 通用的UART接口

├── audio --------------------------------------> Audio编解码

│ ├── lib_helix_mp3 --------------------------> MP3解码算法

│ ├── lib_speex ------------------------------> pcm压缩算法

├── build.sh -----------------------------------> 编译脚本

├── drivers ------------------------------------> 底层驱动

│ ├── audio ----------------------------------> RTT音频驱动

│ ├── board.c --------------------------------> 底板初始化

│ ├── device ---------------------------------> 外设驱动

├── flash_bin_creater --------------------------> 固件包组件

├── include ------------------------------------> 第三方库及自动化构建头文件

├── Kconfig ------------------------------------> RTT配置脚本

├── lib ----------------------------------------> 第三方库

├── libcpu -------------------------------------> 芯片启动代码

├── link.lds -----------------------------------> 固件编译链接脚本

├── README.md ----------------------------------> 版本发布信息

├── rtconfig.h ---------------------------------> RTT系统配置头文件

├── rtconfig.py --------------------------------> RTT系统定制化脚本

├── rt-thread ----------------------------------> RTT系统代码

├── SConscript ---------------------------------> scons编译系统脚本

├── SConstruct ---------------------------------> scons编译系统脚本

├── scripts

│ ├── cmd_reply_data.json ----------------> UDP平台用户定制命令词和回复语信息

│ ├── config_debug.bin -------------------> Debug固件对应的应用配置文件

│ ├── config_release.bin -----------------> Release固件对应的应用配置文件

│ ├── custom_config.json -----------------> UDP平台用户定制系统配置信息

│ ├── default_tones ----------------------> 默认保底音频文件文件夹

│ ├── grammar.dat ------------------------> 语法模型

│ ├── grammar_jsgf.zip -------------------> 语法模型对应的构建脚本

│ ├── grammar.zip ------------------------> 语法模型文件压缩包

│ ├── input.txt --------------------------> 用户定制回复语列表

│ ├── pcm.bin ----------------------------> MP3音频falsh固件，自动生成的中间文件

│ ├── pcm_map.txt ------------------------> MP3音频文件名及内容列表

│ ├── res_build_tool.py ------------------> 自动化构建脚本

│ ├── thresh.dat -------------------------> 唤醒词阈值推荐表

│ ├── tones ------------------------------> MP3音频文件夹

│ └── wav_tones --------------------------> WAV音频文件夹，自动转换到tones

└── user ---------------------------------------> USER层实现代码

├── inc

│ ├── unione.h ---------------------------> USER层使用的底层头文件

│ ├── user_config.h ----------------------> USER可配置项，包括串口、音量等

└── src

├── examples ---------------------------> 包含个股USER模块的示例代码

├── user_asr.c -------------------------> 语音识别控制接口

├── user_event.c -----------------------> USER事件分发机制，底层调用USER注册的事件回调函数

├── user_file.c ------------------------> SD卡文件系统操作接口，蜂鸟暂不支持

├── user_flash.c -----------------------> Flash操作接口

├── user_gpio.c ------------------------> GPIO操作接口

├── user_main.c ------------------------> 用户代码入口，参考示例实现user_main()接口以增加业务逻辑

├── user_player.c ----------------------> 音频播放控制接口

├── user_power.c -----------------------> 功耗操作接口，蜂鸟暂不支持

├── user_pwm.c -------------------------> PWM操作接口

├── user_record.c ----------------------> 录音控制接口，蜂鸟暂不支持

├── user_timer.c -----------------------> Timer操作接口

├── user_uart.c ------------------------> UART操作接口

└── user_uni_ucp.c ---------------------> 通用串口协议操作接口

3.APP层session状态机

为保证代码业务逻辑的额可扩展性和健壮性，在APP层设计中使用了事件分发和状态机的机制，每个session都维护一个独立的状态机，底层事件分发后，根据各个session状态机的状态激发对应session的事件处理，如此一直运行下去。

代码中使用的是有限状态机,也称为FSM(Finite State Machine)，其在任意时刻都处于有限状态集合中的某一状态。当其获得一个输入事件时，将从当前状态转换到另一个状态，或者仍然保持在当前状态。任何一个FSM都可以用状态转换图来描述：

在二次开发时，并不需要关心APP层的实现，USER层已经将各个功能模块控制接口封装，调用USER层接口会自动触发状态机运转，从而实现定制功能。


蜂鸟离线方案开发指导手册: 7、二次开发

7、二次开发

1. 运行一个Demo示例

为方便用户二次开发，源码中提供了大量的示例Demo，以供参考，相关源码可在“user\src\examples”路径下找到。

如果想要运行一个已有Demo，可通过配置“user\inc\user_config.h”内的宏定义来选择Demo功能，如运行ASR控制相关示例，需修改两个宏定义如下：

#define USER_RUN_DEMO 1 // 1：打开Demo功能

#define USER_RUN_DEMO_SELECT USER_DEMO_ASR_CONTROL // 选择ASR控制Demo

然后，运行./build.sh脚本，编译生成固件，烧录后重启开发板即可测试，默认唤醒词为“你好魔方”。

2. user_main()入口函数

user_main()接口是USER层二次开发入口函数，相当于系统中的main函数，定制化代码需加入到user_main()函数中以编译运行，该函数可在“user\src\user_main.c”中找到。

从架构上看，该函数会在系初始化完毕后自动被调用，调用完毕后开始播放开机启动欢迎语，并开始进入循环等待实现watch dog喂狗操作，因此，作为一个限制，user_main()函数内代码不能是阻塞的，建议该函数中仅仅做系统初始化和事件注册操作，具体实现，可以参考Demo程序：user\src\examples\ hb_smart_ac.c。

3. 第一个定制程序

以下代码，作为一个简单示例，实现了用户定制的语音识别指令的打印：

static void _custom_setting_cb (USER_EVENT_TYPE event,

user_event_context_t *context) {

event_custom_setting_t *setting = NULL;

if (context) {

setting = &context->custom_setting;

printf("Action: %s\n", setting->cmd); // 对应UDP平台定制基本action

printf("ASR word: %s\n", setting->word_str); // 识别词

printf("Reply list: %s\n", setting->reply_files); // UDP平台定制回复语编号列表[1, 2]

user_player_reply_list_random(setting->reply_files);// 随机播放一条回复语

}

}

static void _register_event_callback(void) {

user_event_subscribe_event(USER_CUSTOM_SETTING, _custom_setting_cb);

}

int user_main(void) {

printf("Hello World !\n");

_register_event_callback(); // 注册事件回调

return 0;

}

运行后说“你好魔方”唤醒设备，然后说“打开风扇”打印结果为：

Hello World !

Action: ac_power_on

ASR word: 打开风扇

Reply list: [104, 105, 106]

然后设备播报回复语可能是一下三条其中一条（根据当前设备状态）：

“已为您打开风扇，当前为自然风”

“已为您打开风扇，当前为正常风”

“已为您打开风扇，当前为睡眠风”

4. 串口LOG调试

（1）调试串口为章节3中的下载串口，连接PC后使用常见串口工具（如putty、xshell、secureCRT等），配置波特率 (115200bps)、数据位 (8)、停止位 (1)、校验 (None)即可。

设备上电后，可在串口工具中观察到如下启动信息：

(2) 与主控板通讯的串口默认为UART1，配置为波特率 (9600bps)、数据位 (8)、停止位 (1)、校验 (None)，直接与主控板gnd，tx，rx对接即可（无需交叉）：

调试时可以通过uart转usb转接器与PC进行连接，使用常见串口工具进行收发验证，这里推荐使用XCOM这款免费串口工具。


蜂鸟离线方案开发指导手册: 模块

模块
这里列出了所有模块:
[详情级别 123]
▼ 配置宏定义 | 配置宏定义参考user/inc/user_config.h
GPIO相关宏定义 | GPIO settings
audio相关宏定义 | Audio player volume settings, default value means (5, 25, 50, 75, 100)
通讯相关宏定义 | Use Unione communication protocol settings, default, 115200, 8, 1, 0
串口相关宏定义 | Custom UART settings, default 19200, 8, 1, 0
语音相关宏定义 | Recognize configurations, default multiply dialogue and no AEC
Demo相关宏定义 | 使用方法见详细描述
▼ 音频控制 | 音频控制接口参考user/inc/user_player.h
音频控制说明 |
音频控制接口 |
▼ 音频控制示例 |
hb_player.c |
▼ 语音控制 | 语音控制接口参考user/inc/user_asr.h
语音控制说明 |
语音控制接口 |
▼ 音频控制示例 |
hb_asr_control.c |
▼ 云知声标准协议数据通讯 | 云知声标准协议数据通讯接口参考user/inc/user_uni_ucp.h
云知声标准协议数据通讯 |
云知声标准协议数据通讯接口 |
▼ 云知声标准协议数据通讯示例 |
hb_uart_ucp.c |
▼ 数据存储 | 数据存储接口参考user/inc/user_flash.h
数据存储说明 |
数据存储接口 |
▼ 数据存储示例 |
hb_flash_example.c |
▼ 串口收发 | 串口收发接口参考user/inc/user_uart.h
串口收发说明 |
串口收发接口 |
▼ 串口收发示例 |
hb_uart.c |
▼ 定时器 | 定时器接口参考user/inc/user_timer.h
定时器说明 |
定时器接口 |
定时器类型定义 |
▼ 定时器示例 |
hb_sw_timers.c |
user_timer_buzzer.c |
▼ GPIO | GPIO接口参考user/inc/user_gpio.h
GPIO说明 |
GPIO相关接口 |
GPIO类型定义 |
▼ GPIO示例 |
hb_gpio_key.c |
▼ ADC | ADC接口参考user/inc/user_adc.h
ADC说明 |
ADC相关接口 |
ADC类型定义 |
▼ ADC示例 |
hb_adc_key.c |
▼ Event事件 | Event事件接口参考user/inc/user_event.h
Event事件说明 |
Event事件接口 |
Event事件类型定义 |
▼ PWM | PWM接口参考user/inc/user_pwm.h
PWM说明 |
PWM相关接口 |
PWM类型定义 |
▼ PWM示例 |
hb_pwm_led.c |
▼ 方案示例 | 示例代码位于目录user/src/examples/下
智能电风扇 |
智能管家 |


蜂鸟离线方案开发指导手册: 配置宏定义

模块
配置宏定义

配置宏定义参考user/inc/user_config.h 更多...

模块

GPIO相关宏定义
GPIO settings
audio相关宏定义
Audio player volume settings, default value means (5, 25, 50, 75, 100)
通讯相关宏定义
Use Unione communication protocol settings, default, 115200, 8, 1, 0
串口相关宏定义
Custom UART settings, default 19200, 8, 1, 0
语音相关宏定义
Recognize configurations, default multiply dialogue and no AEC
Demo相关宏定义
使用方法见详细描述

详细描述


蜂鸟离线方案开发指导手册: GPIO相关宏定义

宏定义
GPIO相关宏定义
配置宏定义

GPIO settings 更多...

宏定义

#define GPIO_OUT_DEF_VAL 1
0: default is low, 1: default is high, when GPIO set to output mode

详细描述


蜂鸟离线方案开发指导手册: audio相关宏定义

宏定义
audio相关宏定义
配置宏定义

Audio player volume settings, default value means (5, 25, 50, 75, 100) 更多...

宏定义

#define | USER_AUDIO_VOL_LEVEL 5
Level is divided into several 0 - 100
#define | USER_AUDIO_VOL_MIN 5
The minimum volume
#define | USER_AUDIO_VOL_MAX 100
The maximum volume
#define | USER_AUDIO_VOL_MID 50
The middle volume
#define | USER_AUDIO_VOL_DEF 50
Default volume if reset device

详细描述


蜂鸟离线方案开发指导手册: 通讯相关宏定义

宏定义
通讯相关宏定义
配置宏定义

Use Unione communication protocol settings, default, 115200, 8, 1, 0 更多...

宏定义

#define | USE_UNIONE_PROTOCOL 1
0: don't use, 1: use
#define | OPEN_ASR_EVENT_UCP 1
0: not out, 1: output ASR result by UCP uart port, payload is action string, cmd is fixed to 10001
#define | UNI_UART_DEVICE_NUM 2
Only 2/3 can be used on HB board
#define | UNI_UART_BAUD_RATE 115200
4800/9600/19200/38400/57600/115200/921600
#define | UNI_UART_PARITY 0
0: None, 1: Odd, 2: Even
#define | UNI_UART_STOP_BIT 1
1/2
#define | UNI_UART_DATA_BIT 8

详细描述


蜂鸟离线方案开发指导手册: 串口相关宏定义

宏定义
串口相关宏定义
配置宏定义

Custom UART settings, default 19200, 8, 1, 0 更多...

宏定义

#define | USER_UART_DEVICE_NUM 3
Only 2/3 can be used on HB board
#define | USER_UART_BAUD_RATE 19200
4800/9600/19200/38400/57600/115200/921600
#define | USER_UART_PARITY 0
0: None, 1: Odd, 2: Even
#define | USER_UART_STOP_BIT 1
1/2
#define | USER_UART_DATA_BIT 8

详细描述


蜂鸟离线方案开发指导手册: 语音相关宏定义

宏定义
语音相关宏定义
配置宏定义

Recognize configurations, default multiply dialogue and no AEC 更多...

宏定义

#define | MULTI_DIALOGUE_MODE 1
#define | WAKEUP_INTERRUPT_MODE 0

详细描述

宏定义说明

◆ MULTI_DIALOGUE_MODE

#define MULTI_DIALOGUE_MODE 1

多轮对话模式

  • 1: multiply dialogue mode
  • 0: single dialogue mode

◆ WAKEUP_INTERRUPT_MODE

#define WAKEUP_INTERRUPT_MODE 0

唤醒打断模式

  • 1: wakeup interrupt reply
  • 0: wakeup cannot interrupt reply


蜂鸟离线方案开发指导手册: Demo相关宏定义

宏定义
Demo相关宏定义
配置宏定义

使用方法见详细描述 更多...

宏定义

#define | USER_RUN_DEMO 0
add your code to user_main() to run 更多...
#define | USER_DEMO_SMART_AC 1
a demo to show smart air fan (have to replace grammar and mp3 to support commands)
#define | USER_DEMO_HOUSEKEEPER 2
a demo to show IR controller base on HB1688 what is driven by UART
#define | USER_DEMO_KEY_WAKEUP 3
a demo to show how to wakeup device by digital key base on GPIO
#define | USER_DEMO_ADC_CTRL 4
a demo to show how to wakeup device by keep pressed key base on ADC
#define | USER_DEMO_TIMERS 5
a demo to show how to set 15 software timers base on 1 hardware timer
#define | USER_DEMO_BUZZER 6
a demo to show how to drive a buzzer base on timer
#define | USER_DEMO_PWM_LED 7
a demo to show how to drive a LED base on PWM
#define | USER_DEMO_I2C_TIME 8
a demo to show how to get real time from DS3231 base on I2C
#define | USER_DEMO_SPI_LCD 9
a demo to show how to draw chars on LCD waht driven by SSD1306 base on SPI
#define | USER_DEMO_UART 10
a demo to show how to use uart send and receive data
#define | USER_DEMO_UART_UCP 11
a demo to show how to use uart send and receive data with uart communication protocol
#define | USER_DEMO_PLAYER 12
a demo to show how to use player
#define | USER_DEMO_FLASH 13
a demo to show how to save value into flash
#define | USER_DEMO_ASR_CONTROL 14
a demo to show how to control asr state
#define | USER_DEMO_NOISE_CTRL 15
a demo to show how to start offline noise reduction mode
#define | USER_RUN_DEMO_SELECT USER_DEMO_SMART_AC
select a demo to run

详细描述

Demo使用方法：

1.要使能Demo功能，先将USER_RUN_DEMO 设置为1
2.再通过配置USER_RUN_DEMO_SELECT 定义为需要展示的示例程序宏
3.重新编译固件，烧录后即可体验demo运行效果

宏定义说明

◆ USER_RUN_DEMO

#define USER_RUN_DEMO 0

1: select a demo to run, 0: no user demo,


蜂鸟离线方案开发指导手册: 音频控制

模块
音频控制

音频控制接口参考user/inc/user_player.h 更多...

模块

音频控制说明
音频控制接口
音频控制示例

详细描述


蜂鸟离线方案开发指导手册: 音频控制说明

音频控制说明
音频控制
音频控制说明：
  1. 可播放tools/scripts路径下的音频，文件名以序号区分
  2. 调用播放接口是异步不堵塞的
  3. AUDIO_PLAY_TYPE 目前只支持AUDIO_PLAY_REPLY


蜂鸟离线方案开发指导手册: 音频控制接口

函数
音频控制接口
音频控制

函数

int | user_player_play (AUDIO_PLAY_TYPE type, const char *file)
播放文件 更多...
int | user_player_reply_list_num (const char *file_list, int num)
播放列表序号音频 更多...
int | user_player_reply_list_random (const char *file_list)
随机播放列表音频 更多...
int | user_player_stop (AUDIO_PLAY_TYPE type)
停止播放 更多...
int | user_player_set_volume_min (void)
设置最小音量
int | user_player_set_volume_max (void)
设置最大音量
int | user_player_set_volume_mid (void)
设置中等音量
int | user_player_set_volume_up (void)
增加音量
int | user_player_set_volume_down (void)
减小音量
int | user_player_speaker_mute (void)
设置喇叭静音
int | user_player_speaker_unmute (void)
取消设置喇叭静音

详细描述

函数说明

◆ user_player_play()

int user_player_play | ( | AUDIO_PLAY_TYPE | type,
 |  | const char * | file
 | ) |  |
参数
type | 播放类型
file | 播放文件名
返回值
0 | 操作成功
-1 | 操作失败

◆ user_player_reply_list_num()

int user_player_reply_list_num | ( | const char * | file_list,
 |  | int | num
 | ) |  |
参数
file_list | 文件列表 [1, 2, 3]
num | 列表序号
返回值
0 | 操作成功
-1 | 操作失败

◆ user_player_reply_list_random()

int user_player_reply_list_random ( const char * file_list )
参数
file_list 文件列表 [1, 2, 3]
返回值
0 | 操作成功
-1 | 操作失败

◆ user_player_stop()

int user_player_stop ( AUDIO_PLAY_TYPE type )
参数
type 播放类型
返回值
0 | 操作成功
-1 | 操作失败


蜂鸟离线方案开发指导手册: 音频控制示例

模块
音频控制示例
音频控制

模块

hb_player.c

详细描述


蜂鸟离线方案开发指导手册: hb_player.c

hb_player.c
音频控制 » 音频控制示例

可通过定义user/inc/user_config.h中的宏USER_RUN_DEMO_SELECT 为USER_DEMO_PLAYER 运行示例程序

/**************************************************************************
* Copyright (C) 2017-2017 Unisound
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
**************************************************************************
*
* Description : hb_player.c
* Author : liuwenzheng@unisound.com
* Date : 2020.04.25
*
**************************************************************************/
#include "user_player.h"
#define TAG "player_demo"
static void _player_test_process(void *args) {
while (1) {
uni_sleep(10);
user_player_set_volume_min();
LOGT(TAG, "set min vol");
/*播放9.mp3文件*/
user_player_play(AUDIO_PLAY_REPLY, "9"); //9.mp3
uni_sleep(10);
user_player_set_volume_mid();
LOGT(TAG, "set mid vol");
/*播放列表中的101.MP3文件*/
user_player_reply_list_num("[9,101,102]", 1);
uni_sleep(10);
user_player_set_volume_max();
LOGT(TAG, "set max vol");
/*随机播放列表中的某个文件*/
user_player_reply_list_random("[9,101,102]");
break;
}
}
static Result _create_player_test_thread(void) {
struct thread_param param;
uni_pthread_t pid;
uni_memset(&param, 0, sizeof(param));
param.stack_size = STACK_SMALL_SIZE;
param.th_priority = OS_PRIORITY_LOW;
uni_strncpy(param.task_name, "player_test", sizeof(param.task_name) - 1);
if (0 != uni_pthread_create(&pid, &param,
_player_test_process, NULL)) {
LOGE(TAG, "create thread failed");
return E_FAILED;
}
uni_pthread_detach(pid);
return E_OK;
}
int hb_player(void) {
_create_player_test_thread();
return 0;
}


蜂鸟离线方案开发指导手册: 语音控制

模块
语音控制

语音控制接口参考user/inc/user_asr.h 更多...

模块

语音控制说明
语音控制接口
音频控制示例

详细描述


蜂鸟离线方案开发指导手册: 语音控制说明

语音控制说明
语音控制
语音控制说明:
  1. 可控制语音识别工作模式的切换（仅识别唤醒词； 仅识别命令词）
  2. 可控制语音识别功能的开关
  3. 可控制禁用/启用特定的识别词


蜂鸟离线方案开发指导手册: 语音控制接口

函数
语音控制接口
语音控制

函数

int | user_asr_goto_sleep (void)
进入睡眠状态 更多...
int | user_asr_goto_awakend (void)
进入唤醒状态 更多...
int | user_asr_recognize_enable (void)
使能语音识别 更多...
int | user_asr_recognize_disable (void)
关闭语音识别 更多...
int | user_asr_word_enable (const char *word)
启用识别词 更多...
int | user_asr_word_disable (const char *word)
禁用识别词 更多...

详细描述

函数说明

◆ user_asr_goto_awakend()

int user_asr_goto_awakend ( void )

进入后将只会识别命令词

返回值
0 操作成功

◆ user_asr_goto_sleep()

int user_asr_goto_sleep ( void )

进入后将只会识别唤醒词

返回值
0 操作成功

◆ user_asr_recognize_disable()

int user_asr_recognize_disable ( void )

mic被关闭，停止拾音

返回值
0 操作成功

◆ user_asr_recognize_enable()

int user_asr_recognize_enable ( void )

mic开始接收数据

返回值
0 操作成功

◆ user_asr_word_disable()

int user_asr_word_disable ( const char * word )

禁用识别词

参数
word 要禁用的识别词
返回值
0 操作成功

◆ user_asr_word_enable()

int user_asr_word_enable ( const char * word )

启用识别词

参数
word 要启用的识别词
返回值
0 操作成功


蜂鸟离线方案开发指导手册: 音频控制示例

模块
音频控制示例
语音控制

模块

hb_asr_control.c

详细描述


蜂鸟离线方案开发指导手册: hb_asr_control.c

hb_asr_control.c
语音控制 » 音频控制示例

可通过定义user/inc/user_config.h中的宏USER_RUN_DEMO_SELECT 为USER_DEMO_ASR_CONTROL 运行示例程序

/**************************************************************************
* Copyright (C) 2020-2020 Unisound
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
**************************************************************************
*
* Description : user_flash_example.c
* Author : yuanshifeng@unisound.com
* Date : 2020.04.25
*
**************************************************************************/
#include "user_asr.h"
#define TAG "asr_control"
static void _hb_asr_control_task(void *args) {
while (1) {
//进入睡眠模式，此时将只能通过唤醒词唤醒，说命令词无效
user_asr_goto_sleep();
LOGT(TAG, "Now is into sleep mode, you can awake it");
uni_sleep(10);//延迟10秒
//进入唤醒模式，此时可以识别命令词
user_asr_goto_awakend();
LOGT(TAG, "Now is into awake mode, you can say cmd word ");
uni_sleep(10);
//仍然在唤醒模式，执行关闭语音控制
user_asr_recognize_disable();
LOGT(TAG, "asr recognize is disabled, nothing will be recongnized");
uni_sleep(10);
//重新打开语音控制
user_asr_recognize_enable();
LOGT(TAG, "asr recognize is enabled");
//延迟10秒
uni_sleep(10);
}
}
int hb_asr_control(void) {
//启动一个线程，执行语音控制切换
uni_pthread_t pid;
struct thread_param param;
param.stack_size = STACK_SMALL_SIZE;
param.th_priority = OS_PRIORITY_NORMAL;
strncpy(param.task_name, "hb-asr", sizeof(param.task_name) - 1);
uni_pthread_create(&pid, &param, _hb_asr_control_task, NULL);
//禁用一个识别/唤醒词
user_asr_word_disable("退下");
user_asr_word_disable("再见");
return 0;
}


蜂鸟离线方案开发指导手册: 云知声标准协议数据通讯

模块
云知声标准协议数据通讯

云知声标准协议数据通讯接口参考user/inc/user_uni_ucp.h 更多...

模块

云知声标准协议数据通讯
云知声标准协议数据通讯接口
云知声标准协议数据通讯示例

详细描述


蜂鸟离线方案开发指导手册: 云知声标准协议数据通讯

云知声标准协议数据通讯
云知声标准协议数据通讯
云知声标准协议数据通讯说明:
  1. 可通过定义user/inc/user_config.h中的宏USE_UNIONE_PROTOCOL 设为1来启用此功能
协议说明:

云知声蜂鸟UART可靠通信协议接口文档

V3.0

修改记录

版本 | 修订日期 | 修订人员 | 修订纪要
V2.0 | 2019.12.30 | 尚金龙 | Release 2.0
V2.1 | 2020.01.06 | 尚金龙 | 协议栈自动处理ack、resend、去除重复帧
V3.0 | 2020.04.27 | 尚金龙 | 支持跨平台移植

文档目录

1. 概述............................................................................................................................. 4

1.1. 目的与受众........................................................................................................ 4

1.2. 简介................................................................................................................... 4

2. 接口定义...................................................................................................................... 5

2.1. UART底层API...................................................................................................... 5

2.1.1. UartInitialize............................................................................................... 5

2.1.2. UartFinalize................................................................................................ 6

2.1.3. UartWrite................................................................................................... 6

2.2. UART protocol API................................................................................................. 7

2.2.1. CommProtocolInit....................................................................................... 7

2.2.2. CommProtocolFinal...................................................................................... 7

2.2.3. CommProtocolPacketAssembleAndSend......................................................... 7

2.2.4. CommProtocolReceiveUartData.................................................................... 8

3. Protocol帧结构.............................................................................................................. 9

3.1.1. Protocol layout............................................................................................ 9

3.1.2. Protocol struct............................................................................................ 9

3.1.3. Protocol ACK............................................................................................... 9

3.1.4. Protocol重要参数指标.............................................................................. 10

4. 接口调用流程............................................................................................................. 10

4.1. 已有自定义协议调用过程.................................................................................. 10

4.2. 蜂鸟UART协议调用过程................................................................................... 11

5. 移植协议栈到任意平台............................................................................................... 13

5.1. 注册跨平台Hooks............................................................................................. 13

5.2. Porting demo...................................................................................................... 13

6. 附录........................................................................................................................... 14

6.1. 错误码.............................................................................................................. 14

1. 概述

1.1. 目的与受众

本文系云知声蜂鸟芯片UART应用层可靠通信串口协议，供内部开发人员和获授权客户开发使用，旨在为客户提供简单、通用的UART可靠通信协议规范。

1.2. 简介

目标客户：

一、已有自定义UART通信协议客户，对此类型客户，开放UART读写API，客户可自行定制基于UART的各类传输特性。

二、尚未自定义UART通信协议客户，对此类客户，开放一套完整的UART通信协议，提供API，实现串口通信。

UART协议特性：

一、类TCP可靠传输模式。

二、类UDP不可靠传输模式。

三、自动过滤重复帧。

四、自动重传。

五、自动组装数据帧，自动拆解数据帧。

六、最大帧长检测设置。

七、支持控制命令类型定制，命令参数定制。

八、支持极低内存限制下，自适应内存垃圾回收功能。

九、crc16校验和。

2. 接口定义

2.1. UART底层API

用于uart底层驱动初始化，数据发送、接收

2.1.1. UartInitialize

typedef enum {

UNI_UART1,

UNI_UART2,

UNI_UART3,

} UartDeviceName;

typedef enum {

UNI_B_1200,

UNI_B_2400,

UNI_B_4800,

UNI_B_9600,

UNI_B_14400,

UNI_B_19200,

UNI_B_38400,

UNI_B_57600,

UNI_B_115200,

} UartSpeed;

typedef enum {

UNI_PARITY_ODD,

UNI_PARITY_EVEN,

UNI_PARITY_NONE,

UNI_PARITY_MARK,

UNI_PARITY_SPACE,

} UartParity;

typedef enum {

UNI_ONE_STOP_BIT,

UNI_ONE_5_STOP_BIT,

UNI_TWO_STOP_BIT,

} UartStop;

/**

* uart init configure parameter

*/

typedef struct {

UartDeviceName device; /* device name */

UartSpeed speed; /* baudrate */

UartParity parity; /* parity check */

UartStop stop; /* stop bit */

int data_bit; /* data bit */

} UartConfig;

typedef void (*RecvUartDataHandler)(char *buf, int len);

/**

* @brief uart init

* @param config uart configure parameter

* @param handler handle uart receive data hook

* @return 0 means success, -1 means failed

*/

int UartInitialize(UartConfig *config, RecvUartDataHandler handler);

2.1.2. UartFinalize

/**

* @brief uart finalize

* @param void

* @return void

*/

void UartFinalize(void);

2.1.3. UartWrite

/**

* @brief write data by UART, multi-thread unsafe, please write in sync mode

* @param buf the data buffer to write

* @param len the data length

* @return the actual write length by UART

*/

int UartWrite(char *buf, int len);

2.2. UART protocol API

用于串口数据封装、解包

2.2.1. CommProtocolInit

typedef struct {

CommCmd cmd; /* command, such as power_on, power_off */

CommPayloadLen payload_len; /* parameter length of command */

char payload[0]; /* parameter of command */

} PACKED CommPacket;

typedef void (*CommRecvPacketHandler)(CommPacket *packet);

/**

* @brief communication protocol init

* @param write_handler the write handler, such as UartWrite int uni_uart.h

* @param recv_handler when uart data disassemble as communication protocol frame, the frame will be translate to struct CommPacket, then the CommPacket will callback to user

* @return 0 means success, -1 means failed

*/

int CommProtocolInit(CommWriteHandler write_handler,

CommRecvPacketHandler recv_handler);

2.2.2. CommProtocolFinal

/**

* @brief communication protocol finalize

* @param void

* @return void

*/

void CommProtocolFinal(void);

2.2.3. CommProtocolPacketAssembleAndSend

/**

* @brief send one packet(communication protocol frame format)

* @param type customer type, 0 means Unisound

* @param cmd command type, should define as enum (such as power_on、power_off)

* @param payload the payload of cmd, can set as NULL

* @param payload_len the payload length

* @param attribute the attribute for this packet, such as packet need ACK

* @return 0 means success, other means failed

*/

int CommProtocolPacketAssembleAndSend(CommType type,

CommCmd cmd,

char *payload,

CommPayloadLen payload_len,

CommAttribute *attribute);

2.2.4. CommProtocolReceiveUartData

/**

* @brief receive orignial uart data

* @param buf the uart data buffer pointer

* @param len the uart data length

* @return void

*/

void CommProtocolReceiveUartData(char *buf, int len);

3. Protocol帧结构

3.1.1. Protocol layout

3.1.2. Protocol struct

3.1.3. Protocol ACK

通过CommProtocolPacketAssembleAndSend接口参数attribute配置是否启用可靠传输，可靠传输时，需接收方协议栈回复ACK信息，实现可靠传输。

ACK为协议栈内部逻辑，当配置为可靠传输时，协议栈自动回复ACK信息，上层应用无需关注。

ACK帧格式详情可参阅3.1.1 protocol ack frame。

3.1.4. Protocol重要参数指标

1、最大payload：8182字节。即超过8182字节将被拒绝发送、拒绝拆包解析。

2、自动内存回收阈值：1024字节。由于接收到的数据长度不确定（即每一个command帧字节可不同），接收解析器会对protocol buffer自动扩容、收缩，以此来减少内存开销，protocol buffer初始长度16字节，扩容策略为当前长度的2倍（即16、32、64、128...）当解析出一帧有效数据后，会自动回收大于等于1024字节的heap内存；小于1024字节选择常驻内存，以此优化内存分配性能，直到调用CommProtocolFinal销毁。

3、ack超时：目前设定200ms。

4、自动重传：可靠传输发送方200ms未收到ack帧，会自动重发5次（即最多发6次），仍等不到ack则返回错误码E_UNI_COMM_PAYLOAD_ACK_TIMEOUT。

4. 接口调用流程

4.1. 已有自定义协议调用过程

#include "uni_uart.h"

#include "uni_log.h"

#define MAIN_TAG "main"

static void __recv_uart_data(char *buf, int len) {

LOGT(MAIN_TAG, "receive uart data");

/**

* 接收到uart数据，在此进行处理，数据可能是byte by byte形式，不能假设发送方发送了

* 32字节，本次回调出来就是32字节，只能保证多次回调后，最终32字节

*/

}

int main() {

/**

* step 1. 初始化UART。

* 初始化完成后，即可以实现串口数据的读写操作。

*/

UartConfig config;

config.device = UNI_UART1;

config.parity = UNI_PARITY_NONE;

config.speed = UNI_B_115200;

config.stop = UNI_ONE_STOP_BIT;

config.data_bit = 8;

UartInitialize(&config, __recv_uart_data);

/**

* step 2. 写数据

* 向UART写数据，请调用UartWrite接口

*/

char buf[32];

UartWrite(buf, sizeof(buf));

LOGT(MAIN_TAG, "write random data to UART");

/**

* step 3. 反初始化UART。

*/

UartFinalize();

return 0;

}

4.2. 蜂鸟UART协议调用过程

#include "uni_uart.h"

#include "uni_communication.h"

#include "uni_log.h"

#define MAIN_TAG "main"

typedef enum {

POWER_ON = 0,

POWER_FF,

} CommandType;

static void __recv_customer_packet(CommPacket *packet) {

LOGT(MAIN_TAG, "receive packet, cmd=%d, payload_len=%d",

packet->cmd, packet->payload_len);

}

int main() {

/**

* step 1. 初始化UART。

* 初始化完成后，即可以实现串口数据的读写操作。

*/

UartConfig config;

config.device = UNI_UART1;

config.parity = UNI_PARITY_NONE;

config.speed = UNI_B_115200;

config.stop = UNI_ONE_STOP_BIT;

config.data_bit = 8;

UartInitialize(&config, CommProtocolReceiveUartData);

/**

* step 2. 初始化protocol

* 向protocol注册UART写方法、接收拆包后结构信息回调

*/

CommProtocolInit(UartWrite, __recv_customer_packet);

/**

* step 3. 写数据

* 向UART写一帧满足协议格式的数据

*/

char payload[32];

for (int i = 0; i < sizeof(payload); i++) {

payload[i] = (char)i;

}

CommAttribute attribute;

attribute.reliable = true;

/**

* payload、attribute设置为NULL则代表无payload，不需要ack

* attribute.reliable = true; 则表示接收方必须发送ack，否则本次发送失败，

* 返回ack超时错误码

*/

CommProtocolPacketAssembleAndSend(UNI_CUSTOMER_TYPE,

POWER_ON,

payload,

sizeof(payload),

&attribute);

/**

* step 3. 反初始化。

*/

CommProtocolFinal();

UartFinalize();

return 0;

}

5. 移植协议栈到任意平台

5.1. 注册跨平台Hooks

需要注册的跨平台Hooks分为三类：

1、动态内存分配函数，必备APIs，必须注册，否则协议栈无法运行。

2、信号量函数，可选APIs，建议注册，可有效提升协议栈性能。

3、睡眠函数，必备API，必须注册。

5.2. Porting demo

在开源代码example目录分别展示了RT-Thread、Linux、8051单片机移植实例。

需要注意的点，已在demo中详细指出。

6. 附录

6.1. 错误码

结果码 | 含义 | 备注
(0) | 成功 | 通用错误码
(-1) | 错误 | 通用错误码
E_UNI_COMM_ALLOC_FAILED (-10001) | 申请heap内存失败 | 内存不足，申请失败
E_UNI_COMM_PAYLOAD_TOO_LONG (-10000) | 发送的payload太长 | 当前支持最大payload为8182字节
E_UNI_COMM_PAYLOAD_ACK_TIMEOUT(-9999) | 设置接收数据端需ack属性时，接收数据端ack超时 | 目前超时支持[50ms，2000ms]区间


蜂鸟离线方案开发指导手册: 云知声标准协议数据通讯接口

类型定义 | 函数
云知声标准协议数据通讯接口
云知声标准协议数据通讯

类型定义

typedef void(* _user_uni_recv) (uni_u16 cmd, char *payload, int len)
接收数据回调函数定义 更多...

函数

int | user_uni_ucp_init (_user_uni_recv cb_recv)
通讯初始化 更多...
void | user_uni_ucp_final (void)
通讯逆初始化
int | user_uni_ucp_send (uni_u16 cmd, char *payload, int len, uni_bool is_block)
通讯数据发送 更多...

详细描述

类型定义说明

◆ _user_uni_recv

typedef void(* _user_uni_recv) (uni_u16 cmd, char *payload, int len)
参数
cmd | 命令值
payload | 接收字符指针
len | 接收字符长度

函数说明

◆ user_uni_ucp_init()

int user_uni_ucp_init ( _user_uni_recv cb_recv )
参数
cb_recv 接收数据回调函数
返回值
0 | 操作成功
-1 | 操作失败

◆ user_uni_ucp_send()

int user_uni_ucp_send | ( | uni_u16 | cmd,
 |  | char * | payload,
 |  | int | len,
 |  | uni_bool | is_block
 | ) |  |
参数
cmd | 命令值
payload | 发送字符指针
len | 发送字符长度
is_block | 是否堵塞
返回值
else | 实际发送字符长度
-1 | 操作失败


蜂鸟离线方案开发指导手册: 云知声标准协议数据通讯示例

模块
云知声标准协议数据通讯示例
云知声标准协议数据通讯

模块

hb_uart_ucp.c

详细描述


蜂鸟离线方案开发指导手册: hb_uart_ucp.c

hb_uart_ucp.c
云知声标准协议数据通讯 » 云知声标准协议数据通讯示例

可通过定义user/inc/user_config.h中的宏USER_RUN_DEMO_SELECT 为USER_DEMO_UART_UCP 运行示例程序

/**************************************************************************
* Copyright (C) 2017-2017 Unisound
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
**************************************************************************
*
* Description : hb_uart_ucp.c
* Author : shangjinlong@unisound.com
* Date : 2020.04.25
*
**************************************************************************/
#include "user_uni_ucp.h"
#define TAG "hb_ucp"
/* 接收到串口数据后，该接口将被触发回调 */
static void _hb_ucp_recv(uni_u16 cmd, char *payload, int len) {
LOGT(TAG, "recv ucp packet, cmd=%d, len=%d", cmd, len);
int i;
LOGR(TAG, "payload: ");
for (i = 0; i < len; i++) {
LOGR(TAG, "02x ", payload[i]);
}
LOGR(TAG, "\n");
}
//消息唯一索引码，不可重叠
//规定[1, 10000]消息号预留给客户扩展；[10001, 65535]云知声内部使用
enum {
e_MSG_HEARTBEAT = 10001,
e_MSG_DEMO,
};
static void _hb_ucp_send_task(void *args) {
char buf[4] = {'p', 'i', 'n', 'g'};
int ret;
while (1) {
LOGT(TAG, "hb uart ucp send heartbeat: ping");
//is_block = 1指可靠传输，必须接收方ack确认（TCP模式），0 UDP模式
ret = user_uni_ucp_send(e_MSG_HEARTBEAT, buf, sizeof(buf), 1);
LOGT(TAG, "hb uart send done, ret=%d", ret);
uni_msleep(2000);
}
}
int hb_uart_ucp(void) {
//将宏USE_UNIONE_PROTOCOL打开，设置为1
int ret = user_uni_ucp_init(_hb_ucp_recv);
if (ret != 0) {
LOGE(TAG, "hb uart ucp init failed");
return -1;
}
//启动一个线程，模拟发送串口消息任务
uni_pthread_t pid;
struct thread_param param;
param.stack_size = STACK_SMALL_SIZE;
param.th_priority = OS_PRIORITY_NORMAL;
strncpy(param.task_name, "hb-ucp", sizeof(param.task_name) - 1);
uni_pthread_create(&pid, &param, _hb_ucp_send_task, NULL);
return 0;
}


蜂鸟离线方案开发指导手册: 数据存储

模块
数据存储

数据存储接口参考user/inc/user_flash.h 更多...

模块

数据存储说明
数据存储接口
数据存储示例

详细描述


蜂鸟离线方案开发指导手册: 数据存储说明

数据存储说明
数据存储
数据存储说明:
  1. 以key-value形式保存自定义值到flash中，常用于保存配置信息
  2. 可用于该功能的空间为64k


蜂鸟离线方案开发指导手册: 数据存储接口

函数
数据存储接口
数据存储

函数

int | user_flash_init (void)
flash初始化 更多...
void | user_flash_final (void)
flash逆初始化
int | user_flash_set_env_blob (const char *key, const void *value_buf, int buf_len)
保存键值数据对到flash 更多...
int | user_flash_get_env_blob (const char *key, void *value_buf, int buf_len, int *save_len)
读取输入键的值 更多...

详细描述

函数说明

◆ user_flash_get_env_blob()

int user_flash_get_env_blob | ( | const char * | key,
 |  | void * | value_buf,
 |  | int | buf_len,
 |  | int * | save_len
 | ) |  |

Get a blob ENV value by key name.

参数
key | ENV name
value_buf | ENV blob buffer
buf_len | ENV blob buffer length
save_len | return the length of the value saved on the flash, 0: NOT found
返回
the actually get size on successful

◆ user_flash_init()

int user_flash_init ( void )
返回值
0 | 操作成功
-1 | 操作失败

◆ user_flash_set_env_blob()

int user_flash_set_env_blob | ( | const char * | key,
 |  | const void * | value_buf,
 |  | int | buf_len
 | ) |  |
参数
key | 键名
value_buf | 键值
buf_len | 键值长度
返回
-成功：返回键值长度 -失败：-1


蜂鸟离线方案开发指导手册: 数据存储示例

模块
数据存储示例
数据存储

模块

hb_flash_example.c

详细描述


蜂鸟离线方案开发指导手册: hb_flash_example.c

hb_flash_example.c
数据存储 » 数据存储示例

可通过定义user/inc/user_config.h中的宏USER_RUN_DEMO_SELECT 为USER_DEMO_FLASH 运行示例程序

/**************************************************************************
* Copyright (C) 2020-2020 Unisound
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
**************************************************************************
*
* Description : user_flash_example.c
* Author : yuanshifeng@unisound.com
* Date : 2020.04.25
*
**************************************************************************/
#include "user_flash.h"
#define TAG "flash_example"
#define BLOB_KEY_EXAMPLE_INT "EXAMPLE_INT"
#define BLOB_TYPE_U32 uni_u32
int hb_flash(void) {
BLOB_TYPE_U32 example_int = 0;
int save_len = 0;
if (0 != user_flash_init()) {
LOGE(TAG, "user_flash_init failed.");
return -1;
}
user_flash_get_env_blob(BLOB_KEY_EXAMPLE_INT, &example_int,
sizeof(BLOB_TYPE_U32), &save_len);
if (save_len != sizeof(BLOB_TYPE_U32)) {
//仅首次开机进入，发现flash中没有"EXAMPLE_INT"字段，保存一个88进去，待下次开机查看是否能直接读取出这个值。
BLOB_TYPE_U32 set_int = 88;
LOGT(TAG, "cannot found %s in flash, save value %d into flash", BLOB_KEY_EXAMPLE_INT, set_int);
user_flash_set_env_blob(BLOB_KEY_EXAMPLE_INT, &set_int,sizeof(BLOB_TYPE_U32));
}
if (example_int > 0) {
//打印读取flash中"EXAMPLE_INT"字段的值，读出88表示成功保存了值到flash中
LOGT(TAG, "read %s in flash success, value is %d", BLOB_KEY_EXAMPLE_INT, example_int);
}
return 0;
}


蜂鸟离线方案开发指导手册: 串口收发

模块
串口收发

串口收发接口参考user/inc/user_uart.h 更多...

模块

串口收发说明
串口收发接口
串口收发示例

详细描述


蜂鸟离线方案开发指导手册: 串口收发说明

串口收发说明
串口收发
串口收发说明:
  1. 使用该功能需设置user/inc/user_config.h中的宏USE_UNIONE_PROTOCOL 设为0
  2. 串口透传收发


蜂鸟离线方案开发指导手册: 串口收发接口

类型定义 | 函数
串口收发接口
串口收发

类型定义

typedef void(* _user_uart_recv) (char *buf, int len)
接收数据回调函数定义 更多...

函数

int | user_uart_init (_user_uart_recv cb_recv)
串口初始化 更多...
void | user_uart_final (void)
串口逆初始化
int | user_uart_send (char *buf, int len)
串口数据发送 更多...

详细描述

类型定义说明

◆ _user_uart_recv

typedef void(* _user_uart_recv) (char *buf, int len)
参数
buf | 接收字符指针
len | 接收字符长度

函数说明

◆ user_uart_init()

int user_uart_init ( _user_uart_recv cb_recv )
参数
cb_recv 接收数据回调函数
返回值
0 | 操作成功
-1 | 操作失败

◆ user_uart_send()

int user_uart_send | ( | char * | buf,
 |  | int | len
 | ) |  |
参数
buf | 发送字符指针
len | 发送字符长度
返回值
else | 实际发送字符长度
-1 | 操作失败


蜂鸟离线方案开发指导手册: 串口收发示例

模块
串口收发示例
串口收发

模块

hb_uart.c

详细描述


蜂鸟离线方案开发指导手册: hb_uart.c

hb_uart.c
串口收发 » 串口收发示例

可通过定义user/inc/user_config.h中的宏USER_RUN_DEMO_SELECT 为USER_DEMO_UART 运行示例程序

/**************************************************************************
* Copyright (C) 2017-2017 Unisound
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
**************************************************************************
*
* Description : hb_uart.c
* Author : shangjinlong@unisound.com
* Date : 2020.04.25
*
**************************************************************************/
#include "user_uart.h"
#define TAG "hb_uart"
/* 接收到串口数据后，该接口将被触发回调 */
static void _hb_uart_recv(char *buf, int len) {
int i;
for (i = 0; i < len; i++) {
LOGR(TAG, "%02x ", (uint8_t)buf[i]);
}
}
static void _hb_uart_send_task(void *args) {
char buf[6] = {1, 2, 3, 4, 5, 6};
int ret;
/* 每隔2秒发送一次 */
while (1) {
LOGT(TAG, "hb uart send[1, 2, 3, 4, 5, 6]");
ret = user_uart_send(buf, sizeof(buf));
LOGT(TAG, "hb uart send done, ret=%d", ret);
uni_msleep(2000);
}
}
int hb_uart(void) {
int ret = user_uart_init(_hb_uart_recv);
if (ret != 0) {
LOGE(TAG, "hb uart init failed");
return -1;
}
//启动一个线程，模拟发送串口消息任务
uni_pthread_t pid;
struct thread_param param;
param.stack_size = STACK_SMALL_SIZE;
param.th_priority = OS_PRIORITY_NORMAL;
strncpy(param.task_name, "hb-uart", sizeof(param.task_name) - 1);
uni_pthread_create(&pid, &param, _hb_uart_send_task, NULL);
return 0;
}


蜂鸟离线方案开发指导手册: 定时器

模块
定时器

定时器接口参考user/inc/user_timer.h 更多...

模块

定时器说明
定时器接口
定时器类型定义
定时器示例

详细描述


蜂鸟离线方案开发指导手册: 定时器说明

定时器说明
定时器
定时器说明:
  1. user/src/examples/drivers/user_sw_timer.c是基于一个硬件timer，配置成多个软定时器的示例，达到突破硬件timer个数限制的目的
  2. user/src/user_timer.c为硬件定时器接口


蜂鸟离线方案开发指导手册: 定时器接口

函数
定时器接口
定时器

函数

int | user_timer_init (eTIMER_IDX idx, uint32_t usec, usr_timer_callback cb)
定时器初始化 更多...
void | user_timer_start (eTIMER_IDX idx)
启动定时器 更多...
void | user_timer_pause (eTIMER_IDX idx)
暂停定时器计数 更多...
void | user_timer_resume (eTIMER_IDX idx)
重新使能定时器计数 更多...

详细描述

函数说明

◆ user_timer_init()

int user_timer_init | ( | eTIMER_IDX | idx,
 |  | uint32_t | usec,
 |  | usr_timer_callback | cb
 | ) |  |
参数
idx | 定时器索引,可选择的值是eTIMER2和eTIMER3
usec | 定时设置, 单位：微妙(us)
cb | timer中断处理回调函数，会在中断处理中调用此函数
返回值
0 | 操作成功
-1 | 操作失败

◆ user_timer_pause()

void user_timer_pause ( eTIMER_IDX idx )
参数
idx 定时器索引

◆ user_timer_resume()

void user_timer_resume ( eTIMER_IDX idx )
参数
idx 定时器索引

◆ user_timer_start()

void user_timer_start ( eTIMER_IDX idx )
参数
idx 定时器索引


蜂鸟离线方案开发指导手册: 定时器类型定义

类型定义 | 枚举
定时器类型定义
定时器

类型定义

typedef enum TIMER_IDX | eTIMER_IDX
定时器索引
typedef void(* | usr_timer_callback) (eTIMER_IDX idx)
定时器回调函数 更多...

枚举

enum TIMER_IDX { eTIMER_SYS = 0, eTIMER2 = 1, eTIMER3 = 2, eTIMER_SOFT = 100 }
定时器索引

详细描述

类型定义说明

◆ usr_timer_callback

typedef void(* usr_timer_callback) (eTIMER_IDX idx)
参数
idx 定时器索引


蜂鸟离线方案开发指导手册: 定时器示例

模块
定时器示例
定时器

模块

hb_sw_timers.c
user_timer_buzzer.c

详细描述


蜂鸟离线方案开发指导手册: hb_sw_timers.c

hb_sw_timers.c
定时器 » 定时器示例

可通过定义user/inc/user_config.h中的宏USER_RUN_DEMO_SELECT 为USER_DEMO_TIMERS 运行示例程序

/**************************************************************************
* Copyright (C) 2020-2020 Unisound
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
**************************************************************************
*
* Description : user_timer_buzzer.c
* Author : liuwenzheng@unisound.com
* Date : 2020.04.21
*
**************************************************************************/
#include "user_sw_timer.h"
#define TAG "sw_timer_example"
#define PARTICLE_MS 20 // 20ms
typedef struct MyTimer_s {
timer_handle_t handle;
int cnt;
}MyTimer;
static MyTimer m_timers[4] =
{
{INVALID_TIMER_HANDLE, 0},
{INVALID_TIMER_HANDLE, 0},
{INVALID_TIMER_HANDLE, 0},
{INVALID_TIMER_HANDLE, 0}
};
void _sw_timer_cb(void *param) {
int i;
timer_handle_t timer = (timer_handle_t)param;
for (i =0; i < 4; i++) {
if (timer == m_timers[i].handle) {
m_timers[i].cnt++;
break;
}
}
}
static void _timer_print_process(void *args) {
int i = 0;
int loop = 360;
while (1) {
for (i =0; i < 4; i++) {
LOGT(TAG, "---- Timer %d count = %d ----", i, m_timers[i].cnt);
}
uni_sleep(1);
if (loop > 0) {
loop--;
} else {
break;
}
}
for (i = 0; 0 < 4; i++) {
user_sw_timer_remove(m_timers[i].handle);
}
}
static Result _create_timer_print_thread(void) {
struct thread_param param;
uni_pthread_t pid;
uni_memset(&param, 0, sizeof(param));
param.stack_size = STACK_SMALL_SIZE;
param.th_priority = OS_PRIORITY_LOW;
uni_strncpy(param.task_name, "buzzer_set", sizeof(param.task_name) - 1);
if (0 != uni_pthread_create(&pid, &param,
_timer_print_process, NULL)) {
LOGE(TAG, "create thread failed");
return E_FAILED;
}
uni_pthread_detach(pid);
return E_OK;
}
int hb_sw_timer(void) {
if (E_OK != _create_timer_print_thread()) {
LOGE(TAG, "_create_timer_print_thread failed");
return -1;
}
user_sw_timer_init(eTIMER_SOFT, PARTICLE_MS);
m_timers[0].handle = user_sw_timer_add(PARTICLE_MS * 5, false, _sw_timer_cb);
m_timers[1].handle = user_sw_timer_add(PARTICLE_MS * 10, false, _sw_timer_cb);
m_timers[2].handle = user_sw_timer_add(PARTICLE_MS * 20, false, _sw_timer_cb);
m_timers[3].handle = user_sw_timer_add(PARTICLE_MS * 40, true, _sw_timer_cb); //count 1 time only
return 0;
}


蜂鸟离线方案开发指导手册: user_timer_buzzer.c

user_timer_buzzer.c
定时器 » 定时器示例

可通过定义user/inc/user_config.h中的宏USER_RUN_DEMO_SELECT 为USER_DEMO_BUZZER 运行示例程序

/**************************************************************************
* Copyright (C) 2020-2020 Unisound
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
**************************************************************************
*
* Description : user_timer_buzzer.c
* Author : liuwenzheng@unisound.com
* Date : 2020.04.21
*
**************************************************************************/
#include "user_timer_buzzer.h"
#include "user_timer.h"
#include "user_gpio.h"
#define TAG "buzzer"
#define BUZZER_HZ_MAX 4000
typedef struct {
eTIMER_IDX timer_idx;
GPIO_NUMBER gpio_num;
uni_u32 hz;
uni_u32 time_us;
}buzzer_context_t;
static buzzer_context_t g_buzzer = {0};
static void _buzzer_timer_handle(eTIMER_IDX TimerIdx) {
#if GPIO_OUT_DEF_VAL
volatile static int cur_level = 1;
#else
volatile static int cur_level = 0;
#endif
if (g_buzzer.timer_idx == TimerIdx) {
cur_level ^= 1;
user_gpio_set_value(g_buzzer.gpio_num, cur_level);
}
}
int user_timer_buzzer_init(GPIO_NUMBER num, eTIMER_IDX idx) {
user_gpio_init();
if (0 != user_gpio_set_mode(num, GPIO_MODE_OUT)) {
LOGE(TAG, "user_gpio_set_mode failed.");
}
g_buzzer.timer_idx = idx;
g_buzzer.hz = 0;
g_buzzer.gpio_num = num;
g_buzzer.time_us = 0;
return 0;
}
void user_timer_buzzer_final(void) {
user_timer_pause(g_buzzer.timer_idx);
}
int user_timer_buzzer_set_hz(uni_u32 hz) {
if (hz > BUZZER_HZ_MAX) {
LOGE(TAG, "The maximum frequency is 4000Hz.");
return -1;
}
user_timer_pause(g_buzzer.timer_idx);
g_buzzer.hz = hz;
g_buzzer.time_us = 1000 * 1000 / g_buzzer.hz;
user_timer_init(g_buzzer.timer_idx, g_buzzer.time_us, _buzzer_timer_handle);
user_timer_start(g_buzzer.timer_idx);
return 0;
}
uni_u32 user_timer_buzzer_get_hz(void) {
return g_buzzer.hz;
}


蜂鸟离线方案开发指导手册: GPIO

模块
GPIO

GPIO接口参考user/inc/user_gpio.h 更多...

模块

GPIO说明
GPIO相关接口
GPIO类型定义
GPIO示例

详细描述


蜂鸟离线方案开发指导手册: GPIO说明

GPIO说明
GPIO
GPIO说明:
  1. 配置gpio工作模式请用tools/目录下的UniPinmuxTool工具配置
  2. 当为gpio功能时，可配置PD/PU, DIR, VALUE
  3. 当为中断功能时，可注册中断回调函数_gpio_interrupt_cb ， 设置中断方式GPIO_INT_TYPE


蜂鸟离线方案开发指导手册: GPIO相关接口

函数
GPIO相关接口
GPIO

函数

int | user_gpio_init (void)
GPIO初始化 更多...
void | user_gpio_final (void)
GPIO反初始化
int | user_gpio_set_mode (GPIO_NUMBER num, GPIO_MODE mode)
设置GPIO工作模式 更多...
int | user_gpio_set_pull_mode (GPIO_NUMBER num, GPIO_PULL_MODE mode)
设置GPIO pull模式 更多...
int | user_gpio_set_value (GPIO_NUMBER num, int val)
设置GPIO端口数值 更多...
int | user_gpio_get_value (GPIO_NUMBER num)
获取GPIO端口值 更多...
int | user_gpio_interrupt_enable (void)
使能GPIO中断 更多...
int | user_gpio_interrupt_disable (void)
关闭GPIO中断 更多...
int | user_gpio_set_interrupt (GPIO_NUMBER num, GPIO_INT_TYPE type, _gpio_interrupt_cb cb)
注册GPIO中断 更多...
int | user_gpio_clear_interrupt (GPIO_NUMBER num)
注销GPIO中断注册回调函数 更多...

详细描述

函数说明

◆ user_gpio_clear_interrupt()

int user_gpio_clear_interrupt ( GPIO_NUMBER num )
参数
num GPIO端口号
返回值
0 | 操作成功
-1 | 操作失败

◆ user_gpio_get_value()

int user_gpio_get_value ( GPIO_NUMBER num )
参数
num GPIO端口号
返回值
else | 读取数值
-1 | 操作失败

◆ user_gpio_init()

int user_gpio_init ( void )
返回值
0 | 操作成功
-1 | 操作失败

◆ user_gpio_interrupt_disable()

int user_gpio_interrupt_disable ( void )
返回值
0 | 操作成功
-1 | 操作失败

◆ user_gpio_interrupt_enable()

int user_gpio_interrupt_enable ( void )
返回值
0 | 操作成功
-1 | 操作失败

◆ user_gpio_set_interrupt()

int user_gpio_set_interrupt | ( | GPIO_NUMBER | num,
 |  | GPIO_INT_TYPE | type,
 |  | _gpio_interrupt_cb | cb
 | ) |  |
参数
num | GPIO端口号
type | GPIO电平跳变模式
cb | 中断处理回调函数
返回值
0 | 操作成功
-1 | 操作失败

◆ user_gpio_set_mode()

int user_gpio_set_mode | ( | GPIO_NUMBER | num,
 |  | GPIO_MODE | mode
 | ) |  |
参数
num | GPIO端口号
mode | GPIO工作模式
返回值
0 | 操作成功
-1 | 操作失败

◆ user_gpio_set_pull_mode()

int user_gpio_set_pull_mode | ( | GPIO_NUMBER | num,
 |  | GPIO_PULL_MODE | mode
 | ) |  |
参数
num | GPIO端口号
mode | GPIO pull模式
返回值
0 | 操作成功
-1 | 操作失败

◆ user_gpio_set_value()

int user_gpio_set_value | ( | GPIO_NUMBER | num,
 |  | int | val
 | ) |  |
参数
num | GPIO端口号
val | 0 or 1
返回值
0 | 操作成功
-1 | 操作失败


蜂鸟离线方案开发指导手册: GPIO类型定义

类型定义 | 枚举
GPIO类型定义
GPIO

类型定义

typedef void(* _gpio_interrupt_cb) (GPIO_NUMBER num, uni_bool is_high)
中断回调函数 更多...

枚举

enum GPIO_NUMBER {
GPIO_NUM_0 = 0, GPIO_NUM_1, GPIO_NUM_2, GPIO_NUM_3,
GPIO_NUM_4, GPIO_NUM_5, GPIO_NUM_6, GPIO_NUM_7,
GPIO_NUM_8, GPIO_NUM_9, GPIO_NUM_10, GPIO_NUM_11,
GPIO_NUM_12, GPIO_NUM_13, GPIO_NUM_14, GPIO_NUM_15,
GPIO_NUM_16, GPIO_NUM_17, GPIO_NUM_18, GPIO_NUM_19,
GPIO_NUM_20, GPIO_NUM_21, GPIO_NUM_22, GPIO_NUM_23,
GPIO_NUM_24, GPIO_NUM_25, GPIO_NUM_26, GPIO_NUM_27,
GPIO_NUM_28, GPIO_NUM_29, GPIO_NUM_30, GPIO_NUM_31,
GPIO_NUM_MAX
}
GPIO号
enum GPIO_MODE {
GPIO_MODE_IN = 0, GPIO_MODE_OUT, GPIO_MODE_ADC, GPIO_MODE_PWM,
GPIO_MODE_UART, GPIO_MODE_I2C, GPIO_MODE_SPI, GPIO_MODE_MAX
}
GPIO模式,蜂鸟平台上没有使用 更多...
enum GPIO_PULL_MODE { GPIO_PULL_UP, GPIO_PULL_DOWN, GPIO_NOT_PULL }
GPIO PU/PD模式选择
enum GPIO_INT_TYPE {
GPIO_INT_NEG_EDGE, GPIO_INT_POS_EDGE, GPIO_INT_BOTH_EDGE, GPIO_INT_HIGH_LEVEL,
GPIO_INT_LOW_LEVEL, GPIO_INT_MAX
}
GPIO 中断方式选择 更多...

详细描述

类型定义说明

◆ _gpio_interrupt_cb

typedef void(* _gpio_interrupt_cb) (GPIO_NUMBER num, uni_bool is_high)
参数
num | 中断io号
is_high | 是否高电平

枚举类型说明

◆ GPIO_INT_TYPE

enum GPIO_INT_TYPE
枚举值
GPIO_INT_NEG_EDGE | 下降沿触发
GPIO_INT_POS_EDGE | 上升沿触发
GPIO_INT_BOTH_EDGE | 双沿触发
GPIO_INT_HIGH_LEVEL | 高电平触发
GPIO_INT_LOW_LEVEL | 低电平触发

◆ GPIO_MODE

enum GPIO_MODE
枚举值
GPIO_MODE_ADC

not used here,

参见
ADC
GPIO_MODE_PWM

not used here, should set pinmux by UniPinmuxTool

GPIO_MODE_UART

not used here, should set pinmux by UniPinmuxTool

GPIO_MODE_I2C

not used here, should set pinmux by UniPinmuxTool

GPIO_MODE_SPI

not used here, should set pinmux by UniPinmuxTool


蜂鸟离线方案开发指导手册: GPIO示例

模块
GPIO示例
GPIO

模块

hb_gpio_key.c

详细描述


蜂鸟离线方案开发指导手册: hb_gpio_key.c

hb_gpio_key.c
GPIO » GPIO示例

可通过定义user/inc/user_config.h中的宏USER_RUN_DEMO_SELECT 为USER_DEMO_KEY_WAKEUP 运行示例程序

/**************************************************************************
* Copyright (C) 2017-2017 Unisound
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
**************************************************************************
*
* Description : hb_gpio_key.c
* Author : wufangfang@unisound.com
* Date : 2020.04.25
*
**************************************************************************/
#include "user_gpio.h"
#include "user_digital_keys.h"
#include "user_asr.h"
#define TAG "hb_gpio_key"
#define USE_DIGITAL_KEYS_DRIVER 0 //1: user user_digital_keys driver, 0: user user_gpio directly
// if 0 will send wakeup event in interrupt fuction,
// it will crush because that's a long process,
// so 0 is a demo show how to use GPIO directly only
// donn't use it on your code
#define KEY_GPIO_NUM GPIO_NUM_26 // the pin used as gpio on demo board
#if USE_DIGITAL_KEYS_DRIVER
void _key_interrupt_cb(GPIO_NUMBER num) {
user_asr_goto_awakend();
}
int user_key_wakeup(void) {
user_digital_keys_init(GPIO_INT_POS_EDGE);
return user_digital_keys_register_key(KEY_GPIO_NUM, _key_interrupt_cb);
}
#else
static void _key_interrupt_cb(GPIO_NUMBER num, uni_bool is_high) {
LOGE(TAG, "handle key interrupt!! gpio_num %d, is_high %d ", num, is_high);
user_asr_goto_awakend();
}
int hb_key_wakeup(void) {
user_gpio_init();
if (0 != user_gpio_set_mode(KEY_GPIO_NUM, GPIO_MODE_IN)) {
LOGE(TAG, "user_gpio_set_mode failed.");
return -1;
}
user_gpio_set_pull_mode(KEY_GPIO_NUM, GPIO_PULL_UP);
if (0 != user_gpio_set_interrupt(KEY_GPIO_NUM, GPIO_INT_NEG_EDGE,
_key_interrupt_cb)) {
LOGE(TAG, "user_gpio_set_interrupt failed.");
return -1;
}
uni_sleep(1); //avoid debounce
user_gpio_interrupt_enable();
return 0;
}
#endif


蜂鸟离线方案开发指导手册: ADC

模块
ADC

ADC接口参考user/inc/user_adc.h 更多...

模块

ADC说明
ADC相关接口
ADC类型定义
ADC示例

详细描述


蜂鸟离线方案开发指导手册: ADC说明

ADC说明
ADC
ADC说明:
  1. ADC引脚对应ADC_AIN2、ADC_AIN3


蜂鸟离线方案开发指导手册: ADC相关接口

函数
ADC相关接口
ADC

函数

int | user_adc_init (void)
ADC初始化 更多...
int | user_adc_get_value (ADC_AIN_SEL adc_ain, int *value)
ADC初始化 更多...
int | user_adc_start (void)
ADC开始工作 更多...
int | user_adc_final (void)
ADC反初始化 更多...

详细描述

函数说明

◆ user_adc_final()

int user_adc_final ( void )
返回值
0 操作成功

◆ user_adc_get_value()

int user_adc_get_value | ( | ADC_AIN_SEL | adc_ain,
 |  | int * | value
 | ) |  |
参数
adc_ain | ADC编号
*value | ADC读取值，范围0~4095
返回值
0

◆ user_adc_init()

int user_adc_init ( void )
返回值
0

◆ user_adc_start()

int user_adc_start ( void )
返回值
0 | 操作成功
-1 | 操作失败


蜂鸟离线方案开发指导手册: ADC类型定义

枚举
ADC类型定义
ADC

枚举

enum ADC_AIN_SEL { ADC_AIN2 = 2, ADC_AIN3 = 3 }
ADC通道选择

详细描述


蜂鸟离线方案开发指导手册: ADC示例

模块
ADC示例
ADC

模块

hb_adc_key.c

详细描述


蜂鸟离线方案开发指导手册: hb_adc_key.c

hb_adc_key.c
ADC » ADC示例

可通过定义user/inc/user_config.h中的宏USER_RUN_DEMO_SELECT 为USER_DEMO_ADC_CTRL 运行示例程序

/**************************************************************************
* Copyright (C) 2017-2017 Unisound
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
**************************************************************************
*
* Description : hb_adc_key.c
* Author : yuanshifeng@unisound.com
* Date : 2020.05.06
*
**************************************************************************/
#include "user_gpio.h"
#include "user_asr.h"
#include "user_adc.h"
#include "uni_hal_adc.h"
#define TAG "hb_gpio_adc"
#define KEY_DOWN_VAL_THRE 1000
static uni_bool g_state = false; // false: disable, true: enable
static void _adc_read_process(void *args);
static Result _create_adc_read_thread(void) {
struct thread_param param;
uni_pthread_t pid;
uni_memset(&param, 0, sizeof(param));
param.stack_size = STACK_SMALL_SIZE;
param.th_priority = OS_PRIORITY_LOW;
uni_strncpy(param.task_name, "adc_key", sizeof(param.task_name) - 1);
if (0 != uni_pthread_create(&pid, &param,
_adc_read_process, NULL)) {
LOGE(TAG, "create thread failed");
return E_FAILED;
}
uni_pthread_detach(pid);
return E_OK;
}
static void _adc_read_process(void *args) {
int val = 0;
while (1) {
uni_sleep(1);
if (user_adc_get_value(ADC_AIN2, &val) == 0) {
LOGT(TAG, "****** adc val = %d *****", val);
if (val < KEY_DOWN_VAL_THRE) {
if (!g_state) {
user_asr_recognize_enable();
g_state = true;
}
} else {
if (g_state) {
user_asr_recognize_disable();
user_asr_goto_sleep();
g_state = false;
}
}
}
}
}
int hb_adc_ctrl(void) {
user_asr_recognize_disable();
g_state = false;
user_adc_init();
user_adc_start();
if (E_OK != _create_adc_read_thread()) {
LOGE(TAG, "_create_adc_read_thread faild.");
return -1;
}
return 0;
}


蜂鸟离线方案开发指导手册: Event事件

模块
Event事件

Event事件接口参考user/inc/user_event.h 更多...

模块

Event事件说明
Event事件接口
Event事件类型定义

详细描述


蜂鸟离线方案开发指导手册: Event事件说明

Event事件说明
Event事件
Event事件说明:
  1. 通过订阅指定的Event事件，来达到监听某种事件发生的目的。事件类型见USER_EVENT_TYPE


蜂鸟离线方案开发指导手册: Event事件接口

函数
Event事件接口
Event事件

函数

int | user_event_subscribe_event (USER_EVENT_TYPE event, _user_event_cb cb)
订阅一个事件 更多...
int | user_event_clear_observers (void)
清空事件订阅队列，不再接受任何事件 更多...
_user_event_cb | user_event_get_observer (USER_EVENT_TYPE event)
查询事件回调函数 更多...

详细描述

函数说明

◆ user_event_clear_observers()

int user_event_clear_observers ( void )
返回值
0 | 操作成功
-1 | 操作失败

◆ user_event_get_observer()

_user_event_cb user_event_get_observer ( USER_EVENT_TYPE event )
参数
event 待查询事件类型
返回
事件回调函数指针

◆ user_event_subscribe_event()

int user_event_subscribe_event | ( | USER_EVENT_TYPE | event,
 |  | _user_event_cb | cb
 | ) |  |
参数
event | 待订阅事件类型
cb | 事件回调函数指针
返回值
0 | 操作成功
-1 | 操作失败


蜂鸟离线方案开发指导手册: Event事件类型定义

结构体 | 类型定义 | 枚举
Event事件类型定义
Event事件

结构体

struct | event_audio_play_t
对应USER_AUDIO_PLAY_START事件 更多...
struct | event_audio_end_t
对应USER_AUDIO_PLAY_END事件 更多...
struct | event_custom_setting_t
对应USER_CUSTOM_SETTING事件 更多...
struct | event_goto_sleeping_t
对应USER_GOTO_SLEEPING事件 更多...
struct | event_goto_awakend_t
对应USER_GOTO_AWAKENED事件 更多...
struct | event_volume_setting_t
对应USER_VOLUME_SETTING事件 更多...
union | user_event_context_t
事件内容，共用体，根据事件类型具体处理 更多...

类型定义

typedef void(* _user_event_cb) (USER_EVENT_TYPE event, user_event_context_t *context)
事件回调函数，当用户订阅事件发生时会被调用 更多...

枚举

enum USER_EVENT_TYPE {
USER_INVALID_EVENT = 0, USER_AUDIO_PLAY_START, USER_AUDIO_PLAY_END, USER_CUSTOM_SETTING,
USER_VOLUME_SETTING, USER_GOTO_SLEEPING, USER_GOTO_AWAKENED, USER_EVENT_MAX
}
用户可订阅的事件类型 更多...
enum | AUDIO_PLAY_TYPE { AUDIO_PLAY_REPLY = 0, AUDIO_PLAY_MUSIC, AUDIO_PLAY_SKILL }
音频播放类型枚举（目前只支持AUDIO_PLAY_REPLY） 更多...
enum | EVENT_TRIGGER { EVENT_TRIGGER_ASR = 0, EVENT_TRIGGER_AUTO, EVENT_TRIGGER_USER }
事件触发来源 更多...

详细描述

类型定义说明

◆ _user_event_cb

typedef void(* _user_event_cb) (USER_EVENT_TYPE event, user_event_context_t *context)
参数
event | 事件类型
context | 事件信息

枚举类型说明

◆ AUDIO_PLAY_TYPE

enum AUDIO_PLAY_TYPE
枚举值
AUDIO_PLAY_REPLY | 回复语播报
AUDIO_PLAY_MUSIC | 音乐播放
AUDIO_PLAY_SKILL | 技能TTS回复播报

◆ EVENT_TRIGGER

enum EVENT_TRIGGER
枚举值
EVENT_TRIGGER_ASR | 语音识别指令触发
EVENT_TRIGGER_AUTO | 自动状态切换（比如超时等）
EVENT_TRIGGER_USER | 用户接口主动触发

◆ USER_EVENT_TYPE

enum USER_EVENT_TYPE
枚举值
USER_INVALID_EVENT | 错误的事件类型
USER_AUDIO_PLAY_START | 音频开始播放时发送
USER_AUDIO_PLAY_END | 音频播放完毕或被停止时发送
USER_CUSTOM_SETTING | 识别到客户自定义的识别词时发送
USER_VOLUME_SETTING | 识别到音量调节指令时发送
USER_GOTO_SLEEPING | 进入待唤醒状态时发送
USER_GOTO_AWAKENED | 进入识别状态（已唤醒）时发送


蜂鸟离线方案开发指导手册: event_audio_play_t结构体 参考

成员变量
event_audio_play_t结构体 参考
Event事件 » Event事件类型定义

对应USER_AUDIO_PLAY_START事件

#include <user_event.h>

成员变量

AUDIO_PLAY_TYPE type
音频类型
char * file_name
播放音频文件名


蜂鸟离线方案开发指导手册: event_audio_end_t结构体 参考

成员变量
event_audio_end_t结构体 参考
Event事件 » Event事件类型定义

对应USER_AUDIO_PLAY_END事件

#include <user_event.h>

成员变量

AUDIO_PLAY_TYPE type
音频类型
uni_bool is_auto
是否自动播放完毕，true：自动播放完毕，false：主动停止


蜂鸟离线方案开发指导手册: event_custom_setting_t结构体 参考

成员变量
event_custom_setting_t结构体 参考
Event事件 » Event事件类型定义

对应USER_CUSTOM_SETTING事件

#include <user_event.h>

成员变量

char * | cmd
命令词意图，对应UDP平台上用户定义脚本中的action
char * | word_str
识别到的命令词
char * | reply_files
回复语列表[1, 2, 3]，对应UDP平台上用户定义脚本中的回复语列表，在pcm_map.txt中可以找到对应关系


蜂鸟离线方案开发指导手册: event_goto_sleeping_t结构体 参考

成员变量
event_goto_sleeping_t结构体 参考
Event事件 » Event事件类型定义

对应USER_GOTO_SLEEPING事件

#include <user_event.h>

成员变量

EVENT_TRIGGER trigger
触发来源
char * | cmd
命令词意图，对应UDP平台上用户定义脚本中的action
char * | word_str
识别到的命令词
char * | reply_files
回复语列表[1, 2, 3]，对应UDP平台上用户定义脚本中的回复语列表，在pcm_map.txt中可以找到对应关系


蜂鸟离线方案开发指导手册: event_goto_awakend_t结构体 参考

成员变量
event_goto_awakend_t结构体 参考
Event事件 » Event事件类型定义

对应USER_GOTO_AWAKENED事件

#include <user_event.h>

成员变量

EVENT_TRIGGER trigger
触发来源
char * | cmd
命令词意图，对应UDP平台上用户定义脚本中的action
char * | word_str
识别到的命令词
char * | reply_files
回复语列表[1, 2, 3]，对应UDP平台上用户定义脚本中的回复语列表，在pcm_map.txt中可以找到对应关系


蜂鸟离线方案开发指导手册: event_volume_setting_t结构体 参考

成员变量
event_volume_setting_t结构体 参考
Event事件 » Event事件类型定义

对应USER_VOLUME_SETTING事件

#include <user_event.h>

成员变量

int | value
当前音量值
int | min_val
可设置最小音量值
int | max_val
可设置最大音量值
EVENT_TRIGGER trigger
触发来源
char * | cmd
命令词意图，对应UDP平台上用户定义脚本中的action
char * | word_str
识别到的命令词
char * | reply_files
回复语列表[1, 2, 3]，对应UDP平台上用户定义脚本中的回复语列表，在pcm_map.txt中可以找到对应关系


蜂鸟离线方案开发指导手册: user_event_context_t联合体 参考

成员变量
user_event_context_t联合体 参考
Event事件 » Event事件类型定义

事件内容，共用体，根据事件类型具体处理

#include <user_event.h>

成员变量

event_audio_play_t audio_play
对应USER_AUDIO_PLAY_START事件
event_audio_end_t audio_end
对应USER_AUDIO_PLAY_END事件
event_custom_setting_t custom_setting
对应USER_CUSTOM_SETTING事件
event_volume_setting_t voluem_setting
对应USER_VOLUME_SETTING事件
event_goto_sleeping_t goto_sleeping
对应USER_GOTO_SLEEPING事件
event_goto_awakend_t goto_awakend
对应USER_GOTO_AWAKENED事件


蜂鸟离线方案开发指导手册: PWM

模块
PWM

PWM接口参考user/inc/user_pwm.h 更多...

模块

PWM说明
PWM相关接口
PWM类型定义
PWM示例

详细描述


蜂鸟离线方案开发指导手册: PWM说明

PWM说明
PWM
PWM说明:
  1. 如要复用管脚的PWM功能，需要先通过tools/目录下的UniPinmuxTool工具配置对应引脚为PWM功能


蜂鸟离线方案开发指导手册: PWM相关接口

函数
PWM相关接口
PWM

函数

int | user_pwm_init (USER_PWM_NUM num, uni_u32 hz, uni_bool is_high_duty)
PWM初始化 更多...
int | user_pwm_final (USER_PWM_NUM num)
PWM反初始化 更多...
int | user_pwm_start (USER_PWM_NUM num, uni_u8 duty)
开使PWM输出 更多...
int | user_pwm_stop (USER_PWM_NUM num)
停止PWM输出 更多...
int | user_pwm_pause (USER_PWM_NUM num)
暂停PWM输出 更多...
int | user_pwm_resume (USER_PWM_NUM num)
恢复PWM输出 更多...
int | user_pwm_change_duty (USER_PWM_NUM num, uni_u8 duty)
PWM占空比切换 更多...

详细描述

函数说明

◆ user_pwm_change_duty()

int user_pwm_change_duty | ( | USER_PWM_NUM | num,
 |  | uni_u8 | duty
 | ) |  |
参数
num | PWM管脚号
duty | 占空比
返回值
0 | 操作成功
-1 | 操作失败

◆ user_pwm_final()

int user_pwm_final ( USER_PWM_NUM num )
参数
num PWM管脚号
返回值
0 | 操作成功
-1 | 操作失败

◆ user_pwm_init()

int user_pwm_init | ( | USER_PWM_NUM | num,
 |  | uni_u32 | hz,
 |  | uni_bool | is_high_duty
 | ) |  |
参数
num | PWM管脚号
hz | 频率
is_high_duty | 是否满占空比
返回值
0 | 操作成功
-1 | 操作失败

◆ user_pwm_pause()

int user_pwm_pause ( USER_PWM_NUM num )
参数
num PWM管脚号
返回值
0 | 操作成功
-1 | 操作失败

◆ user_pwm_resume()

int user_pwm_resume ( USER_PWM_NUM num )
参数
num PWM管脚号
返回值
0 | 操作成功
-1 | 操作失败

◆ user_pwm_start()

int user_pwm_start | ( | USER_PWM_NUM | num,
 |  | uni_u8 | duty
 | ) |  |
参数
num | PWM管脚号
duty | 占空比
返回值
0 | 操作成功
-1 | 操作失败

◆ user_pwm_stop()

int user_pwm_stop ( USER_PWM_NUM num )
参数
num PWM管脚号
返回值
0 | 操作成功
-1 | 操作失败


蜂鸟离线方案开发指导手册: PWM类型定义

枚举
PWM类型定义
PWM

枚举

enum USER_PWM_NUM {
PWM_NUM_0 = 0, PWM_NUM_1, PWM_NUM_2, PWM_NUM_3,
PWM_NUM_4, PWM_NUM_5, PWM_NUM_6, PWM_NUM_7,
PWM_NUM_MAX
}

详细描述

枚举类型说明

◆ USER_PWM_NUM

enum USER_PWM_NUM

PWM管脚号


蜂鸟离线方案开发指导手册: PWM示例

模块
PWM示例
PWM

模块

hb_pwm_led.c

详细描述


蜂鸟离线方案开发指导手册: hb_pwm_led.c

hb_pwm_led.c
PWM » PWM示例

可通过定义user/inc/user_config.h中的宏USER_RUN_DEMO_SELECT 为USER_DEMO_PWM_LED 运行示例程序

/**************************************************************************
* Copyright (C) 2017-2017 Unisound
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
**************************************************************************
*
* Description : hb_pwm_led.c
* Author : wufangfang@unisound.com
* Date : 2020.04.26
*
**************************************************************************/
#include "user_gpio.h"
#include "user_pwm_led.h"
#define TAG "hb_pwm_led"
#define PWM_LED_GPIO_NUM PWM_NUM_3 //配置pinmux 55 X_UART1_CTS：pwm3_tmr
static void _pwm_led_process(void *args) {
LED_BRIGHT_LEVEL level = BRIGHT_LEVEL_0;
while (1) {
user_pwm_led_set_brightness(PWM_LED_GPIO_NUM, level);
level += 1;
if (level >= BRIGHT_LEVEL_MAX) {
level = BRIGHT_LEVEL_0;
}
//uni_sleep(1);
}
}
static Result _create_pwm_led_thread(void) {
struct thread_param param;
uni_pthread_t pid;
uni_memset(&param, 0, sizeof(param));
param.stack_size = STACK_SMALL_SIZE;
param.th_priority = OS_PRIORITY_LOW;
uni_strncpy(param.task_name, "pwm_led", sizeof(param.task_name) - 1);
if (0 != uni_pthread_create(&pid, &param,
_pwm_led_process, NULL)) {
LOGE(TAG, "create thread failed");
return E_FAILED;
}
uni_pthread_detach(pid);
return E_OK;
}
int hb_pwm_led(void) {
if (0 != user_pwm_led_init(PWM_LED_GPIO_NUM)) {
LOGE(TAG, "user_pwm_led_init failed.");
return -1;
}
if (E_OK != _create_pwm_led_thread()) {
LOGE(TAG, "_create_pwm_led_thread failed.");
user_pwm_led_final(PWM_LED_GPIO_NUM);
return -1;
}
return 0;
}


蜂鸟离线方案开发指导手册: 方案示例

模块
方案示例

示例代码位于目录user/src/examples/下 更多...

模块

智能电风扇
智能管家

详细描述


蜂鸟离线方案开发指导手册: 智能电风扇

智能电风扇
方案示例

可通过定义user/inc/user_config.h中的宏USER_RUN_DEMO_SELECT 为USER_DEMO_SMART_AC 运行示例程序

/**************************************************************************
* Copyright (C) 2017-2017 Unisound
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
**************************************************************************
*
* Description : hb_smart_ac.c
* Author : wufangfang@unisound.com
* Date : 2020.04.03
*
**************************************************************************/
#include "unione.h"
#include "ac_device_simulator.h"
#include "user_asr.h"
#include "user_player.h"
#define TAG "smart_ac"
static char g_power_off_reply[32] = {0};
static int _ac_power_replay(event_custom_setting_t *setting) {
eAcSate state = eACSTATE_UNKONWN;
eAcMode mode = eACMODE_UNKONWN;
if (0 == uni_strcmp(setting->cmd, "acPowerOn")) {
state = AcDeviceSetState(eACSTATE_ON);
} else if (0 == uni_strcmp(setting->cmd, "acPowerOff")) {
state = AcDeviceSetState(eACSTATE_OFF);
} else {
LOGE(TAG, "unknown cmd: %s", setting->cmd);
return -1;
}
LOGT(TAG, "AC power state: %d", state);
if (eACSTATE_OFF == state) {
uni_strncpy(g_power_off_reply, setting->reply_files, sizeof(g_power_off_reply) - 1);
return user_asr_goto_sleep();
} else if (eACSTATE_ON == state) {
mode = AcDeviceGetMode();
switch (mode) {
case eACMODE_COOL:
return user_player_reply_list_num(setting->reply_files, 0);
case eACMODE_HAT:
return user_player_reply_list_num(setting->reply_files, 1);
case eACMODE_DRY:
return user_player_reply_list_num(setting->reply_files, 2);
case eACMODE_FAN:
return user_player_reply_list_num(setting->reply_files, 3);
case eACMODE_AUTO:
return user_player_reply_list_num(setting->reply_files, 4);
default:
LOGE(TAG, "Unknown mode: %d", mode);
break;
}
} else {
LOGE(TAG, "invalid AC state: %d", state);
}
return -1;
}
static int _ac_off_replay(void) {
#ifdef DEFAULT_PCM_WAKEUP
return user_player_reply_list_num(DEFAULT_PCM_WAKEUP, 0);
#else
return user_player_reply_list_random(HI_AC_OFF);
#endif
}
static int _ac_temp_change_replay(char *reply_files, eAcTemp temp) {
eAcMode mode = AcDeviceGetMode();
int diff = temp - eACTEMP_16;
if (temp <= eACTEMP_20) {
if (eACMODE_COOL == mode) {
return user_player_reply_list_num(reply_files, diff * 2 + 1);
}
return user_player_reply_list_num(reply_files, diff * 2);
}
return user_player_reply_list_num(reply_files, diff + 5);
}
static int _ac_temp_replay(event_custom_setting_t *setting) {
eAcSate state = AcDeviceGetState();
eAcTemp temp = eACTEMP_UNKONWN;
eAcMode mode = eACMODE_UNKONWN;
if (eACSTATE_ON != state) {
return _ac_off_replay();
}
if (0 == uni_strcmp(setting->cmd, "acTemp16")) {
temp = AcDeviceSetTemp(eACTEMP_16);
} else if (0 == uni_strcmp(setting->cmd, "acTemp17")) {
temp = AcDeviceSetTemp(eACTEMP_17);
} else if (0 == uni_strcmp(setting->cmd, "acTemp18")) {
temp = AcDeviceSetTemp(eACTEMP_18);
} else if (0 == uni_strcmp(setting->cmd, "acTemp19")) {
temp = AcDeviceSetTemp(eACTEMP_19);
} else if (0 == uni_strcmp(setting->cmd, "acTemp20")) {
temp = AcDeviceSetTemp(eACTEMP_20);
} else if (0 == uni_strcmp(setting->cmd, "acTemp21")) {
temp = AcDeviceSetTemp(eACTEMP_21);
} else if (0 == uni_strcmp(setting->cmd, "acTemp22")) {
temp = AcDeviceSetTemp(eACTEMP_22);
} else if (0 == uni_strcmp(setting->cmd, "acTemp23")) {
temp = AcDeviceSetTemp(eACTEMP_23);
} else if (0 == uni_strcmp(setting->cmd, "acTemp24")) {
temp = AcDeviceSetTemp(eACTEMP_24);
} else if (0 == uni_strcmp(setting->cmd, "acTemp25")) {
temp = AcDeviceSetTemp(eACTEMP_25);
} else if (0 == uni_strcmp(setting->cmd, "acTemp26")) {
temp = AcDeviceSetTemp(eACTEMP_26);
} else if (0 == uni_strcmp(setting->cmd, "acTemp27")) {
temp = AcDeviceSetTemp(eACTEMP_27);
} else if (0 == uni_strcmp(setting->cmd, "acTemp28")) {
temp = AcDeviceSetTemp(eACTEMP_28);
} else if (0 == uni_strcmp(setting->cmd, "acTemp29")) {
temp = AcDeviceSetTemp(eACTEMP_29);
} else if (0 == uni_strcmp(setting->cmd, "acTemp30")) {
temp = AcDeviceSetTemp(eACTEMP_30);
} else if (0 == uni_strcmp(setting->cmd, "acTemp31")) {
temp = AcDeviceSetTemp(eACTEMP_31);
} else if (0 == uni_strcmp(setting->cmd, "acTemp32")) {
temp = AcDeviceSetTemp(eACTEMP_32);
} else if (0 == uni_strcmp(setting->cmd, "acTempInc")) {
temp = AcDeviceTempInc();
return _ac_temp_change_replay(setting->reply_files, temp);
} else if (0 == uni_strcmp(setting->cmd, "acTempDec")) {
temp = AcDeviceTempDec();
return _ac_temp_change_replay(setting->reply_files, temp);
} else if (0 == uni_strcmp(setting->cmd, "acTempIncBig")) {
temp = AcDeviceTempIncBig();
return _ac_temp_change_replay(setting->reply_files, temp);
} else if (0 == uni_strcmp(setting->cmd, "acTempDecBig")) {
temp = AcDeviceTempDecBig();
return _ac_temp_change_replay(setting->reply_files, temp);
} else {
LOGE(TAG, "unknown cmd: %s", setting->cmd);
return -1;
}
LOGT(TAG, "AC temp state: %d", temp);
if (temp <= eACTEMP_20) {
mode = AcDeviceGetMode();
if (eACMODE_COOL == mode) {
return user_player_reply_list_num(setting->reply_files, 1);
}
return user_player_reply_list_num(setting->reply_files, 0);
}
return user_player_reply_list_random(setting->reply_files);
}
static int _ac_wind_replay(event_custom_setting_t *setting) {
eAcSate state = AcDeviceGetState();
eAcWindSpeed speed = eACWINDSPEED_UNKONWN;
eAcMode mode = AcDeviceGetMode();
if (eACSTATE_ON != state) {
return _ac_off_replay();
}
if (0 == uni_strcmp(setting->cmd, "acWindHigh")) {
if (eACMODE_DRY == mode) {
return user_player_reply_list_num(setting->reply_files, 1);
}
speed = AcDeviceSetWindSpeed(eACWINDSPEED_HIGH);
return user_player_reply_list_num(setting->reply_files, 0);
} else if (0 == uni_strcmp(setting->cmd, "acWindMid")) {
if (eACMODE_DRY == mode) {
return user_player_reply_list_num(setting->reply_files, 1);
}
speed = AcDeviceSetWindSpeed(eACWINDSPEED_MID);
return user_player_reply_list_num(setting->reply_files, 0);
} else if (0 == uni_strcmp(setting->cmd, "acWindLow")) {
if (eACMODE_DRY == mode) {
return user_player_reply_list_num(setting->reply_files, 1);
}
speed = AcDeviceSetWindSpeed(eACWINDSPEED_LOW);
return user_player_reply_list_num(setting->reply_files, 0);
} else if (0 == uni_strcmp(setting->cmd, "acWindMax")) {
speed = AcDeviceSetWindSpeed(eACWINDSPEED_HIGH);
} else if (0 == uni_strcmp(setting->cmd, "acWindMin")) {
speed = AcDeviceSetWindSpeed(eACWINDSPEED_LOW);
} else if (0 == uni_strcmp(setting->cmd, "acWindMute")) {
speed = AcDeviceSetWindSpeed(eACWINDSPEED_LOW);
} else if (0 == uni_strcmp(setting->cmd, "acWindAuto")) {
speed = AcDeviceSetWindSpeed(eACWINDSPEED_MID);
} else if (0 == uni_strcmp(setting->cmd, "acWindInc")) {
speed = AcDeviceGetWindSpeed();
if (eACWINDSPEED_HIGH == speed) {
return user_player_reply_list_num(setting->reply_files, 1);
}
speed = AcDeviceWindSpeedInc();
return user_player_reply_list_num(setting->reply_files, 0);
} else if (0 == uni_strcmp(setting->cmd, "acWindDec")) {
speed = AcDeviceGetWindSpeed();
if (eACWINDSPEED_LOW == speed) {
return user_player_reply_list_num(setting->reply_files, 1);
}
speed = AcDeviceWindSpeedDec();
return user_player_reply_list_num(setting->reply_files, 0);
} else {
LOGE(TAG, "unknown cmd: %s", setting->cmd);
return -1;
}
LOGT(TAG, "AC speed state: %d", speed);
return user_player_reply_list_random(setting->reply_files);
}
static int _ac_mode_replay(event_custom_setting_t *setting) {
eAcSate state = AcDeviceGetState();
eAcMode mode = eACMODE_UNKONWN;
if (eACSTATE_ON != state) {
return _ac_off_replay();
}
if (0 == uni_strcmp(setting->cmd, "acModeCool")) {
mode = AcDeviceSetMode(eACMODE_COOL);
} else if (0 == uni_strcmp(setting->cmd, "acModeDry")) {
mode = AcDeviceSetMode(eACMODE_DRY);
} else if (0 == uni_strcmp(setting->cmd, "acModeFan")) {
mode = AcDeviceSetMode(eACMODE_FAN);
} else if (0 == uni_strcmp(setting->cmd, "acModeHat")) {
mode = AcDeviceSetMode(eACMODE_HAT);
} else {
LOGE(TAG, "unknown cmd: %s", setting->cmd);
return -1;
}
LOGT(TAG, "AC mode state: %d", mode);
return user_player_reply_list_random(setting->reply_files);
}
static int _ac_swing_replay(event_custom_setting_t *setting) {
eAcSate state = AcDeviceGetState();
eAcSwing swing = AcDeviceGetSwingState();
if (eACSTATE_ON != state) {
return _ac_off_replay();
}
if (0 == uni_strcmp(setting->cmd, "acSwingCrossOn")) {
swing = AcDeviceSetSwingState(eACSWING_CROSS_ON);
} else if (0 == uni_strcmp(setting->cmd, "acSwingCrossOff")) {
swing = AcDeviceSetSwingState(eACSWING_CROSS_OFF);
} else if (0 == uni_strcmp(setting->cmd, "acSwingVertOn")) {
swing = AcDeviceSetSwingState(eACSWING_VERT_ON);
} else if (0 == uni_strcmp(setting->cmd, "acSwingVertOff")) {
swing = AcDeviceSetSwingState(eACSWING_VERT_OFF);
} else if (0 == uni_strcmp(setting->cmd, "acSwingOn")) {
swing = AcDeviceSetSwingState(eACSWING_ALL_ON);
} else if (0 == uni_strcmp(setting->cmd, "acSwingOff")) {
swing = AcDeviceSetSwingState(eACSWING_ALL_OFF);
} else {
LOGE(TAG, "unknown cmd: %s", setting->cmd);
return -1;
}
LOGT(TAG, "AC swing state: %d", swing);
return user_player_reply_list_random(setting->reply_files);
}
static int _ac_sleep_replay(event_custom_setting_t *setting) {
eAcSate state = AcDeviceGetState();
uni_bool is_on = AcDeviceGetSkillState(eACSKILL_SLEEP);
eAcMode mode = AcDeviceGetMode();
if (eACSTATE_ON != state) {
return _ac_off_replay();
}
if (0 == uni_strcmp(setting->cmd, "acSleepOn")) {
is_on = AcDeviceSetSkillState(eACSKILL_SLEEP, true);
if (eACMODE_COOL == mode) {
return user_player_reply_list_num(setting->reply_files, 1);
}
return user_player_reply_list_num(setting->reply_files, 0);
} else if (0 == uni_strcmp(setting->cmd, "acSleepOff")) {
is_on = AcDeviceSetSkillState(eACSKILL_SLEEP, false);
} else {
LOGE(TAG, "unknown cmd: %s", setting->cmd);
return -1;
}
LOGT(TAG, "AC sleep state: %d", is_on);
return user_player_reply_list_random(setting->reply_files);
}
static int _ac_humidifier_replay(event_custom_setting_t *setting) {
eAcSate state = AcDeviceGetState();
uni_bool is_on = AcDeviceGetSkillState(eACSKILL_HUMID);
if (eACSTATE_ON != state) {
return _ac_off_replay();
}
if (0 == uni_strcmp(setting->cmd, "acHumidifierOn")) {
is_on = AcDeviceSetSkillState(eACSKILL_HUMID, true);
} else if (0 == uni_strcmp(setting->cmd, "acHumidifierOff")) {
is_on = AcDeviceSetSkillState(eACSKILL_HUMID, false);
} else {
LOGE(TAG, "unknown cmd: %s", setting->cmd);
return -1;
}
LOGT(TAG, "AC humidifier state: %d", is_on);
return user_player_reply_list_random(setting->reply_files);
}
static int _ac_screen_replay(event_custom_setting_t *setting) {
eAcSate state = AcDeviceGetState();
uni_bool is_on = AcDeviceGetSkillState(eACSKILL_SCREEN);
if (eACSTATE_ON != state) {
return _ac_off_replay();
}
if (0 == uni_strcmp(setting->cmd, "acScreenOn")) {
is_on = AcDeviceSetSkillState(eACSKILL_SCREEN, true);
} else if (0 == uni_strcmp(setting->cmd, "acScreenOff")) {
is_on = AcDeviceSetSkillState(eACSKILL_SCREEN, false);
} else {
LOGE(TAG, "unknown cmd: %s", setting->cmd);
return -1;
}
LOGT(TAG, "AC screen state: %d", is_on);
return user_player_reply_list_random(setting->reply_files);
}
static int _ac_energy_replay(event_custom_setting_t *setting) {
eAcSate state = AcDeviceGetState();
uni_bool is_on = AcDeviceGetSkillState(eACSKILL_ENERGY);
if (eACSTATE_ON != state) {
return _ac_off_replay();
}
if (0 == uni_strcmp(setting->cmd, "acEnergyOn")) {
is_on = AcDeviceSetSkillState(eACSKILL_ENERGY, true);
} else if (0 == uni_strcmp(setting->cmd, "acEnergyOff")) {
is_on = AcDeviceSetSkillState(eACSKILL_ENERGY, false);
} else {
LOGE(TAG, "unknown cmd: %s", setting->cmd);
return -1;
}
LOGT(TAG, "AC screen state: %d", is_on);
return user_player_reply_list_random(setting->reply_files);
}
static void _custom_setting_cb(USER_EVENT_TYPE event,
user_event_context_t *context) {
event_custom_setting_t *setting = NULL;
if (context) {
setting = &context->custom_setting;
if (0 == uni_strncmp(setting->cmd, "acPower", uni_strlen("acPower"))) {
_ac_power_replay(setting);
} else if (0 == uni_strncmp(setting->cmd, "acTemp", uni_strlen("acTemp"))) {
_ac_temp_replay(setting);
} else if (0 == uni_strncmp(setting->cmd, "acMode", uni_strlen("acMode"))) {
_ac_mode_replay(setting);
} else if (0 == uni_strncmp(setting->cmd, "acWind", uni_strlen("acWind"))) {
_ac_wind_replay(setting);
} else if (0 == uni_strncmp(setting->cmd, "acSwing", uni_strlen("acSwing"))) {
_ac_swing_replay(setting);
} else if (0 == uni_strncmp(setting->cmd, "acSleep", uni_strlen("acSleep"))) {
_ac_sleep_replay(setting);
} else if (0 == uni_strncmp(setting->cmd, "acHumidifier", uni_strlen("acHumidifier"))) {
_ac_humidifier_replay(setting);
} else if (0 == uni_strncmp(setting->cmd, "acScreen", uni_strlen("acScreen"))) {
_ac_screen_replay(setting);
} else if (0 == uni_strncmp(setting->cmd, "acEnergy", uni_strlen("acEnergy"))) {
_ac_energy_replay(setting);
} else {
/* don't reply if other setting command */
}
}
}
static void _goto_awakend_cb(USER_EVENT_TYPE event,
user_event_context_t *context) {
event_goto_awakend_t *awakend = NULL;
if (context) {
awakend = &context->goto_awakend;
if (EVENT_TRIGGER_ASR == awakend->trigger) {
LOGT(TAG, "ASR command: %s -> %s -> %s", awakend->cmd, awakend->word_str, awakend->reply_files);
} else {
LOGT(TAG, "External command: %s", awakend->reply_files);
}
if (awakend->reply_files) {
if(eACSTATE_ON == AcDeviceGetState()) {
user_player_reply_list_num(awakend->reply_files, 1);
} else {
user_player_reply_list_num(awakend->reply_files, 0);
}
}
}
}
static void _goto_sleeping_cb (USER_EVENT_TYPE event,
user_event_context_t *context) {
event_goto_sleeping_t *sleeping = NULL;
if (context) {
sleeping = &context->goto_sleeping;
if (EVENT_TRIGGER_ASR == sleeping->trigger) {
LOGT(TAG, "ASR command: %s -> %s -> %s", sleeping->cmd, sleeping->word_str,
sleeping->reply_files);
} else {
LOGT(TAG, "External command: %s", sleeping->reply_files);
}
if (sleeping->reply_files) {
if(EVENT_TRIGGER_USER == sleeping->trigger) {
user_player_reply_list_random(g_power_off_reply);
} else {
user_player_reply_list_random(sleeping->reply_files);
}
}
}
}
static void _volume_setting_cb(USER_EVENT_TYPE event,
user_event_context_t *context) {
event_volume_setting_t *setting = NULL;
if (context) {
setting = &context->voluem_setting;
LOGT(TAG, "user command: %s", setting->cmd);
if (0 == uni_strcmp(setting->cmd, "volumeUpUni")) {
if (setting->value >= setting->max_val) {
user_player_reply_list_num(setting->reply_files, 1);
} else {
user_player_set_volume_up();
user_player_reply_list_num(setting->reply_files, 0);
}
} else if (0 == uni_strcmp(setting->cmd, "volumeDownUni")) {
if (setting->value <= setting->min_val) {
user_player_reply_list_num(setting->reply_files, 1);
} else {
user_player_set_volume_down();
user_player_reply_list_num(setting->reply_files, 0);
}
} else {
LOGE(TAG, "Unknown cmd: %s", setting->cmd);
}
}
}
static void _register_event_callback(void) {
user_event_subscribe_event(USER_CUSTOM_SETTING, _custom_setting_cb);
user_event_subscribe_event(USER_GOTO_AWAKENED, _goto_awakend_cb);
user_event_subscribe_event(USER_GOTO_SLEEPING, _goto_sleeping_cb);
user_event_subscribe_event(USER_VOLUME_SETTING, _volume_setting_cb);
}
int hb_smart_ac(void) {
AcDeviceInit();
_register_event_callback();
return 0;
}


蜂鸟离线方案开发指导手册: 智能管家

智能管家
方案示例

可通过定义user/inc/user_config.h中的宏USER_RUN_DEMO_SELECT 为USER_DEMO_HOUSEKEEPER 运行示例程序

/**************************************************************************
* Copyright (C) 2017-2017 Unisound
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
**************************************************************************
*
* Description : hb_housekeeper.c
* Author : wufangfang@unisound.com
* Date : 2020.04.13
*
**************************************************************************/
#include "unione.h"
#include "user_asr.h"
#include "user_player.h"
#include "user_uart_hb1688.h"
#include "user_flash.h"
#include "user_uni_ucp.h"
#include "ArcLib.h"
#define TAG "hb_housekeeoer"
#define KEY_WORD_LEN_MAX 64
#define REPLAY_MATCH_OK "116" // 匹配成功
#define REPLAY_MATCH_FAIL "117" // 匹配失败
#define REPLAY_LEARN_OK "119" // 学习成功
#define REPLAY_LEARN_FAIL "120" // 学习失败
#define REPLAY_CODE_OK "187" // 对码成功
#define REPLAY_CODE_FAIL "188" // 对码失败
#define BLOB_KEY_IS_MATCH "AC_IS_MATCH" // save in flash key, value means 0: nerver match AC RC, 1: have matched
#define BLOB_TYPE_IS_MATCH uni_u32
#define BLOB_KEY_AC_TYPE "AC_TYPE" // save in flash key, value means number get AC RC code from code lib
#define BLOB_TYPE_AC_TYPE int
#define BLOB_KEY_ADR_VAR "ADR_VAR"
#define AC_TMP_MIN 16
#define AC_TMP_MAX 32
typedef enum {
HB1688_LEARN_NONE = 0,
HB1688_AC_MATCH,
HB1688_LEARN_ARC,
HB1688_LEARN_URC,
HB1688_LEARN_CODE,
HB1688_LEARN_MAX
}HB1688_LEARN_MODE;
typedef enum {
HB1688_ADR_MODE = 0,
HB1688_ADR_TMP,
HB1688_ADR_FANLEV,
HB1688_ADR_FANDIR,
HB1688_ADR_AFANDIR,
HB1688_ADR_MFANDIR,
HB1688_ADR_NONE_06,
HB1688_ADR_TIMEON,
HB1688_ADR_TIMEOFF,
HB1688_ADR_KEYVAL,
HB1688_ADR_SYSFLAG,
HB1688_ADR_NONE_11,
HB1688_ADR_TMSTATE3,
HB1688_ADR_NONE_13,
HB1688_ADR_NONE_14,
HB1688_ADR_NONE_15,
HB1688_ADR_MAX
}HB1688_ADR_TYPE;
typedef struct {
char key_word[KEY_WORD_LEN_MAX];
uni_u8 code[HB1688_LRC_LEN];
uni_u8 len;
}hb1688_lrc_code_t;
typedef struct {
uni_bool is_learn;
HB1688_LEARN_MODE learn_mode;
hb1688_lrc_code_t lrc_code;
}hb_housekeeper_context_t;
typedef struct {
const char *cmd_str;
uni_bool is_block;
uni_u8 cmd_num_h;
uni_u8 cmd_num_l;
}mcu_cmd_map_t;
static uni_bool g_speaker_mute = false;
static hb_housekeeper_context_t g_hk_context = {false, HB1688_LEARN_NONE, {{0}, {0}, 0}};
static unsigned char g_adr_var[HB1688_ADR_MAX] = {0};
static mcu_cmd_map_t g_mcu_cmd_map[] = {
{ "volumeMaxUni", true, 0x00, 0x00 },
{ "volumeMidUni", true, 0x00, 0x01 },
{ "volumeMinUni", true, 0x00, 0x02 },
{ "speakerMute", true, 0x00, 0x03 },
{ "speakerUnmMute", true, 0x00, 0x04 },
{ "learnMode", true, 0x00, 0x05 },
{ "learnModeExit", true, 0x00, 0x06 },
{ "userGoOut", true, 0x00, 0x07 },
{ "userGoHome", true, 0x00, 0x08 },
{ "userGoToBed", true, 0x00, 0x09 },
{ "userGetUp", true, 0x00, 0x0A },
{ "rcAcMatch", true, 0x00, 0x0B },
{ "acTurnOn", true, 0x00, 0x0C },
{ "acTurnOff", true, 0x00, 0x0D },
{ "acModeCool", true, 0x00, 0x0E },
{ "acModeHeat", true, 0x00, 0x0F },
{ "acModeBlower", true, 0x00, 0x10 },
{ "acModeMoisture", true, 0x00, 0x11 },
{ "acFanSpeedHigh", true, 0x00, 0x12 },
{ "acFanSpeedMid", true, 0x00, 0x13 },
{ "acFanSpeedLow", true, 0x00, 0x14 },
{ "acFanSpeedAuto", true, 0x00, 0x15 },
{ "acFanSweptOn", true, 0x00, 0x16 },
{ "acFanSweptOff", true, 0x00, 0x17 },
{ "acDegrees16", true, 0x00, 0x18 },
{ "acDegrees17", true, 0x00, 0x19 },
{ "acDegrees18", true, 0x00, 0x1A },
{ "acDegrees19", true, 0x00, 0x1B },
{ "acDegrees20", true, 0x00, 0x1C },
{ "acDegrees21", true, 0x00, 0x1D },
{ "acDegrees22", true, 0x00, 0x1E },
{ "acDegrees23", true, 0x00, 0x1F },
{ "acDegrees24", true, 0x00, 0x20 },
{ "acDegrees25", true, 0x00, 0x21 },
{ "acDegrees26", true, 0x00, 0x22 },
{ "acDegrees27", true, 0x00, 0x23 },
{ "acDegrees28", true, 0x00, 0x24 },
{ "acDegrees29", true, 0x00, 0x25 },
{ "acDegrees30", true, 0x00, 0x26 },
{ "rcLearnKey", true, 0x00, 0x27 },
{ "tvTurnOn", true, 0x00, 0x28 },
{ "tvTurnOff", true, 0x00, 0x29 },
{ "tvChannelPre", true, 0x00, 0x2A },
{ "tvChannelNext", true, 0x00, 0x2B },
{ "tvVolumeUp", true, 0x00, 0x2C },
{ "tvVolumeDown", true, 0x00, 0x2D },
{ "tvSpeakerMute", true, 0x00, 0x2E },
{ "tvSpeakerUnmute", true, 0x00, 0x2F },
{ "tvSettings", true, 0x00, 0x30 },
{ "tvMenu", true, 0x00, 0x31 },
{ "tvEnter", true, 0x00, 0x32 },
{ "tvReturn", true, 0x00, 0x33 },
{ "tvSwitchLeft", true, 0x00, 0x34 },
{ "tvSwitchRight", true, 0x00, 0x35 },
{ "tvSwitchUp", true, 0x00, 0x36 },
{ "tvSwitchDown", true, 0x00, 0x37 },
{ "tvSwicthSingle", true, 0x00, 0x38 },
{ "stbTurnOn", true, 0x00, 0x39 },
{ "stbTurnOff", true, 0x00, 0x3A },
{ "lampLivingOn", true, 0x00, 0x3B },
{ "lampLivingOff", true, 0x00, 0x3C },
{ "downLightOn", true, 0x00, 0x3D },
{ "downLightOff", true, 0x00, 0x3E },
{ "tapeLightOn", true, 0x00, 0x3F },
{ "tapeLightOff", true, 0x00, 0x40 },
{ "lampDiningOn", true, 0x00, 0x41 },
{ "lampDiningOff", true, 0x00, 0x42 },
{ "lampBedroomOn", true, 0x00, 0x43 },
{ "lampBedroomOff", true, 0x00, 0x44 },
{ "lampBedsideOn", true, 0x00, 0x45 },
{ "lampBedsideOff", true, 0x00, 0x46 },
{ "lampNightOn", true, 0x00, 0x47 },
{ "lampNightOff", true, 0x00, 0x48 },
{ "lampAllOn", true, 0x00, 0x49 },
{ "lampAllOff", true, 0x00, 0x4A },
{ "curtainsOpen", true, 0x00, 0x4B },
{ "curtainsClose", true, 0x00, 0x4C },
{ "curtainsCancel", true, 0x00, 0x4D },
{ "codeLampLiving", true, 0x00, 0x4E },
{ "codeDownLight", true, 0x00, 0x4F },
{ "codeTapeLight", true, 0x00, 0x50 },
{ "codeLampDining", true, 0x00, 0x51 },
{ "codeLampBedroom", true, 0x00, 0x52 },
{ "codeLampBedside", true, 0x00, 0x53 },
{ "codeLampNight", true, 0x00, 0x54 },
{ "codeCurtains", true, 0x00, 0x55 }
};
static int _send_cmd_uart_protocol(const char *cmd) {
int i = 0;
uni_u16 ucp_cmd = 0x0000;
for (i = 0; i < sizeof(g_mcu_cmd_map)/sizeof(mcu_cmd_map_t); i++) {
if (0 == uni_strcmp(cmd, g_mcu_cmd_map[i].cmd_str)) {
LOGT(TAG, "UART protcol: %s : (%s) 0x%02x [0x%02x]",
g_mcu_cmd_map[i].cmd_str, g_mcu_cmd_map[i].is_block ? "block" : "unblock",
g_mcu_cmd_map[i].cmd_num_h, g_mcu_cmd_map[i].cmd_num_l);
ucp_cmd = g_mcu_cmd_map[i].cmd_num_h;
ucp_cmd = (ucp_cmd << 8) | g_mcu_cmd_map[i].cmd_num_l;
return user_uni_ucp_send(ucp_cmd, NULL, 0, g_mcu_cmd_map[i].is_block);
}
}
return 0;
}
static void _ext_dev_ucp_recv(uni_u16 cmd, char *payload, int len) {
if (0x0056 == cmd) {
/* code learn success */
user_player_play(AUDIO_PLAY_REPLY, REPLAY_CODE_OK);
} else if (0x0057 == cmd) {
/* code learn failed */
user_player_play(AUDIO_PLAY_REPLY, REPLAY_CODE_FAIL);
}
}
static void _hb1688_lrc_learn_recv(uni_bool is_ok, uni_u8 *buf, uni_u8 len) {
BLOB_TYPE_IS_MATCH is_ac_match = 0;
BLOB_TYPE_AC_TYPE ac_type = 0;
unsigned int ac_group_num[10] = {0};
switch (g_hk_context.learn_mode) {
case HB1688_AC_MATCH:
if (is_ok) {
/* match use HB1688 lib*/
Arc_Identification((unsigned const char *)buf, ac_group_num, 0x01);
LOGT(TAG, "ac_group_num = %d", ac_group_num[0]);
if (ac_group_num[0] > 0) {
/* save match type to flash */
is_ac_match = 1;
ac_type = ac_group_num[0];
user_flash_set_env_blob(BLOB_KEY_IS_MATCH, &is_ac_match,
sizeof(is_ac_match));
user_flash_set_env_blob(BLOB_KEY_AC_TYPE, &ac_type,
sizeof(BLOB_TYPE_AC_TYPE));
user_player_play(AUDIO_PLAY_REPLY, REPLAY_MATCH_OK);
} else {
user_player_play(AUDIO_PLAY_REPLY, REPLAY_MATCH_FAIL);
}
} else {
user_player_play(AUDIO_PLAY_REPLY, REPLAY_MATCH_FAIL);
}
break;
case HB1688_LEARN_ARC:
if (is_ok) {
is_ac_match = 0;
user_flash_set_env_blob(BLOB_KEY_IS_MATCH, &is_ac_match,
sizeof(is_ac_match));
user_flash_set_env_blob(g_hk_context.lrc_code.key_word, buf, len);
user_player_play(AUDIO_PLAY_REPLY, REPLAY_LEARN_OK);
} else {
user_player_play(AUDIO_PLAY_REPLY, REPLAY_LEARN_FAIL);
}
break;
case HB1688_LEARN_URC:
if (is_ok) {
user_flash_set_env_blob(g_hk_context.lrc_code.key_word, buf, len);
user_player_play(AUDIO_PLAY_REPLY, REPLAY_LEARN_OK);
} else {
user_player_play(AUDIO_PLAY_REPLY, REPLAY_LEARN_FAIL);
}
break;
default:
break;
}
}
static int _speaker_mute_process(event_custom_setting_t *setting) {
if (0 == uni_strcmp(setting->cmd, "speakerMute")) {
if (0 == _send_cmd_uart_protocol(setting->cmd)) {
g_speaker_mute = true;
user_player_reply_list_random(setting->reply_files);
} else {
user_player_speaker_mute();
}
} else {
g_speaker_mute = false;
user_player_speaker_unmute();
if (0 == _send_cmd_uart_protocol(setting->cmd)) {
user_player_reply_list_random(setting->reply_files);
}
}
return 0;
}
static void _goto_ac_match_mode(void) {
switch (g_hk_context.learn_mode) {
case HB1688_LEARN_CODE:
/* TODO: exit code learn mode, don't support on HB-M */
break;
default:
break;
}
g_hk_context.lrc_code.len = 0;
g_hk_context.learn_mode = HB1688_AC_MATCH;
}
static void _goto_arc_learn_mode(void) {
switch (g_hk_context.learn_mode) {
case HB1688_LEARN_CODE:
/* TODO: exit code learn mode, don't support on HB-M */
break;
default:
break;
}
g_hk_context.lrc_code.len = 0;
g_hk_context.learn_mode = HB1688_LEARN_ARC;
}
static void _goto_urc_learn_mode(void) {
switch (g_hk_context.learn_mode) {
case HB1688_LEARN_CODE:
/* TODO: exit code learn mode, don't support on HB-M */
break;
default:
break;
}
g_hk_context.lrc_code.len = 0;
g_hk_context.learn_mode = HB1688_LEARN_URC;
}
static void _goto_code_learn_mode(void) {
switch (g_hk_context.learn_mode) {
case HB1688_AC_MATCH:
user_uart_hb1688_learn_exit();
break;
case HB1688_LEARN_ARC:
user_uart_hb1688_learn_exit();
break;
case HB1688_LEARN_URC:
user_uart_hb1688_learn_exit();
break;
default:
break;
}
g_hk_context.lrc_code.len = 0;
g_hk_context.learn_mode = HB1688_LEARN_CODE;
}
static void _enter_learn_mode(void) {
LOGT(TAG, "enter learn_mode: %d", g_hk_context.learn_mode);
switch (g_hk_context.learn_mode) {
case HB1688_AC_MATCH:
user_uart_hb1688_arc_learn(_hb1688_lrc_learn_recv);;
break;
case HB1688_LEARN_ARC:
user_uart_hb1688_arc_learn(_hb1688_lrc_learn_recv);;
break;
case HB1688_LEARN_URC:
user_uart_hb1688_urc_learn(_hb1688_lrc_learn_recv);;
break;
case HB1688_LEARN_CODE:
/* TODO: enter code learn mode, don't support on HB-M */
break;
default:
break;
}
}
static void _exit_learn_mode(void) {
if (HB1688_LEARN_NONE != g_hk_context.learn_mode) {
user_uart_hb1688_learn_exit();
/* TODO: exit code learn mode, don't support on HB-M */
g_hk_context.lrc_code.len = 0;
g_hk_context.learn_mode = HB1688_LEARN_NONE;
}
}
static int _learn_mode_process(event_custom_setting_t *setting) {
if (0 == uni_strcmp(setting->cmd, "learnModeExit")) {
_exit_learn_mode();
g_hk_context.is_learn = false;
} else {
g_hk_context.is_learn = true;
g_hk_context.learn_mode = HB1688_LEARN_NONE;
}
if (0 == _send_cmd_uart_protocol(setting->cmd)) {
user_player_reply_list_random(setting->reply_files);
}
return 0;
}
static int _work_mode_process(event_custom_setting_t *setting) {
if (0 == _send_cmd_uart_protocol(setting->cmd)) {
user_player_reply_list_random(setting->reply_files);
}
return 0;
}
static int _code_learn_mode_process(event_custom_setting_t *setting) {
if (!g_hk_context.is_learn) {
LOGE(TAG, "It's not on learn mode.");
return -1;
}
_goto_code_learn_mode();
if (0 == _send_cmd_uart_protocol(setting->cmd)) {
user_player_reply_list_num(setting->reply_files, 0);
}
return 0;
}
static int _lrc_learn_mode_process(event_custom_setting_t *setting) {
if (!g_hk_context.is_learn) {
LOGE(TAG, "It's not on learn mode.");
return -1;
}
/* default to URC learn mode, will switch to ARC mode if user say AC command */
_goto_urc_learn_mode();
if (0 == _send_cmd_uart_protocol(setting->cmd)) {
user_player_reply_list_num(setting->reply_files, 0);
}
return 0;
}
static int _ac_match_process(event_custom_setting_t *setting) {
if (!g_hk_context.is_learn) {
LOGE(TAG, "It's not on learn mode.");
return -1;
}
_goto_ac_match_mode();
_enter_learn_mode();
if (0 == _send_cmd_uart_protocol(setting->cmd)) {
user_player_reply_list_num(setting->reply_files, 0);
}
return 0;
}
static int _ac_key_learn_process(event_custom_setting_t *setting) {
/* default to URC learn mode, will switch to ARC mode if user say AC command */
if (HB1688_LEARN_ARC != g_hk_context.learn_mode
&& HB1688_LEARN_URC != g_hk_context.learn_mode) {
LOGE(TAG, "not in HB1688_LEARN_ARC or HB1688_LEARN_URC mode.");
return -1;
}
uni_strncpy(g_hk_context.lrc_code.key_word, setting->cmd,
sizeof(g_hk_context.lrc_code.key_word) - 1);
LOGT(TAG, "key_word: %s", g_hk_context.lrc_code.key_word);
_goto_arc_learn_mode();
_enter_learn_mode();
/* don't send protocol to MCU on learn mode */
user_player_reply_list_num(setting->reply_files, 0);
return 0;
}
static void _adr_var_ac_tmp_set(unsigned char tmp) {
if (g_adr_var[HB1688_ADR_TMP] < (tmp - AC_TMP_MIN)) {
g_adr_var[HB1688_ADR_KEYVAL] = 1;
} else if (g_adr_var[HB1688_ADR_TMP] > (tmp - AC_TMP_MIN)) {
g_adr_var[HB1688_ADR_KEYVAL] = 2;
} else {
g_adr_var[HB1688_ADR_KEYVAL] = 0xff;
}
g_adr_var[HB1688_ADR_TMP] = (tmp - AC_TMP_MIN);
}
static int _flush_adr_var(const char *cmd) {
if (0 == strcmp(cmd, "acTurnOn")) {
g_adr_var[HB1688_ADR_KEYVAL] = 0; //电源键
g_adr_var[HB1688_ADR_SYSFLAG] = 0x20 & g_adr_var[HB1688_ADR_SYSFLAG]; //清除灯光以外的所有功能标志
g_adr_var[HB1688_ADR_SYSFLAG] = 0x01 | g_adr_var[HB1688_ADR_SYSFLAG]; //开机标志
} else if (0 == strcmp(cmd, "acTurnOff")) {
g_adr_var[HB1688_ADR_KEYVAL] = 0; //电源键
g_adr_var[HB1688_ADR_SYSFLAG] = 0x20 & g_adr_var[HB1688_ADR_SYSFLAG]; //清除灯光以外的所有功能标志
} else if (0 == strcmp(cmd, "acModeCool")) {
g_adr_var[HB1688_ADR_KEYVAL] = 3; //模式键
g_adr_var[HB1688_ADR_MODE] = 1; //制冷模式
} else if (0 == strcmp(cmd, "acModeHeat")) {
g_adr_var[HB1688_ADR_KEYVAL] = 3; //模式键
g_adr_var[HB1688_ADR_MODE] = 4; //制热模式
} else if (0 == strcmp(cmd, "acModeBlower")) {
g_adr_var[HB1688_ADR_KEYVAL] = 3; //模式键
g_adr_var[HB1688_ADR_MODE] = 3; //送风模式
} else if (0 == strcmp(cmd, "acModeMoisture")) {
g_adr_var[HB1688_ADR_KEYVAL] = 3; //模式键
g_adr_var[HB1688_ADR_MODE] = 2; //除湿模式
} else if (0 == strcmp(cmd, "acFanSpeedHigh")) {
g_adr_var[HB1688_ADR_KEYVAL] = 4; //风量键
g_adr_var[HB1688_ADR_FANLEV] = 3; //高速风
} else if (0 == strcmp(cmd, "acFanSpeedMid")) {
g_adr_var[HB1688_ADR_KEYVAL] = 4; //风量键
g_adr_var[HB1688_ADR_FANLEV] = 2; //中速风
} else if (0 == strcmp(cmd, "acFanSpeedLow")) {
g_adr_var[HB1688_ADR_KEYVAL] = 4; //风量键
g_adr_var[HB1688_ADR_FANLEV] = 1; //低速风
} else if (0 == strcmp(cmd, "acFanSpeedAuto")) {
g_adr_var[HB1688_ADR_KEYVAL] = 4; //风量键
g_adr_var[HB1688_ADR_FANLEV] = 0; //自动风
} else if (0 == strcmp(cmd, "acFanSweptOn")) {
g_adr_var[HB1688_ADR_KEYVAL] = 5; //自动风向
if (g_adr_var[HB1688_ADR_FANDIR] < 9) {
g_adr_var[HB1688_ADR_FANDIR] += 1;
} else {
g_adr_var[HB1688_ADR_FANDIR] = 0;
}
g_adr_var[HB1688_ADR_AFANDIR] = g_adr_var[HB1688_ADR_FANDIR];
g_adr_var[HB1688_ADR_MFANDIR] = 0; //清除手动风向
} else if (0 == strcmp(cmd, "acFanSweptOff")) {
g_adr_var[HB1688_ADR_KEYVAL] = 6; //手动风向
if (g_adr_var[HB1688_ADR_FANDIR] < 9) {
g_adr_var[HB1688_ADR_FANDIR] += 1;
} else {
g_adr_var[HB1688_ADR_FANDIR] = 0;
}
g_adr_var[HB1688_ADR_AFANDIR] = 0; //清除自动风向
g_adr_var[HB1688_ADR_MFANDIR] = g_adr_var[HB1688_ADR_FANDIR];
} else if (0 == strcmp(cmd, "acDegrees16")) {
_adr_var_ac_tmp_set(16);
} else if (0 == strcmp(cmd, "acDegrees17")) {
_adr_var_ac_tmp_set(17);
} else if (0 == strcmp(cmd, "acDegrees18")) {
_adr_var_ac_tmp_set(18);
} else if (0 == strcmp(cmd, "acDegrees19")) {
_adr_var_ac_tmp_set(19);
} else if (0 == strcmp(cmd, "acDegrees20")) {
_adr_var_ac_tmp_set(20);
} else if (0 == strcmp(cmd, "acDegrees21")) {
_adr_var_ac_tmp_set(21);
} else if (0 == strcmp(cmd, "acDegrees22")) {
_adr_var_ac_tmp_set(22);
} else if (0 == strcmp(cmd, "acDegrees23")) {
_adr_var_ac_tmp_set(23);
} else if (0 == strcmp(cmd, "acDegrees24")) {
_adr_var_ac_tmp_set(24);
} else if (0 == strcmp(cmd, "acDegrees25")) {
_adr_var_ac_tmp_set(25);
} else if (0 == strcmp(cmd, "acDegrees26")) {
_adr_var_ac_tmp_set(26);
} else if (0 == strcmp(cmd, "acDegrees27")) {
_adr_var_ac_tmp_set(27);
} else if (0 == strcmp(cmd, "acDegrees28")) {
_adr_var_ac_tmp_set(28);
} else if (0 == strcmp(cmd, "acDegrees29")) {
_adr_var_ac_tmp_set(29);
} else if (0 == strcmp(cmd, "acDegrees30")) {
_adr_var_ac_tmp_set(30);
} else {
LOGE(TAG, "unknown cmd: %s", cmd);
return -1;
}
return 0;
}
static int _ac_key_use_process(event_custom_setting_t *setting) {
BLOB_TYPE_IS_MATCH is_ac_match = 0;
BLOB_TYPE_AC_TYPE ac_type = 0;
int save_len = 0;
/* send protocol in any case */
if (0 == _send_cmd_uart_protocol(setting->cmd)) {
user_player_reply_list_num(setting->reply_files, 0);
}
/* is AC match or not */
user_flash_get_env_blob(BLOB_KEY_IS_MATCH, &is_ac_match,
sizeof(is_ac_match), &save_len);
if (save_len != sizeof(is_ac_match)) {
LOGE(TAG, "cannot found %s in flash", BLOB_KEY_IS_MATCH);
return -1;
}
if (is_ac_match) {
user_flash_get_env_blob(BLOB_KEY_AC_TYPE, &ac_type,
sizeof(BLOB_TYPE_AC_TYPE), &save_len);
if (save_len != sizeof(BLOB_TYPE_AC_TYPE)) {
LOGE(TAG, "cannot found %s in flash", BLOB_KEY_AC_TYPE);
return -1;
}
/* map cmd and ARC var */
user_flash_get_env_blob(BLOB_KEY_ADR_VAR, g_adr_var,
sizeof(g_adr_var), &save_len);
if (save_len != sizeof(g_adr_var)) {
LOGE(TAG, "cannot found %s in flash.", BLOB_KEY_ADR_VAR);
return -1;
}
if (0 == _flush_adr_var(setting->cmd)) {
/* get ARC code from code lib and send to UART */
Read_ARC_IR_Data(ac_type, g_adr_var, 0x01);
user_flash_set_env_blob(BLOB_KEY_ADR_VAR, g_adr_var, sizeof(g_adr_var));
user_uart_hb1688_arc_send(ArcIRdataBuff, HB1688_LRC_LEN);
} else {
LOGE(TAG, "cannot map cmd: %s", setting->cmd);
}
} else {
/* find LRC code from flash by cmd */
user_flash_get_env_blob(setting->cmd, g_hk_context.lrc_code.code,
sizeof(g_hk_context.lrc_code.code),
&save_len);
if (save_len <= 0) {
LOGE(TAG, "cannot found %s in flash", setting->cmd);
return -1;
}
if (save_len > sizeof(g_hk_context.lrc_code.code)) {
save_len = sizeof(g_hk_context.lrc_code.code);
}
g_hk_context.lrc_code.len = (uni_u8)save_len;
user_uart_hb1688_arc_send(g_hk_context.lrc_code.code,
g_hk_context.lrc_code.len);
}
return 0;
}
static int _ac_command_process(event_custom_setting_t *setting) {
LOGT(TAG, "is_learn = %d", g_hk_context.is_learn);
if (g_hk_context.is_learn) {
return _ac_key_learn_process(setting);
} else {
return _ac_key_use_process(setting);
}
}
static int _tv_key_learn_process(event_custom_setting_t *setting) {
/* default to URC learn mode, will switch to ARC mode if user say AC command */
if (HB1688_LEARN_ARC != g_hk_context.learn_mode
&& HB1688_LEARN_URC != g_hk_context.learn_mode) {
LOGE(TAG, "not in HB1688_LEARN_ARC or HB1688_LEARN_URC mode.");
return -1;
}
uni_strncpy(g_hk_context.lrc_code.key_word, setting->cmd,
sizeof(g_hk_context.lrc_code.key_word) - 1);
_goto_urc_learn_mode();
_enter_learn_mode();
/* don't send protocol to MCU on learn mode */
user_player_reply_list_num(setting->reply_files, 0);
return 0;
}
static int _tv_key_use_process(event_custom_setting_t *setting) {
int save_len = 0;
/* send protocol in any case */
if (0 == _send_cmd_uart_protocol(setting->cmd)) {
user_player_reply_list_num(setting->reply_files, 0);
}
/* find LRC code from flash by cmd */
user_flash_get_env_blob(setting->cmd, g_hk_context.lrc_code.code,
sizeof(g_hk_context.lrc_code.code),
&save_len);
if (save_len <= 0) {
LOGE(TAG, "cannot found %s in flash", setting->cmd);
return -1;
}
if (save_len > sizeof(g_hk_context.lrc_code.code)) {
save_len = sizeof(g_hk_context.lrc_code.code);
}
g_hk_context.lrc_code.len = (uni_u8)save_len;
user_uart_hb1688_urc_send(g_hk_context.lrc_code.code,
g_hk_context.lrc_code.len);
return 0;
}
static int _tv_command_process(event_custom_setting_t *setting) {
if (g_hk_context.is_learn) {
return _tv_key_learn_process(setting);
} else {
return _tv_key_use_process(setting);
}
}
static int _stb_command_process(event_custom_setting_t *setting) {
if (g_hk_context.is_learn) {
return _tv_key_learn_process(setting);
} else {
return _tv_key_use_process(setting);
}
}
static void _custom_setting_cb(USER_EVENT_TYPE event,
user_event_context_t *context) {
event_custom_setting_t *setting = NULL;
if (context) {
setting = &context->custom_setting;
LOGT(TAG, "user command: %s", setting->cmd);
if (0 == uni_strncmp(setting->cmd, "speaker", uni_strlen("speaker"))) {
_speaker_mute_process(setting);
} else if (0 == uni_strncmp(setting->cmd, "learnMode", uni_strlen("learnMode"))) {
_learn_mode_process(setting);
} else if (0 == uni_strncmp(setting->cmd, "user", uni_strlen("user"))) {
_work_mode_process(setting);
} else if (0 == uni_strncmp(setting->cmd, "ac", uni_strlen("ac"))) {
_ac_command_process(setting);
} else if (0 == uni_strncmp(setting->cmd, "tv", uni_strlen("tv"))) {
_tv_command_process(setting);
} else if (0 == uni_strncmp(setting->cmd, "stb", uni_strlen("stb"))) {
_stb_command_process(setting);
} else if (0 == uni_strncmp(setting->cmd, "code", uni_strlen("code"))) {
_code_learn_mode_process(setting);
} else if (0 == uni_strcmp(setting->cmd, "rcLearnKey")) {
_lrc_learn_mode_process(setting);
} else if (0 == uni_strcmp(setting->cmd, "rcAcMatch")) {
_ac_match_process(setting);
} else {
if (0 == _send_cmd_uart_protocol(setting->cmd)) {
user_player_reply_list_random(setting->reply_files);
}
}
}
}
static void _volume_setting_cb(USER_EVENT_TYPE event,
user_event_context_t *context) {
event_volume_setting_t *setting = NULL;
if (context) {
setting = &context->voluem_setting;
LOGT(TAG, "user command: %s", setting->cmd);
if (0 == uni_strcmp(setting->cmd, "volumeMinUni")) {
user_player_set_volume_min();
if (0 == _send_cmd_uart_protocol(setting->cmd)) {
user_player_reply_list_random(setting->reply_files);
}
} else if (0 == uni_strcmp(setting->cmd, "volumeMaxUni")) {
user_player_set_volume_max();
if (0 == _send_cmd_uart_protocol(setting->cmd)) {
user_player_reply_list_random(setting->reply_files);
}
} else if (0 == uni_strcmp(setting->cmd, "volumeMidUni")) {
user_player_set_volume_mid();
if (0 == _send_cmd_uart_protocol(setting->cmd)) {
user_player_reply_list_random(setting->reply_files);
}
} else {
LOGE(TAG, "Unknown cmd: %s", setting->cmd);
}
}
}
static void _audio_play_end_cb(USER_EVENT_TYPE event,
user_event_context_t *context) {
LOGT(TAG, "g_speaker_mute = %d", g_speaker_mute);
if (g_speaker_mute) {
g_speaker_mute = false;
user_player_speaker_mute();
}
}
static void _goto_sleeping_cb (USER_EVENT_TYPE event,
user_event_context_t *context) {
event_goto_sleeping_t *sleeping = NULL;
if (context) {
sleeping = &context->goto_sleeping;
user_player_reply_list_random(sleeping->reply_files);
_exit_learn_mode();
g_hk_context.is_learn = false;
}
}
static void _register_event_callback(void) {
user_event_subscribe_event(USER_CUSTOM_SETTING, _custom_setting_cb);
user_event_subscribe_event(USER_VOLUME_SETTING, _volume_setting_cb);
user_event_subscribe_event(USER_AUDIO_PLAY_END, _audio_play_end_cb);
user_event_subscribe_event(USER_GOTO_SLEEPING, _goto_sleeping_cb);
}
static void _hb1688_version_recv(uni_bool is_ok, uni_u16 version) {
uni_u8 ver_master = version >> 8;
uni_u8 ver_major = version & 0x0f;
if (is_ok) {
LOGT(TAG, "HB1688 version: %d.%d", ver_master, ver_major);
} else {
LOGE(TAG, "Get HB1688 version failed.");
}
}
static void _init_adr_var(void) {
int save_len = 0;
user_flash_get_env_blob(BLOB_KEY_ADR_VAR, g_adr_var,
sizeof(g_adr_var), &save_len);
if (save_len != sizeof(g_adr_var)) {
g_adr_var[HB1688_ADR_MODE] = 1; //制冷模式
g_adr_var[HB1688_ADR_TMP] = 9; //25度
g_adr_var[HB1688_ADR_FANLEV] = 0; //自动
g_adr_var[HB1688_ADR_FANDIR] = 0; //自动风量清0（自动手动同按键情况）
g_adr_var[HB1688_ADR_AFANDIR] = 0; //自动风量清0（自动手动不同按键情况）
g_adr_var[HB1688_ADR_MFANDIR] = 0; //手动风向清0（自动手动不同按键情况）
g_adr_var[HB1688_ADR_NONE_06] = 0;
g_adr_var[HB1688_ADR_TIMEON] = 0; //无定时开机
g_adr_var[HB1688_ADR_TIMEOFF] = 0; //无定时关机
g_adr_var[HB1688_ADR_KEYVAL] = 0xff; //空键
g_adr_var[HB1688_ADR_SYSFLAG] = 0x00; //清零
g_adr_var[HB1688_ADR_NONE_11] = 0;
g_adr_var[HB1688_ADR_TMSTATE3] = 0; //无定时开关机
g_adr_var[HB1688_ADR_NONE_13] = 0;
g_adr_var[HB1688_ADR_NONE_14] = 0;
g_adr_var[HB1688_ADR_NONE_15] = 0;
user_flash_set_env_blob(BLOB_KEY_ADR_VAR, g_adr_var, sizeof(g_adr_var));
}
}
static void _init_ac_match_state(void) {
BLOB_TYPE_IS_MATCH is_ac_match = 0;
int save_len = 0;
user_flash_get_env_blob(BLOB_KEY_IS_MATCH, &is_ac_match,
sizeof(is_ac_match), &save_len);
if (save_len != sizeof(is_ac_match)) {
is_ac_match = 0;
user_flash_set_env_blob(BLOB_KEY_IS_MATCH, &is_ac_match,
sizeof(is_ac_match));
}
}
int hb_housekeeper(void) {
if (0 != user_uart_hb1688_init()) {
LOGE(TAG, "user_uart_hb1688_init failed.");
return -1;
}
if (0 != user_flash_init()) {
LOGE(TAG, "user_flash_init failed.");
user_uart_hb1688_final();
return -1;
}
if (0 != user_uni_ucp_init(_ext_dev_ucp_recv)) {
LOGE(TAG, "user_uni_ucp_init failed.");
user_uart_hb1688_final();
user_flash_final();
return -1;
}
user_uart_hb1688_get_version(_hb1688_version_recv);
_register_event_callback();
_init_ac_match_state();
_init_adr_var();
return 0;
}


蜂鸟离线方案开发指导手册: 结构体

结构体
这里列出了所有结构体，并附带简要说明:
C event_audio_end_t | 对应USER_AUDIO_PLAY_END事件
C event_audio_play_t | 对应USER_AUDIO_PLAY_START事件
C event_custom_setting_t | 对应USER_CUSTOM_SETTING事件
C event_goto_awakend_t | 对应USER_GOTO_AWAKENED事件
C event_goto_sleeping_t | 对应USER_GOTO_SLEEPING事件
C event_volume_setting_t | 对应USER_VOLUME_SETTING事件
C user_event_context_t | 事件内容，共用体，根据事件类型具体处理


蜂鸟离线方案开发指导手册: 结构体索引

结构体索引
e | u
e
event_audio_play_t event_goto_sleeping_t
event_custom_setting_t event_volume_setting_t
event_audio_end_t event_goto_awakend_t
u
user_event_context_t


蜂鸟离线方案开发指导手册: Z:/Hummingbird/cpu_firmware/rtt_unione_lite_app/user/inc 目录参考

  • Hummingbird
  • cpu_firmware
  • rtt_unione_lite_app
  • user
  • inc
inc 目录参考


蜂鸟离线方案开发指导手册: Z:/Hummingbird 目录参考

  • Hummingbird
Hummingbird 目录参考


蜂鸟离线方案开发指导手册: Z:/Hummingbird/cpu_firmware/rtt_unione_lite_app 目录参考

  • Hummingbird
  • cpu_firmware
  • rtt_unione_lite_app
rtt_unione_lite_app 目录参考


蜂鸟离线方案开发指导手册: Z:/doxygen/src/Hummingbird/input 目录参考

  • src
  • Hummingbird
  • input
input 目录参考


蜂鸟离线方案开发指导手册: Z:/Hummingbird/cpu_firmware/rtt_unione_lite_app/user 目录参考

  • Hummingbird
  • cpu_firmware
  • rtt_unione_lite_app
  • user
user 目录参考

目录


蜂鸟离线方案开发指导手册: Z:/doxygen/src/Hummingbird 目录参考

  • src
  • Hummingbird
Hummingbird 目录参考


蜂鸟离线方案开发指导手册: Z:/Hummingbird/cpu_firmware 目录参考

  • Hummingbird
  • cpu_firmware
cpu_firmware 目录参考


蜂鸟离线方案开发指导手册: 成员变量

这里列出了所有文档化的结构体和联合体的成员变量，并附带结构或联合所属的文件:
  • audio_end : user_event_context_t
  • audio_play : user_event_context_t
  • cmd : event_custom_setting_t , event_goto_awakend_t , event_goto_sleeping_t , event_volume_setting_t
  • custom_setting : user_event_context_t
  • file_name : event_audio_play_t
  • goto_awakend : user_event_context_t
  • goto_sleeping : user_event_context_t
  • is_auto : event_audio_end_t
  • max_val : event_volume_setting_t
  • min_val : event_volume_setting_t
  • reply_files : event_custom_setting_t , event_goto_awakend_t , event_goto_sleeping_t , event_volume_setting_t
  • trigger : event_goto_awakend_t , event_goto_sleeping_t , event_volume_setting_t
  • type : event_audio_end_t , event_audio_play_t
  • value : event_volume_setting_t
  • voluem_setting : user_event_context_t
  • word_str : event_custom_setting_t , event_goto_awakend_t , event_goto_sleeping_t , event_volume_setting_t


蜂鸟离线方案开发指导手册: 成员变量 - 变量

  • audio_end : user_event_context_t
  • audio_play : user_event_context_t
  • cmd : event_custom_setting_t , event_goto_awakend_t , event_goto_sleeping_t , event_volume_setting_t
  • custom_setting : user_event_context_t
  • file_name : event_audio_play_t
  • goto_awakend : user_event_context_t
  • goto_sleeping : user_event_context_t
  • is_auto : event_audio_end_t
  • max_val : event_volume_setting_t
  • min_val : event_volume_setting_t
  • reply_files : event_custom_setting_t , event_goto_awakend_t , event_goto_sleeping_t , event_volume_setting_t
  • trigger : event_goto_awakend_t , event_goto_sleeping_t , event_volume_setting_t
  • type : event_audio_end_t , event_audio_play_t
  • value : event_volume_setting_t
  • voluem_setting : user_event_context_t
  • word_str : event_custom_setting_t , event_goto_awakend_t , event_goto_sleeping_t , event_volume_setting_t


蜂鸟离线方案开发指导手册: 相关页面

相关页面
这里列出了所有相关页面:
1、简介
2、产品说明
3、产品创建
4、烧录固件
5、搭建开发环境
6、软件架构
7、二次开发


蜂鸟离线方案开发指导手册: Z:/Hummingbird/cpu_firmware/rtt_unione_lite_app/user/inc/unione.h 源文件

  • Hummingbird
  • cpu_firmware
  • rtt_unione_lite_app
  • user
  • inc
unione.h
1 /**************************************************************************
2 * Copyright (C) 2017-2017 Unisound
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License along
15 * with this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
17 **************************************************************************
18 *
19 * Description : unione.h
20 * Author : wufangfang@unisound.com
21 * Date : 2020.04.02
22 *
23 **************************************************************************/
24 #ifndef USER_INC_UNIONE_H_
25 #define USER_INC_UNIONE_H_
26
27 #ifdef __cplusplus
28 extern "C" {
29 #endif
30
31 #include "uni_iot.h"
32 #include "uni_log.h"
33 #include "uni_hal_adc.h"
34 #include "uni_hal_gpio.h"
35 #include "uni_hal_i2c.h"
36 #include "uni_hal_pwm.h"
37 #include "uni_pcm_default.h"
38 #include "user_config.h"
39
40 #ifdef __cplusplus
41 }
42 #endif
43 #endif
44


蜂鸟离线方案开发指导手册: Z:/Hummingbird/cpu_firmware/rtt_unione_lite_app/user/inc/user_adc.h 源文件

  • Hummingbird
  • cpu_firmware
  • rtt_unione_lite_app
  • user
  • inc
user_adc.h
1 /**************************************************************************
2 * Copyright (C) 2017-2017 Unisound
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License along
15 * with this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
17 **************************************************************************
18 *
19 * Description : user_adc.h
20 * Author : yuanshifeng@unisound.com
21 * Date : 2020.04.24
22 *
23 **************************************************************************/
24 #ifndef USER_INC_USER_ADC_H_
25 #define USER_INC_USER_ADC_H_
26
27 #ifdef __cplusplus
28 extern "C" {
29 #endif
30
31 #include "unione.h"
32
36 typedef enum {
38 ADC_AIN2 = 2,
39 ADC_AIN3 = 3
40 }ADC_AIN_SEL;
41
51 int user_adc_init(void);
52
59 int user_adc_get_value(ADC_AIN_SEL adc_ain, int *value);
60
66 int user_adc_start(void);
67
72 int user_adc_final(void);
73
76 #ifdef __cplusplus
77 }
78 #endif
79 #endif
80


蜂鸟离线方案开发指导手册: Z:/Hummingbird/cpu_firmware/rtt_unione_lite_app/user/inc/user_asr.h 源文件

  • Hummingbird
  • cpu_firmware
  • rtt_unione_lite_app
  • user
  • inc
user_asr.h
1 /**************************************************************************
2 * Copyright (C) 2017-2017 Unisound
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License along
15 * with this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
17 **************************************************************************
18 *
19 * Description : user_asr.h
20 * Author : wufangfang@unisound.com
21 * Date : 2020.04.07
22 *
23 **************************************************************************/
24 #ifndef USER_INC_USER_ASR_H_
25 #define USER_INC_USER_ASR_H_
26
27 #ifdef __cplusplus
28 extern "C" {
29 #endif
30
31 #include "unione.h"
32
41 int user_asr_goto_sleep(void);
42
48 int user_asr_goto_awakend(void);
49
55 int user_asr_recognize_enable(void);
56
62 int user_asr_recognize_disable(void);
63
70 int user_asr_word_enable(const char *word);
71
78 int user_asr_word_disable(const char *word);
79
82 #ifdef __cplusplus
83 }
84 #endif
85 #endif
86


蜂鸟离线方案开发指导手册: Z:/Hummingbird/cpu_firmware/rtt_unione_lite_app/user/inc/user_config.h 源文件

  • Hummingbird
  • cpu_firmware
  • rtt_unione_lite_app
  • user
  • inc
user_config.h
1 #ifndef USER_INC_USER_CONFIG_H_
2 #define USER_INC_USER_CONFIG_H_
3
9 #define GPIO_OUT_DEF_VAL 1
10
15 #define USER_AUDIO_VOL_LEVEL 5
16 #define USER_AUDIO_VOL_MIN 5
17 #define USER_AUDIO_VOL_MAX 100
18 #define USER_AUDIO_VOL_MID 50
19 #define USER_AUDIO_VOL_DEF 50
20
25 #define USE_UNIONE_PROTOCOL 1
26 #define OPEN_ASR_EVENT_UCP 1
27 #define UNI_UART_DEVICE_NUM 2
28 #define UNI_UART_BAUD_RATE 115200
29 #define UNI_UART_PARITY 0
30 #define UNI_UART_STOP_BIT 1
31 #define UNI_UART_DATA_BIT 8
32
37 #define USER_UART_DEVICE_NUM 3
38 #define USER_UART_BAUD_RATE 19200
39 #define USER_UART_PARITY 0
40 #define USER_UART_STOP_BIT 1
41 #define USER_UART_DATA_BIT 8
42
51 #define MULTI_DIALOGUE_MODE 1
52
56 #define WAKEUP_INTERRUPT_MODE 0
57
67 #define USER_RUN_DEMO 0
68 #define USER_DEMO_SMART_AC 1
70 #define USER_DEMO_HOUSEKEEPER 2
71 #define USER_DEMO_KEY_WAKEUP 3
72 #define USER_DEMO_ADC_CTRL 4
73 #define USER_DEMO_TIMERS 5
74 #define USER_DEMO_BUZZER 6
75 #define USER_DEMO_PWM_LED 7
76 #define USER_DEMO_I2C_TIME 8
77 #define USER_DEMO_SPI_LCD 9
78 #define USER_DEMO_UART 10
79 #define USER_DEMO_UART_UCP 11
80 #define USER_DEMO_PLAYER 12
81 #define USER_DEMO_FLASH 13
82 #define USER_DEMO_ASR_CONTROL 14
83 #define USER_DEMO_NOISE_CTRL 15
84 #define USER_RUN_DEMO_SELECT USER_DEMO_SMART_AC
85
89 #endif
90


蜂鸟离线方案开发指导手册: Z:/Hummingbird/cpu_firmware/rtt_unione_lite_app/user/inc/user_event.h 源文件

  • Hummingbird
  • cpu_firmware
  • rtt_unione_lite_app
  • user
  • inc
user_event.h
1 /**************************************************************************
2 * Copyright (C) 2017-2017 Unisound
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License along
15 * with this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
17 **************************************************************************
18 *
19 * Description : user_event.h
20 * Author : wufangfang@unisound.com
21 * Date : 2020.04.03
22 *
23 **************************************************************************/
24 #ifndef USER_INC_USER_EVENT_H_
25 #define USER_INC_USER_EVENT_H_
26
27 #ifdef __cplusplus
28 extern "C" {
29 #endif
30
31 #include "unione.h"
32
37 typedef enum {
38 USER_INVALID_EVENT = 0,
39 USER_AUDIO_PLAY_START,
40 USER_AUDIO_PLAY_END,
41 USER_CUSTOM_SETTING,
42 USER_VOLUME_SETTING,
43 USER_GOTO_SLEEPING,
44 USER_GOTO_AWAKENED,
45 USER_EVENT_MAX
46 }USER_EVENT_TYPE;
47
49 typedef enum {
50 AUDIO_PLAY_REPLY = 0,
51 AUDIO_PLAY_MUSIC,
52 AUDIO_PLAY_SKILL
53 }AUDIO_PLAY_TYPE;
54
56 typedef struct {
57 AUDIO_PLAY_TYPE type;
58 char *file_name;
59 }event_audio_play_t;
60
62 typedef struct {
63 AUDIO_PLAY_TYPE type;
64 uni_bool is_auto;
65 }event_audio_end_t;
66
68 typedef struct {
69 char *cmd;
70 char *word_str;
71 char *reply_files;
72 }event_custom_setting_t;
73
75 typedef enum {
76 EVENT_TRIGGER_ASR = 0,
77 EVENT_TRIGGER_AUTO,
78 EVENT_TRIGGER_USER
79 }EVENT_TRIGGER;
80
82 typedef struct {
83 EVENT_TRIGGER trigger;
84 char *cmd;
85 char *word_str;
86 char *reply_files;
87 }event_goto_sleeping_t;
88
90 typedef struct {
91 EVENT_TRIGGER trigger;
92 char *cmd;
93 char *word_str;
94 char *reply_files;
95 }event_goto_awakend_t;
96
98 typedef struct {
99 int value;
100 int min_val;
101 int max_val;
102 EVENT_TRIGGER trigger;
103 char *cmd;
104 char *word_str;
105 char *reply_files;
106 }event_volume_setting_t;
107
109 typedef union {
110 event_audio_play_t audio_play;
111 event_audio_end_t audio_end;
112 event_custom_setting_t custom_setting;
113 event_volume_setting_t voluem_setting;
114 event_goto_sleeping_t goto_sleeping;
115 event_goto_awakend_t goto_awakend;
116 }user_event_context_t;
117
122 typedef void (*_user_event_cb)(USER_EVENT_TYPE event,
123 user_event_context_t *context);
136 int user_event_subscribe_event(USER_EVENT_TYPE event,
137 _user_event_cb cb);
138
144 int user_event_clear_observers(void);
145
151 _user_event_cb user_event_get_observer(USER_EVENT_TYPE event);
152
155 #ifdef __cplusplus
156 }
157 #endif
158 #endif
159
160


蜂鸟离线方案开发指导手册: Z:/Hummingbird/cpu_firmware/rtt_unione_lite_app/user/inc/user_file.h 源文件

  • Hummingbird
  • cpu_firmware
  • rtt_unione_lite_app
  • user
  • inc
user_file.h


蜂鸟离线方案开发指导手册: Z:/Hummingbird/cpu_firmware/rtt_unione_lite_app/user/inc/user_flash.h 源文件

  • Hummingbird
  • cpu_firmware
  • rtt_unione_lite_app
  • user
  • inc
user_flash.h
1 /**************************************************************************
2 * Copyright (C) 2017-2017 Unisound
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License along
15 * with this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
17 **************************************************************************
18 *
19 * Description : user_flash.h
20 * Author : wufangfang@unisound.com
21 * Date : 2020.04.14
22 *
23 **************************************************************************/
24
25 #ifndef USER_INC_USER_FLASH_H_
26 #define USER_INC_USER_FLASH_H_
27
28 #ifdef __cplusplus
29 extern "C" {
30 #endif
31
32 #include "unione.h"
33
42 int user_flash_init(void);
43
47 void user_flash_final(void);
48
58 int user_flash_set_env_blob(const char *key,
59 const void *value_buf, int buf_len);
60
72 int user_flash_get_env_blob(const char *key,
73 void *value_buf, int buf_len,
74 int *save_len);
75
78 #ifdef __cplusplus
79 }
80 #endif
81 #endif
82
83
84


蜂鸟离线方案开发指导手册: Z:/Hummingbird/cpu_firmware/rtt_unione_lite_app/user/inc/user_gpio.h 源文件

  • Hummingbird
  • cpu_firmware
  • rtt_unione_lite_app
  • user
  • inc
user_gpio.h
1 /**************************************************************************
2 * Copyright (C) 2017-2017 Unisound
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License along
15 * with this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
17 **************************************************************************
18 *
19 * Description : user_gpio.h
20 * Author : wufangfang@unisound.com
21 * Date : 2020.04.24
22 *
23 **************************************************************************/
24 #ifndef USER_INC_USER_GPIO_H_
25 #define USER_INC_USER_GPIO_H_
26
27 #ifdef __cplusplus
28 extern "C" {
29 #endif
30
31 #include "unione.h"
32
37 typedef enum {
38 GPIO_NUM_0 = 0,
39 GPIO_NUM_1,
40 GPIO_NUM_2,
41 GPIO_NUM_3,
42 GPIO_NUM_4,
43 GPIO_NUM_5,
44 GPIO_NUM_6,
45 GPIO_NUM_7,
46 GPIO_NUM_8,
47 GPIO_NUM_9,
48 GPIO_NUM_10,
49 GPIO_NUM_11,
50 GPIO_NUM_12,
51 GPIO_NUM_13,
52 GPIO_NUM_14,
53 GPIO_NUM_15,
54 GPIO_NUM_16,
55 GPIO_NUM_17,
56 GPIO_NUM_18,
57 GPIO_NUM_19,
58 GPIO_NUM_20,
59 GPIO_NUM_21,
60 GPIO_NUM_22,
61 GPIO_NUM_23,
62 GPIO_NUM_24,
63 GPIO_NUM_25,
64 GPIO_NUM_26,
65 GPIO_NUM_27,
66 GPIO_NUM_28,
67 GPIO_NUM_29,
68 GPIO_NUM_30,
69 GPIO_NUM_31,
70 GPIO_NUM_MAX
71 }GPIO_NUMBER;
72
74 typedef enum {
75 GPIO_MODE_IN = 0,
76 GPIO_MODE_OUT,
77 GPIO_MODE_ADC,
78 GPIO_MODE_PWM,
79 GPIO_MODE_UART,
80 GPIO_MODE_I2C,
81 GPIO_MODE_SPI,
82 GPIO_MODE_MAX
83 }GPIO_MODE;
84
86 typedef enum {
87 GPIO_PULL_UP,
88 GPIO_PULL_DOWN,
89 GPIO_NOT_PULL
90 }GPIO_PULL_MODE;
91
93 typedef enum {
94 GPIO_INT_NEG_EDGE,
95 GPIO_INT_POS_EDGE,
96 GPIO_INT_BOTH_EDGE,
97 GPIO_INT_HIGH_LEVEL,
98 GPIO_INT_LOW_LEVEL,
99 GPIO_INT_MAX
100 }GPIO_INT_TYPE;
101
106 typedef void (*_gpio_interrupt_cb)(GPIO_NUMBER num, uni_bool is_high);
117 int user_gpio_init(void);
118
122 void user_gpio_final(void);
123
131 int user_gpio_set_mode(GPIO_NUMBER num, GPIO_MODE mode);
132
140 int user_gpio_set_pull_mode(GPIO_NUMBER num, GPIO_PULL_MODE mode);
141
149 int user_gpio_set_value(GPIO_NUMBER num, int val);
150
157 int user_gpio_get_value(GPIO_NUMBER num);
158
164 int user_gpio_interrupt_enable(void);
165
171 int user_gpio_interrupt_disable(void);
172
181 int user_gpio_set_interrupt(GPIO_NUMBER num, GPIO_INT_TYPE type,
182 _gpio_interrupt_cb cb);
183
190 int user_gpio_clear_interrupt(GPIO_NUMBER num);
191
194 #ifdef __cplusplus
195 }
196 #endif
197 #endif


蜂鸟离线方案开发指导手册: Z:/Hummingbird/cpu_firmware/rtt_unione_lite_app/user/inc/user_main.h 源文件

  • Hummingbird
  • cpu_firmware
  • rtt_unione_lite_app
  • user
  • inc
user_main.h
1 /**************************************************************************
2 * Copyright (C) 2017-2017 Unisound
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License along
15 * with this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
17 **************************************************************************
18 *
19 * Description : user_main.h
20 * Author : wufangfang@unisound.com
21 * Date : 2020.04.03
22 *
23 **************************************************************************/
24 #ifndef USER_INC_USER_MAIN_H_
25 #define USER_INC_USER_MAIN_H_
26
27 #ifdef __cplusplus
28 extern "C" {
29 #endif
30
31 #include "unione.h"
32
33 int user_main(void);
34
35 void user_exit(void);
36
37 #ifdef __cplusplus
38 }
39 #endif
40 #endif
41
42
43


蜂鸟离线方案开发指导手册: Z:/Hummingbird/cpu_firmware/rtt_unione_lite_app/user/inc/user_player.h 源文件

  • Hummingbird
  • cpu_firmware
  • rtt_unione_lite_app
  • user
  • inc
user_player.h
1 /**************************************************************************
2 * Copyright (C) 2017-2017 Unisound
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License along
15 * with this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
17 **************************************************************************
18 *
19 * Description : user_player.h
20 * Author : wufangfang@unisound.com
21 * Date : 2020.04.07
22 *
23 **************************************************************************/
24 #ifndef USER_INC_USER_PLAYER_H_
25 #define USER_INC_USER_PLAYER_H_
26
27 #ifdef __cplusplus
28 extern "C" {
29 #endif
30
31 #include "unione.h"
32 #include "user_event.h"
33
44 int user_player_play(AUDIO_PLAY_TYPE type, const char *file);
45
53 int user_player_reply_list_num(const char *file_list, int num);
54
61 int user_player_reply_list_random(const char *file_list);
62
69 int user_player_stop(AUDIO_PLAY_TYPE type);
70
74 int user_player_set_volume_min(void);
75
79 int user_player_set_volume_max(void);
80
84 int user_player_set_volume_mid(void);
85
89 int user_player_set_volume_up(void);
90
94 int user_player_set_volume_down(void);
95
99 int user_player_speaker_mute(void);
100
104 int user_player_speaker_unmute(void);
105
108 #ifdef __cplusplus
109 }
110 #endif
111 #endif
112


蜂鸟离线方案开发指导手册: Z:/Hummingbird/cpu_firmware/rtt_unione_lite_app/user/inc/user_power.h 源文件

  • Hummingbird
  • cpu_firmware
  • rtt_unione_lite_app
  • user
  • inc
user_power.h


蜂鸟离线方案开发指导手册: Z:/Hummingbird/cpu_firmware/rtt_unione_lite_app/user/inc/user_pwm.h 源文件

  • Hummingbird
  • cpu_firmware
  • rtt_unione_lite_app
  • user
  • inc
user_pwm.h
1 /**************************************************************************
2 * Copyright (C) 2017-2017 Unisound
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License along
15 * with this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
17 **************************************************************************
18 *
19 * Description : user_pwm.h
20 * Author : wufangfang@unisound.com
21 * Date : 2020.04.26
22 *
23 **************************************************************************/
24 #ifndef USER_INC_USER_PWM_H_
25 #define USER_INC_USER_PWM_H_
26
27 #ifdef __cplusplus
28 extern "C" {
29 #endif
30
31 #include "unione.h"
32
36 typedef enum {
37 PWM_NUM_0 = 0,
38 PWM_NUM_1,
39 PWM_NUM_2,
40 PWM_NUM_3,
41 PWM_NUM_4,
42 PWM_NUM_5,
43 PWM_NUM_6,
44 PWM_NUM_7,
45 PWM_NUM_MAX
46 } USER_PWM_NUM;
47
59 int user_pwm_init(USER_PWM_NUM num, uni_u32 hz, uni_bool is_high_duty);
60
67 int user_pwm_final(USER_PWM_NUM num);
68
76 int user_pwm_start(USER_PWM_NUM num, uni_u8 duty);
77
84 int user_pwm_stop(USER_PWM_NUM num);
85
92 int user_pwm_pause(USER_PWM_NUM num);
93
100 int user_pwm_resume(USER_PWM_NUM num);
101
109 int user_pwm_change_duty(USER_PWM_NUM num, uni_u8 duty);
110
113 #ifdef __cplusplus
114 }
115 #endif
116
117 #endif


蜂鸟离线方案开发指导手册: Z:/Hummingbird/cpu_firmware/rtt_unione_lite_app/user/inc/user_record.h 源文件

  • Hummingbird
  • cpu_firmware
  • rtt_unione_lite_app
  • user
  • inc
user_record.h


蜂鸟离线方案开发指导手册: Z:/Hummingbird/cpu_firmware/rtt_unione_lite_app/user/inc/user_timer.h 源文件

  • Hummingbird
  • cpu_firmware
  • rtt_unione_lite_app
  • user
  • inc
user_timer.h
1 /**************************************************************************
2 * Copyright (C) 2020-2020 Unisound
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License along
15 * with this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
17 **************************************************************************
18 *
19 * Description : user_timer.h
20 * Author : liuwenzheng@unisound.com
21 * Date : 2020.04.21
22 *
23 **************************************************************************/
24 #ifndef USER_INC_USER_TIMER_H_
25 #define USER_INC_USER_TIMER_H_
26
27 #ifdef __cplusplus
28 extern "C" {
29 #endif
30
31 #include "unione.h"
32
36 typedef enum TIMER_IDX {
37 eTIMER_SYS = 0, /*for os sys ticks*/
38 eTIMER2 = 1,
39 eTIMER3 = 2,
40 eTIMER_SOFT = 100
41 }eTIMER_IDX;
42
47 typedef void(*usr_timer_callback)(eTIMER_IDX idx);
48
61 int user_timer_init(eTIMER_IDX idx, uint32_t usec, usr_timer_callback cb);
62
67 void user_timer_start(eTIMER_IDX idx);
68
73 void user_timer_pause(eTIMER_IDX idx);
74
79 void user_timer_resume(eTIMER_IDX idx);
80
83 #ifdef __cplusplus
84 }
85 #endif
86
87 #endif /*USER_INC_USER_TIMER_H_*/
88


蜂鸟离线方案开发指导手册: Z:/Hummingbird/cpu_firmware/rtt_unione_lite_app/user/inc/user_uart.h 源文件

  • Hummingbird
  • cpu_firmware
  • rtt_unione_lite_app
  • user
  • inc
user_uart.h
1 /**************************************************************************
2 * Copyright (C) 2017-2017 Unisound
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License along
15 * with this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
17 **************************************************************************
18 *
19 * Description : user_uart.h
20 * Author : wufangfang@unisound.com
21 * Date : 2020.04.14
22 *
23 **************************************************************************/
24 #ifndef USER_INC_USER_UART_H_
25 #define USER_INC_USER_UART_H_
26
27 #ifdef __cplusplus
28 extern "C" {
29 #endif
30
31 #include "unione.h"
32
41 typedef void (*_user_uart_recv)(char *buf, int len);
42
49 int user_uart_init(_user_uart_recv cb_recv);
50
54 void user_uart_final(void);
55
63 int user_uart_send(char *buf, int len);
64
67 #ifdef __cplusplus
68 }
69 #endif
70 #endif
71
72


蜂鸟离线方案开发指导手册: Z:/Hummingbird/cpu_firmware/rtt_unione_lite_app/user/inc/user_uni_ucp.h 源文件

  • Hummingbird
  • cpu_firmware
  • rtt_unione_lite_app
  • user
  • inc
user_uni_ucp.h
1 /**************************************************************************
2 * Copyright (C) 2017-2017 Unisound
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License along
15 * with this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
17 **************************************************************************
18 *
19 * Description : user_uart_ucp.h
20 * Author : shangjinlong@unisound.com
21 * Date : 2020.04.20
22 *
23 **************************************************************************/
24 #ifndef USER_INC_USER_UART_UCP_H_
25 #define USER_INC_USER_UART_UCP_H_
26
27 #ifdef __cplusplus
28 extern "C" {
29 #endif
30
31 #include "unione.h"
32
42 typedef void (*_user_uni_recv)(uni_u16 cmd, char *payload, int len);
43
50 int user_uni_ucp_init(_user_uni_recv cb_recv);
51
55 void user_uni_ucp_final(void);
56
66 int user_uni_ucp_send(uni_u16 cmd, char *payload, int len, uni_bool is_block);
67
70 #ifdef __cplusplus
71 }
72 #endif
73 #endif // USER_INC_USER_UART_UCP_H_
74
75