如何利用Python+ESP8266 DIY 一个智能聊天机器人？

前言

大二忙里偷闲，花了一个月左右自己利用了Python+ESP8266 DIY 了一个智能聊天机器人，调用的是图灵机器人的体验API，现在把DIY过程记录下来，希望能分享给别的对这方面有兴趣的人。
DIY前的准备

1.STM32F429IG作为主控芯片
2.ESP8266，用来与自己电脑上服务器通信
3.VS1053，用来保存和播放音乐
硬件方面很简单，当然也可以自己兴趣拓展，比如自己加一块显示屏什么的，都是可以的。
电脑端服务器Python

思路是，电脑利用Python开服务器，等待ESP8266的连接，连接上后，STM32会发送给服务端刚刚录下的音乐，然后调用百度语音识别api，就可以将刚刚的录下的音乐发送给百度语音识别，百度语音会返回识别完成的字符串，再调用图灵机器人的api，把识别后的字符串发送出去，就会得到聊天的回复语句，最后一步，将回复语句发送给 百度语音合成，生成的回复语句的mp3，发送给stm32，stm32再通过VS1053播放，以上就实现了聊天的功能。
流程就是   vs1053>录音下的语句（stm32）  >百度语音识别 >图灵机器人 >百度语音生成 >stm32>vs1053
流程很简单，那么直接上代码

#coding=utf-8

from socket import *
import sys
import json
import base64
from urllib.request import urlopen
from urllib.request import Request
from urllib.error import URLError
from urllib.parse import urlencode
import string
import requests

class DemoError(Exception):
    pass


"""  获取TOKEN"""



def fetch_token():
    TOKEN_URL = 'http://openapi.baidu.com/oauth/2.0/token'
    SCOPE = 'audio_voice_assistant_get'  # 有此scope表示有asr能力，没有请在网页里勾选
    API_KEY = '你的api_key'
    SECRET_KEY = '你的api_secret'   
    params = {'grant_type': 'client_credentials',
              'client_id': API_KEY,
              'client_secret': SECRET_KEY}
    post_data = urlencode(params)
    post_data = post_data.encode( 'utf-8')
    req = Request(TOKEN_URL, post_data)
    try:
        f = urlopen(req)
        result_str = f.read()
    except URLError as err:
        result_str = err.read()
    result_str =  result_str.decode()

    result = json.loads(result_str)
    if ('access_token' in result.keys() and 'scope' in result.keys()):
        if not SCOPE in result['scope'].split(' '):
            raise DemoError('scope is not correct')
        return result['access_token']
    else:
        raise DemoError('MAYBE API_KEY or SECRET_KEY not correct: access_token or scope not found in token response')



"""  语音识别"""


ASR_URL = 'http://vop.baidu.com/server_api'
def voice_judge():
    token = fetch_token()
    # 需要识别的文件
    AUDIO_FILE = '8k.wav' #只支持 pcm/wav/amr
    # 文件格式
    FORMAT = AUDIO_FILE[-3:];  # 文件后缀 pcm/wav/amr
    # 根据文档填写PID，选择语言及识别模型
    DEV_PID = 1537;  # 1537 表示识别普通话，使用输入法模型。1536表示识别普通话，使用搜索模型
    CUID = '123456PYTHON';
    # 采样率
    RATE = 8000;  # 固定值
    speech_data = []
    with open(AUDIO_FILE, 'rb') as speech_file:
        speech_data = speech_file.read()
    length = len(speech_data)
    if length == 0:
        raise DemoError('file %s length read 0 bytes' % AUDIO_FILE)
    speech = base64.b64encode(speech_data)

    speech = str(speech, 'utf-8')
    params = {'dev_pid': DEV_PID,
              'format': FORMAT,
              'rate': RATE,
              'token': token,
              'cuid': CUID,
              'channel': 1,
              'speech': speech,
              'len': length
              }
    post_data = json.dumps(params, sort_keys=False)
    req = Request(ASR_URL, post_data.encode('utf-8'))
    req.add_header('Content-Type', 'application/json')
    try:
        f = urlopen(req)
        result_str = f.read()
    except  URLError as err:
        result_str = err.read()

    result_str = str(result_str, 'utf-8')
    return (result_str)

       
""" 聊天回复"""
def get_response(msg):
    api = 'http://openapi.tuling123.com/openapi/api/v2'
    dat = {
        "perception": {
            "inputText": {
                "text": msg
            },
            "inputImage": {
                "url": "imageUrl"
            },
            "selfInfo": {
                "location": {
                    "city": "厦门",
                }
            }
        },
        "userInfo": {
            "apiKey": '你的api_key',
            "userId": "随意的用户id，用来判断是否为同一人，因为图灵机器人会根据上文回复"
        }
    }
    dat = json.dumps(dat)
    r = requests.post(api, data=dat).json()


    mesage = r['results'][0]['values']['text']
    return mesage       



""" 语音生成"""



def voice_make(msg):
    token = fetch_token()
    # 发音人选择, 0为普通女声，1为普通男生，3为情感合成-度逍遥，4为情感合成-度丫丫，默认为普通女声
    PER = 4
    # 语速，取值0-15，默认为5中语速
    SPD = 2
    # 音调，取值0-15，默认为5中语调
    PIT = 5
    # 音量，取值0-9，默认为5中音量
    VOL = 5
    # 下载的文件格式, 3：mp3(default) 4： pcm-16k 5： pcm-8k 6. wav
    AUE = 3

    FORMATS = {3: "mp3", 4: "pcm", 5: "pcm", 6: "wav"}
    FORMAT = FORMATS[AUE]

    CUID = "123456PYTHON"

    TTS_URL = 'http://tsn.baidu.com/text2audio'
   
   
    params = {'tok': token, 'tex': msg, 'per': PER, 'spd': SPD, 'pit': PIT, 'vol': VOL, 'aue': AUE, 'cuid': CUID,
              'lan': 'zh', 'ctp': 1}  # lan ctp 固定参数
    data = urlencode(params)

    req = Request(TTS_URL, data.encode('utf-8'))

    has_error = False
    try:
        f = urlopen(req)
        result_str = f.read()
        has_error = ('Content-Type' not in f.headers.keys() or f.headers['Content-Type'].find('audio/') < 0)
    except  URLError as err:
        result_str = err.read()
        has_error = True

    save_file = "error.txt" if has_error else 'result.' + FORMAT
    with open(save_file, 'wb') as of:
        of.write(result_str)
    if has_error:
        result_str = str(result_str, 'utf-8')





#服务器，主程序
HOST = '你当前电脑的ip地址'
PORT = 80
BUFSIZ = 0x500000
ADDR=(HOST,PORT)
AUDIO_FILE = '8k.wav' #只支持 pcm/wav/amr
s = socket(AF_INET, SOCK_STREAM)
s.bind(ADDR)
s.listen(5)
while True:
    print('waiting for connecting...')
    print('')
    c, addr = s.accept()
    print('..connected from:', addr)
    speech_file= open(AUDIO_FILE, 'r+')
    speech_file.seek(0)
    speech_file.truncate()   #清空文件
    speech_file.close( )           
    while True:
        data = c.recv(BUFSIZ)
        if not data:
            break
        speech_file= open(AUDIO_FILE, 'ab+')
        speech_file.write(data)
        speech_file.flush()
        speech_file.close( )      

    c.close()            
    mystr=voice_judge()
    result = json.loads(mystr)
    if(result['err_no']==0):
        mystr = "".join(result['result'])
    else:
        mystr="无效"
    print(mystr)        
    mybyte = bytes(mystr, encoding = "gbk")   
    reply=get_response(mystr)
    voice_make(reply)
    print(reply)
    c, addr = s.accept()
    speech_file= open('result.mp3', 'rb')
    data=speech_file.read()
    speech_file.close( )      
    c.sendall(data)
    time.sleep(1)   
    c.close()


s.close()
stm32f429的流程也很简单，就是按下按键，开始录音，再按一下结束录音，然后等待回传回来的音频文件并且播放。


至于VS1053的代码，我之前有篇博客说了，如果不懂可以看看https://blog.csdn.net/qq_41495871/article/details/83686514


另外一个模块就是ESP8266，ESP8266的代码也是很简单的，我使用的是模组，所以很简单的调用api就好了，如果使用的是正统的esp8266,除了传输速度慢了一些，别的应该都一样。至于esp8266的配置，这边就不详细说明了，网络一大堆这个东西，我之前也用过NodeMcu实现过，Arduino调库调起来也是容易实现的。





void User_BSP_Init()
{
    delay_init(168);              // 初始化系统时钟，主频为168M
    SDRAM_Init();           //SDRAM初始化
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);  // 配置NVIC为优先级组2
    LED_GPIO_Config();      //配置板载LED
    USART_Config();         //配置串口
    USART_IT_ENABLE();      //打开串口接收中断
    EXTI_Key_Config();      //打开Key的外部中断        
    Fatfs_Flash_Format();   //初始化Fatfs_SPI_Flash
    M8266_Module_User_Init(); //初始化M8266，并打印相关信息
    VS_Init();              //初始化VS1053
    f_mount(&fs,"1:",1);     //挂载SPI_Flash 为盘符 1:
   
}
这是BSP的初始化


void User_main()
{
    OS_ERR  err;
    OSSchedRoundRobinCfg(DEF_ENABLED,0,&err);   //开启时间片转轮调度  10*系统节拍  即10ms
    OSMemCreate(&uC_mem,"uC/Data",uC_Data,4,16,&err);       //开启内存管理系统 ，128个内存块，每个4个字节
    OSTaskCreate(&USART1_Get_TCB,"串口接收",USART1_Get,0,USART1_Get_PRIO,USART1_Get_STK,USART1_Get_STK_SIZE/10,USART1_Get_STK_SIZE,0,0,0,(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),&err);
    OSTaskCreate(&Key_TCB,"按键中断",Key_On,0,Key_PRIO,Key_Stk,Key_Stk_Size/10,Key_Stk_Size,0,0,0,(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),&err);   
    OSTaskCreate(&USART1_OK_TCB,"串口接收完成",USART1_OK,0,USART1_OK_PRIO,USART1_OK_STK,USART1_OK_STK_SIZE/10,USART1_OK_STK_SIZE,0,0,0,(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),&err);
    OSTaskCreate(&M8266_Get_TCB,"M8266接收",M8266_Get,0,M8266_Get_PRIO,M8266_Gett_Stk,M8266_Get_Stk_Size/10,M8266_Get_Stk_Size,0,0,0,(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),&err);
   M8266_Module_Join_AP((u8*)WiFi_SSID,(u8*)WiFi_PAWD,Hostname);     
   
}
上面是几个主要任务，并且esp8266连接上你的热点


static void  Key_On (void *p_arg)
{
    OS_ERR  err;
    unsigned long file_size ;
    CPU_SR_ALLOC();
    LED_TOGGLE;            
    OSTimeDly(300,OS_OPT_TIME_DLY,&err);               
    LED_TOGGLE;            
    OSTimeDly(300,OS_OPT_TIME_DLY,&err);               
    LED_TOGGLE;   
    OSTimeDly(300,OS_OPT_TIME_DLY,&err);               
    LED_TOGGLE;         //闪灯表示准备完成
    while(1)
    {
    OSTaskSemPend (0,OS_OPT_PEND_BLOCKING,NULL,&err);            
    OS_CRITICAL_ENTER();
    M8266_Module_Set_Connect(Goal_Ip,Remote_Port,LinkNum,10);    //连接
    OS_CRITICAL_EXIT();           
    f_unlink("1:录音文件.wav");
    f_unlink("1:音乐文件.mp3");              
    vs1053_record_start();    //开始录音
    OSTaskCreate(&Record_TCB,"录音",Record,0,Record_PRIO,Record_Stk,Record_Stk_Size/10,Record_Stk_Size,2,0,0,(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),&err);
    OSTaskSemPend (0,OS_OPT_PEND_BLOCKING,NULL,&err);        
    OSTaskDel(&Record_TCB,&err);
    vs1053_record_stop("1:录音文件.wav"); //停止录音,并且保存在外部Flash中
    OSTimeDly(100,OS_OPT_TIME_DLY,&err);      
    M8266_Module_SendFile((uint8_t*)"1:录音文件.wav",LinkNum);      //发送录音文件
    printf("音乐文件大小是 %ld Byte，%.2f KBrn",file_size,(double)file_size/1024);  
    M8266WIFI_SPI_Delete_Connection(LinkNum,NULL);      //断开连接
    OSTimeDly(1500,OS_OPT_TIME_DLY,&err);               
    M8266_Module_Set_Connect(Goal_Ip,Remote_Port,LinkNum,10);     //开启连接，等待服务端发送处理好的回复音频文件      
    OSTimeDly(1000,OS_OPT_TIME_DLY,&err);                       
    M8266WIFI_SPI_Delete_Connection(LinkNum,NULL);         
    LED_TOGGLE;            
    }
}

static void    Record (void *p_arg)
{
    OS_ERR  err;
        CPU_SR_ALLOC();
    OSTimeDly(500,OS_OPT_TIME_DLY,&err);
    LED_TOGGLE;              
   
    while(1)
    {
     OS_CRITICAL_ENTER();   
     vs1053_record_run();   
     OS_CRITICAL_EXIT();        
     OSTimeDly(33,OS_OPT_TIME_DLY,&err);  //经过测试大概33ms收集一次，音质最佳
    }        
}


这是按键任务，应该是最主要的任务。还有录音时创建的任务。


static void  M8266_Get (void *p_arg)
{
    OS_ERR  err;
    u16 recv_data_num;
    u16 status;
    u16 wifi_get_flag;
    unsigned long file_size ;
   
    while(1)
    {
        status=M8266_Module_GetData(NULL,&recv_data_num);
        if(status!=0x0001)
        {
            wifi_get_flag=0;        
            while(status)
            {
            memcpy(&VS1053_Mem[wifi_get_flag],test_get,recv_data_num);
            memset(test_get,0,recv_data_num);                       
            wifi_get_flag+= recv_data_num;           
            status=M8266_Module_GetData(NULL,&recv_data_num);                                          
            }
             memcpy(VS1053_Mem,test_get,recv_data_num);
             memset(test_get,0,recv_data_num);      
             wifi_get_flag+=recv_data_num;  
            //将接收到的音乐文件保存到 VS1053_Mem SDRAM中

          printf("接收到 %d Bytern",wifi_get_flag);  
          vs1053_write_misic_file("1:音乐文件.mp3",wifi_get_flag);  //写入Flash中
          OSTimeDly(100,OS_OPT_TIME_DLY,&err);        
          vs1053_player_song((uint8_t*)"1:音乐文件.mp3",&file_size); //播放刚刚保存的文集
          printf("音乐文件大小是 %ld Bytern",file_size);        
        }
        OSTimeDly(50,OS_OPT_TIME_DLY,&err);        
    }           
}





然后是ESP8266接收到音频数据后，播放音频的任务


其余部分就是一些串口部分的任务了


static  void   USART1_OK(void *p_arg)  //串口接收完成任务
{
    OS_ERR  err;
    uint32_t M8266_flag;
    uint32_t Debug_flag;
    u16 status;
    while(1)
    {
    OSTaskSemPend (0,OS_OPT_PEND_BLOCKING,NULL,&err);
    M8266_flag=0;
    Debug_flag=0;   
    printf("接收到 %d 串口数据rn",Write_Usart_flag);   
    while(M8266_flag     {
         if(Write_Usart_flag-M8266_flag<=1024)
         {
         Debug_flag+=M8266WIFI_SPI_Send_Data(&Usart_Mem[M8266_flag],Write_Usart_flag-M8266_flag,LinkNum,&status);
         M8266_flag+=Write_Usart_flag-M8266_flag;      
         }
         else
         {              
         Debug_flag+=M8266WIFI_SPI_Send_Data(&Usart_Mem[M8266_flag],1024,LinkNum,&status);
         M8266_flag+=1024;
         }
    }   
    printf("成功发送 %d Bytern",Debug_flag);
    memset(Usart_Mem,0,Write_Usart_flag);  
    Write_Usart_flag=0;
    }
}


static void  USART1_Get (void *p_arg)
{
        OS_ERR         err;
        OS_MSG_SIZE    msg_size;
        char * pMsg;
        while (DEF_TRUE)
    {                                          
        pMsg = OSTaskQPend(0,OS_OPT_PEND_BLOCKING,&msg_size,NULL,&err);     //无限期限堵塞等待
        Usart_Mem[Write_Usart_flag]=*pMsg;
        Write_Usart_flag++;
        OSMemPut(&uC_mem,pMsg,&err);                            // 退还内存块      
        }      
}


以上就是几个主要部分了，很简单。