项目：智能语音对话机器人

矫情吗；* 2021-11-23 09:56 342阅读 0赞

## 技术点： ##

● **C++STL**  
● http第三方库  
● 图灵机器人  
● **百度语音识别和语音识别**  
● Linux系统/网络编程  
● 各种第三方库和第三方工具的安装与使用

## 项目简介 ##

*  **使用C++编写一个智能AI对话和语音命令执行的语音管理工具，其中可执行命令支持配置。**
 *  主要采用C++进程编写，当程序启动后，加载配置文件，启动录音功能进行录音，调用百度语音识别平台对所录音文件进行识别；再对所识别到的文字进行判断，是命令还是普通对话，**命令**则执行系统命令执行模块；**普通对话**则交给图灵机器人进行交流，所返回的文字交给百度语音合成平台，启动播放功能，则成功进行对话。

--------------------

## 准备工作 ##

*  使用图灵机器人实现对话，需要注册图灵机器人，拥有一个属于自己的机器人
 *  使用百度语音识别和语音合成，同样也需要注册，在之后的使用中，我们选择的技术文档为C++SDK，需要下载百度C++语音识别SDK
 *  安装jsoncpp、 安装openssl、安装libcurl(需要支持https)
 *  还要准备录音和播放工具，在我的Centos 7上有系统自带的录音工具arecord，安装vlc/cvlc播放器

# 编码过程 #

● 先建立项目目录，创建工程文件，引入百度语音识别SDK

#mkdir Boyfriend 
    #ls build.sh

*  构建项目的shell脚本，简单实现 command.etc
 *  语音命令配置文件 Boyfriend.cc
 *  源文件 Boyfriend.hpp
 *  核心代码 Makefile speech
 *  百度语音识别SDK temp\_file
 *  保存临时语音文件目录

**核心代码**

[ LInux语音AI相关代码][LInux_AI]

#Boyfriend.hpp
      //1、创建相关类,包含相关头文件 
       #pragma once
       #include <map>
       #include <iostream>
       #include <cstdio>
       #include <sstream>
       #include <memory>
       #include <fstream>
       #include <unistd.h>
       #include <stdlib.h>
       #include <unordered_map>
       #include <json/json.h>
       #include <string>
       #include <pthread.h>
       #include "base/http.h"
       #include "speech.h"
      
       //#define TTS_PATH "temp_file/tts.mp3"
       #define TTS_PATH "temp_file/tts.wav"
       #define ASR_PATH "temp_file/asr.wav"
       #define CMD_ETC "command.etc"
       #define LOG "log.txt"
      
      class Util{ 
          private:
              static pthread_t id;
          public:
             static bool Exec(std::string command, bool is_print)
              { 
                if(!is_print){ 
                      command += ">/dev/null 2>&1";
                      }
                 FILE *fp = popen(command.c_str(), "r");
                 if(nullptr == fp){ 
                      std::cerr << "popen exec \'" << command << "\' Error" << std::endl;
                      return false;
                 }
                      if(is_print){ 
                              char ch;
                              while(fread(&ch,1,1,fp) >0){ 
                                      fwrite(&ch,1,1,stdout);
                              }
                      }
                      pclose(fp);
                      return true;
              }
              static void *ThreadRun(void *arg)
              { 
                 const char *tips = (char*)arg;
                 int i = 0;
                 char bar[103] = { 0};
                 const char *lable = "|/-\\";
                 for(; i<=50;i++){ 
                      printf("%s[%-51s][%d%%][%c]\r",tips,bar,i*2,lable[i%4]);
                      fflush(stdout);
                      bar[i] = '=';
                      bar[i+1] = '>';
                      //bar[i+2] = 0;
                      usleep(49000*2);
                 }
                 printf("\n");
              }
              static void PrintStart(std::string tips)
              { 
                 pthread_create(&id,NULL,ThreadRun,(void*)tips.c_str());
              }
              static void PrintEnd()
              { 
                 pthread_cancel(id);
              }
      };
      pthread_t Util::id;
      //2、采用图灵机器人，进行智能对话 
      class Robot{ 
         private:
            std::string url;
            std::string api_key;
            std::string user_id;
            aip::HttpClient client;
          private:
                 bool IsCodeLegal(int code)
                { 
                      bool result = false;
                      switch(code){ 
                          case 5000:
                          case 6000:
                              break;
                          case 10004:
                              result = true;
                              break;
                          default:
                              result = true;
                              break;
                       }
                      return result;
                }
                  std::string MessageToJson(std::string &message)
                 { 
                     Json::Value root;
                     Json::StreamWriterBuilder wb;
                     std::ostringstream ss;
     
                     Json::Value item_;
                     item_["text"] = message ;
     
                     Json::Value item;
                     item["inputText"] = item_ ;
     
                     root["reqType"] = 0;//text
                     root["perception"] = item;
     
                     item.clear();
                     item["apiKey"] = api_key;
                     item["userId"] = user_id;
                     root["userInfo"] = item;
     
                     std::unique_ptr<Json::StreamWriter> sw(wb.newStreamWriter());
                     sw->write(root,&ss);
                     std::string json_string = ss.str();
                     //std::cout<<"debug: "<<json_string<<std::endl;
                     return json_string;
                }
                 std::string RequestTL(std::string &request_json)
                 { 
                   std::string response;
                   int status_code = client.post(url,nullptr,request_json,nullptr,&response);
                   if (status_code != CURLcode::CURLE_OK) { 
                         std::cerr << "post error" << std::endl;
                         return "";
                  }
                     return response;
                 }
                  std::string JsonToEchoMessage(std::string &str)
                  { 
                     //std::cout <<"JsonToEchoMessage:"<< str << std::endl;
                     JSONCPP_STRING errs;
                     Json::Value root;
                     Json::CharReaderBuilder rb;
                     std::unique_ptr<Json::CharReader> const cr(rb.newCharReader());
                     bool res = cr->parse(str.data(),str.data()+str.size(), &root,&errs);
                     if(!res || !errs.empty()) { 
                             std::cerr << "parse error!"<<std::endl;
                             return "";
                     }
                     int code = root["intent"]["code"].asInt();
                     if(!IsCodeLegal(code))
                     { 
                             std::cerr<< "response code error!" <<std::endl;
                             return "";
                     }
                     Json::Value item = root["results"][0];
                     std::string msg = item["values"]["text"].asString();
                     return msg;
                  }
     
         public:
            Robot(std::string id = "1")
            { 
                this->url = "http://openapi.tuling123.com/openapi/api/v2";
                this->api_key = "b7fa07e47cbe46a191b8190cc004ed60";
                this->user_id = id;
             }
            std::string Talk(std::string message)
            { 
               std::string json = MessageToJson(message);
               std::string responce = RequestTL(json);
               std::string echo_message = JsonToEchoMessage(responce);
               return echo_message ;
            }
     
            ~Robot()
            { 
     
            }
     };
     //3、语音识别Speech Recognition
     class SpeechRec{ 
        private:
             //填写appid，填写Api Key，填写Secret Key.
             std::string app_id;
             std::string api_key;
             std::string secret_key;
             aip::Speech *client;
        private:
                bool IsCodeLegal(int code)
                { 
                      bool result = false;
                      switch(code){ 
                          case 0:
                              result=true;
                              break;
                          default:
                              break;
                       }
                      return result;
                }
        public:
             SpeechRec()
             { 
                 app_id = "16943059";
                 api_key = "q9vkbqwjwKjvoPgt69NTt36F";
                 secret_key = "8lbil7MTruiGKHQdSsIT1WB97rX4ncsl";
                 client = new aip::Speech(app_id, api_key, secret_key);
             }
      //4、语音识别Automatic Speech Recognition 
             bool ASR(std::string path,std::string &out)
             { 
                 std::map<std::string,std::string> options;
                 options["dev_pid"] = "1536";
                 std::string file_content;
                 aip::get_file_content(ASR_PATH,&file_content);
                 Json::Value result = client->recognize(file_content,"wav",16000,options);
                 //std::cout << "debug: " << result.toStyledString() << std::endl;
                 int code = result["err_no"].asInt();
                 if(!IsCodeLegal(code)){ 
                        std::cerr << "recognize error" << std::endl;
                        return false;
                     }
                 out = result["result"][0].asString();
                 return true;
             }
      //5、语音合成Text To Speech
             bool TTS(std::string message)
             { 
                bool ret；
                std::ofstream ofile;
                std::string ret_file;
                std::map<std::string,std::string> options;
                options["spd"]="5"; //speech speed 0~15
                options["pit"]="7"; //0-15
                options["vol"]="15"; //0-15
                options["per"]="110"; //1 0 3 4 度博文=106 度小童=110 度小萌=111 度米朵=103 度小娇=5
                options["aue"]="6";
                ofile.open(TTS_PATH,std::ios::out|std::ios::binary);
                Json::Value result=client->text2audio(message,options,ret_file);
                 if(!ret_file.empty()){ 
                     ofile << ret_file;
                     ofile.close();
                     ret = true;
                }
                else{ 
                     std::cerr <<result.toStyledString() << std::endl;
                     ret = false;
                }
                ofile.close();
                return ret;
             }
             ~SpeechRec()
             { 
             }
     };
     //6、核心代码-服务器&&系统相关 
     class Boyfriend{ 
        private:
             Robot rt;
             SpeechRec sr;
             std::unordered_map<std::string,std::string> commands;
        private:
             bool Record()
             { 
                //std::cout << "debug:" << "Record ..." << std::endl;
                Util::PrintStart("录音中");
                std::string command = "arecord -t wav -c 1 -r 16000 -d 5 -f S16_LE ";
                command += ASR_PATH;
                bool ret = Util::Exec(command,false);
                //std::cout << "debug:Recoed ... done" <<std::endl;
                Util::PrintEnd();
                return ret;
             }
             bool Play()
             { 
                std::string command = "cvlc --play-and-exit ";
                command += TTS_PATH;
                return Util::Exec(command,false);
             }
        public:
          Boyfriend()
          { 
     
           };
           bool LoadEtc()
          { 
             std::ifstream in(CMD_ETC);
             if(!in.is_open()){ 
                     std::cerr <<"open error" <<std::endl;
                     return false;
                     }
                     std::string sep = ":";
                     char line[256];
                    while(in.getline(line,sizeof(line))){ 
                             std::string str = line;
                             std::size_t pos = str.find(sep);
                             if(std::string::npos == pos){ 
                                     std::cerr << "not find :" << std::endl;
                                     continue;
                             }
                             std::string k = str.substr(0,pos);
                             std::string v = str.substr(pos+sep.size());
                             k+="。";
                             commands.insert(std::make_pair(k,v));
                             //commands.insert({k,v});
                     }
                     std::cerr <<"Load command erc done ... success"<< std::endl;
                     in.close();
                     return true;
          }
          bool IsCommand(std::string message,std::string &cmd)
          { 
             auto iter = commands.find(message);
             if(iter ==commands.end()){ 
                     return false;
             }
             cmd = iter->second;
          }
           void Run()
          { 
     #ifdef _LOG_
             int fd = open(LOG,O_WRONLY|O_CREAT,0644);
             if(fd<0){ 
               return 1;
             }
             dup2(fd,2);
             //int fd = open("/dev/null",O_WRONLY);
     #endif
             volatile bool quit = false;
             while(!quit){ 
                if(this->Record()){ 
                     std::string message;
                     if(sr.ASR(ASR_PATH,message)){ 
                        //1.command
                        std::string cmd="";
                        if(IsCommand(message,cmd)){ 
                             std::cout << "[Boyfriend@localhost]$ "<<cmd <<std::endl;
                             Util::Exec(cmd,true);
                             continue;
                             }
                        std::cout<<"我# "<<message <<std::endl;
                        if(message =="你走吧。"){ 
                             std::string quit_message = "那我就走了，不要太想我哦！";
                             std::cout<<"Boyfriend# " << quit_message<< std::endl;
                              if(sr.TTS(quit_message)){ 
                                      this->Play();
                                     }
                             exit(0);
                             }
                        //2.Tuling
                        // std::cout<<"我# "<<message <<std::endl;
                        std::string echo = rt.Talk(message);
                        std::cout<<"Boyfriend# " << echo<< std::endl;
                        if(sr.TTS(echo)){ 
                             this->Play();
                        }
                     }
             // else{ 
             // std::cerr<<"Recognize error..." << std::endl;
             // }
                }
                else{ 
                     std::cerr << "Record error..." << std::endl;
             }
               // sleep(2);
             }
     #ifdef _LOG_
             close(fd);
     #endif
           }
          ~Boyfriend()
          { 
           }
     };

**● 调用逻辑**

#Boyfriend.cc
       #include "Boyfriend.hpp"
      
       using namespace std;
       
       int main()
       { 
          //Robot r;
          //string str;
          //volatile bool quit = false;
          //while(!quit){ 
          // cout << "我# ";
          // cin >> str;
          // std::string s = r.Talk(str);
          // cout << "Tom$ " << s << endl;
          // }
          // std::string s = r.Talk("你好吗？");
          // cout << s << endl;
        Boyfriend *bf = new Boyfriend();
        if(!bf->LoadEtc()){ 
              return 1;
        }
      
        bf->Run();
        return 0;
      }

**● command.etc命令配置文件**

#command.etc
       查看当前目录:ls -l
       关闭防火墙:systemctl stop firewalld
       打开防火墙:systemctl start firewalld
       跑火车:sl
       黑客帝国:cmatrix -B -C blue
       查看黑名单:cat black_name.txt
       你给我闺蜜唱首歌:aplay 李森茂_-_生日快乐歌（吉他改编版）.wav

**● Makefile配置环境变量**

#Makefile
       CC=g++
       #编译器
       bin=Boyfriend
       #生成的可执行文件
       src=Boyfriend.cc
       #依赖的源文件
       INCLUDE=-Ispeech/
       LIB=-ljsoncpp  -lcurl -lcrypto -lpthread
       
      $(bin):$(src)
       #生成bin，依赖的src
              $(CC) -o $@ $^ $(INCLUDE) $(LIB)
      #方法
      .PHONY:clean
      clean:
              rm -f $(bin)

## 代码实现 ##

智能语音对话AI

## 难点 ##

**jsoncpp的使用方法讲解**：

*  什么是json
 *  有什么特点
 *  为什么要用它
 *  StreamWriterBuilder、StreamWriter、CharReaderBuilder、CharReader、write函数、parse函数与Json:Value的使用

//序列化 
    #include <iostream> 
    #include <sstream>
    #include <memory> 
    #include <string>
    #include <json/json.h> 
    int main() 
    {     
    Json::Value root;    
    Json::StreamWriterBuilder wb;     
    std::ostringstream os; 
    root["Name"] = "zhangsan";     
    root["Age"] = 26;     
    root["Lang"] = "c++"; 
    std::unique_ptr<Json::StreamWriter>
    jsonWriter(wb.newStreamWriter());     
    jsonWriter->write(root, &os);     
    std::string
    s = os.str(); 
    std::cout << s << std::endl; 
    return 0; 
    }

#打印序列化结果
    { 
     "Age" : 26,
     "Lang" : "c++",
     "Name" : "zhangsan"
    }

**总结：json还支持嵌套，如json里面包含“json”，甚至json还包含”json数组“等，但是目前jsoncpp我们以简单使用为主。**

#### 总结&项目扩展 ####

*  整体来讲，项目的难度不大，核心点在于**对各个工具，平台的熟悉程度**。
 *  我从这个项目中吸收的东西是： **学会使用第三方平台，第三方工具，就能完成很有意思的功能**。

**扩展：**

*  将该项目移植到windows中， 语音控制windows上各个软件的打开和关闭，岂不酷炫
 *  能否移植到手机端呢？如找一个js页面，在服务器上部署服务，使用手机远程控制服务器（笔记本）
 *  可以在树莓派上，安装一些第三方驱动或者组件（如，灯），语音控制灯的开启和关闭灯，再调研一下百度的其他语音或者文本功能做这类项目，就应该玩起来。

[LInux_AI]: https://github.com/jingyu0/Linux_project/tree/master/Boyfriend