社区导航

 
查看: 201|回复: 2

[原创] stm32单片机裸机调用百度语音识别接口和合成接口的部分代码实现

[复制链接]

30

TA的帖子

0

TA的资源

一粒金砂(中级)

Rank: 2

发表于 2018-11-9 13:38:55 | 显示全部楼层 |阅读模式
stm32单片机裸机调用百度语音识别接口和合成接口的部分代码实现,---作者:阮丁远(版权所有



此内容由EEWORLD论坛网友net2uizoo原创,如需转载或用于商业用途需征得作者同意并注明出处




先介绍个要用到的函数:lwip 下 WebClient或者说http cilent的实现:




  1. int8_t WebClient(const char *url, const char *post, uint8_t **pageBuf,uint8_t is_upload_wav,uint32_t wav_len1)

  2. {

  3.   

  4.          uint32_t i;

  5.        

  6.   uint8_t server_addr[200];//这2个放在局部变量里,防止多线程冲突:

  7.      uint8_t web_addr[1200];//有的tts的二次url编码后的请求长度很长,所以这个大点

  8. ip_addr_t server_ip;





  9. uint8_t ishttps;

  10.    uint16_t start_char_i;

  11.     uint16_t start_len1;

  12.   uint32_t ret_lens;

  13.          err_t err ;

  14.        

  15.    uint32_t  j, k;

  16.    uint32_t head_and_wav_len1;



  17.     struct netconn *conn = NULL;

  18.     struct netbuf *inBuf = NULL;

  19.     struct pbuf *q;

  20.     char *request = NULL;

  21.     uint32_t recvPos = 0;

  22.     uint8_t *recvBuf;

  23.     err_t err_msg;









  24.     while(wifi_88w8801_sta.ip_addr.addr == 0x00)

  25.     {

  26.         return HTTP_ROUTE_NOT_FOUND;

  27.     }



  28.          

  29.          

  30.    if(strncasecmp((const char *)url, "http://", 7) == 0||strncasecmp((const char *)url, "https://", 8) == 0)                 /* 只处理http协议 */

  31.     {

  32.                  

  33.                  

  34.                  if(strncasecmp((const char *)url, "http://", 7) == 0){

  35.                          

  36.                          ishttps=0;

  37.                          start_char_i=4;

  38.                          start_len1=7;

  39.                  }

  40.                  

  41.                  if(strncasecmp((const char *)url, "https://", 8) == 0){

  42.                          

  43.                          ishttps=1;

  44.                          start_char_i=5;

  45.                          start_len1=8;

  46.                  }                 

  47.                  

  48.                  

  49.                  if(ishttps==0){

  50.                           ////改为全局变量式,可以防止内存泄露:

  51.         //server_addr = pvPortMalloc2 strlen(url) - 7);

  52.                  

  53.                  }else{

  54.                          

  55.                           ////改为全局变量式,可以防止内存泄露:

  56.         //server_addr = pvPortMalloc2 strlen(url) - 8);

  57.                          

  58.                  }

  59.                  

  60.                  

  61.                  ////改为全局变量式,可以防止内存泄露:

  62. //        if(server_addr == NULL) {

  63. //                          

  64. //                          printf("HTTP_OUT_OF_RAM in malloc server_addr");

  65. //                          

  66. //                          return HTTP_OUT_OF_RAM;

  67. //                          

  68. //                          

  69. //                  }



  70.   printf("proceess 1\r\n");





  71.                  /* 1)提取服务器部分 */

  72.         for(i = start_char_i; url[i]; ++i)

  73.         {

  74.             if (url[i] == ':' && url[i + 1] == '/' && url[i + 2] == '/')

  75.             {

  76.                 for (i = i + 3, j = 0; url[i] > 32 && url[i] < 127 && url[i] != '/'; //32-127间的ascII码的字符

  77.                         ++i, ++j)

  78.                 {

  79.                     server_addr[j] = url[i];

  80.                     if (url[i] == '@') /* 服务器基础认证符号,我们做不了,遇到就错误. */

  81.                     {

  82.                         return HTTP_AUTH_NOT_SUPPORT;

  83.                     }

  84.                 }

  85.                 server_addr[j] = '\0';



  86.                                          

  87.                                                   ////改为全局变量式,可以防止内存泄露:

  88.                 //web_addr = pvPortMalloc2 strlen(url) - start_len1 - strlen((const char *)server_addr));

  89.                 //if(web_addr == NULL) return HTTP_OUT_OF_RAM;



  90.                 for (k = start_len1 + j; k < (strlen(url)); k++) /* 后半部分提取 */

  91.                 {

  92.                     web_addr[k - start_len1 - j] = url[k];

  93.                 }



  94.                 web_addr[k - start_len1 - j] = '\0';



  95.                 while (--j)

  96.                 {

  97.                     if (server_addr[j] == ':')//??过滤端口号?

  98.                     {

  99.                         server_addr[j] = '\0';

  100.                     }

  101.                 }

  102.             }



  103.         }



  104.         if(strlen((const char *)server_addr) < 2) /* 最短网址3.cn */

  105.         {

  106.          

  107.                           

  108.                      printf("HTTP_SERVER_ADDR_ERROR\r\n");

  109.                           

  110.                                

  111.                           

  112.                      printf(server_addr);

  113.                           

  114.                                    ////改为全局变量式,可以防止内存泄露:

  115.                                 //vPortFree2 server_addr);

  116.                           

  117.                                    ////改为全局变量式,可以防止内存泄露:

  118.           //  if(web_addr == NULL) {vPortFree2 web_addr); }

  119.                                

  120.                                 /* 这么短,还不一定提取到了这个. */

  121.                           

  122.                                

  123.             return HTTP_SERVER_ADDR_ERROR;

  124.         }

  125.                   

  126.                   printf("\r\nweb host:");



  127.                   printf(server_addr);

  128.                   

  129.                   

  130.                   

  131.         /* 2)查询IP */

  132.          netconn_gethostbyname((const char *)server_addr, &server_ip);



  133.                   

  134.                   

  135. //                  

  136. //                  server_ip.addr=0;

  137. //                  err =  dns_gethostbyname((const char *)server_addr, &server_ip,dns_foundB , NULL);//dns_foundB

  138. //  if (err == ERR_OK)

  139. //  {

  140. //    printf("In cache! IP: %s\n", ipaddr_ntoa(&server_ip));



  141. //  }

  142. //                 

  143. //                  

  144. //                  while(server_ip.addr==0){

  145. //                  

  146. //                  

  147. //                  }

  148. //                          

  149.                            printf("get a IP: %s\n", ipaddr_ntoa(&server_ip));

  150.                           

  151.                   

  152.                         if(is_upload_wav==1){

  153.         /* 3)构造访问头 */

  154.                                

  155.                                

  156.                                

  157.         request = pvPortMalloc2( strlen(url) + wav_len1+1024); /* 头所需内存大小. */

  158.                                

  159.                                

  160.                                

  161.                                

  162.                         }else if(is_upload_wav==0){

  163.                                

  164.                                   request = pvPortMalloc2( strlen(url) + 1024); /* 头所需内存大小. */

  165.                                

  166.                         }else if(is_upload_wav==2){

  167.                                

  168.                                   request = pvPortMalloc2( strlen(url) + 1024); /* 头所需内存大小. */

  169.                                

  170.                         }

  171.                   

  172.         if(request == NULL)

  173.                           {

  174.                   

  175.                   

  176.                   printf("HTTP_OUT_OF_RAM in request Malloc.");

  177.                   

  178.                   return HTTP_OUT_OF_RAM;

  179.                           

  180.                           }



  181.                           

  182.                         if(is_upload_wav==1){

  183.                                

  184.                                

  185.                                

  186.           #if upload_Wav0_or_pcm1 ==0

  187.          sprintf(request, "POST %s HTTP/1.0\r\nHost: %s\r\nUser-Agent:Mozilla/5.0 (Windows; U; Windows NT 6.1; en-us) AppleWebKit/534.50 (KHTML, like Gecko) Version/5.1 Safari/534.50\r\nContent-Length: %d\r\nContent-Type: audio/wav;rate=8000\r\n\r\n", web_addr, server_addr, wav_len1);

  188.           #endif

  189.                                

  190.                                

  191.                                

  192.           #if upload_Wav0_or_pcm1 ==1

  193.          sprintf(request, "POST %s HTTP/1.0\r\nHost: %s\r\nUser-Agent:Mozilla/5.0 (Windows; U; Windows NT 6.1; en-us) AppleWebKit/534.50 (KHTML, like Gecko) Version/5.1 Safari/534.50\r\nContent-Length: %d\r\nContent-Type: audio/pcm;rate=8000\r\n\r\n", web_addr, server_addr, wav_len1);

  194.           #endif

  195.                                

  196.                                 head_and_wav_len1=strlen(request)+wav_len1;

  197.                                

  198.                                 memcpy( &request[strlen(request)],post,wav_len1);

  199.                                

  200.                                



  201.                         }else if(is_upload_wav==0){                               

  202.                           

  203.                                           if(post != NULL){

  204.                                                         sprintf(request, "POST %s HTTP/1.0\r\nHost: %s\r\nUser-Agent:Mozilla/5.0 (Windows; U; Windows NT 6.1; en-us) AppleWebKit/534.50 (KHTML, like Gecko) Version/5.1 Safari/534.50\r\nContent-Length: %d\r\nContent-Type: application/x-www-form-urlencoded\r\n\r\n%s", web_addr, server_addr, strlen(post), post);

  205.                                           





  206.                                                  // printf( "POST %s HTTP/1.0\r\nHost: %s\r\nUser-Agent: Mozilla/5.0 (lwip;STM32) TaterLi\r\nContent-Length: %d\r\nContent-Type: application/x-www-form-urlencoded\r\n\r\n%s", web_addr, server_addr, strlen(post), post);

  207.                                           

  208.                                                   

  209.                                           }else{

  210.                                                         sprintf(request, "GET %s HTTP/1.0\r\nHost: %s\r\nUser-Agent:Mozilla/5.0 (Windows; U; Windows NT 6.1; en-us) AppleWebKit/534.50 (KHTML, like Gecko) Version/5.1 Safari/534.50\r\n\r\n", web_addr, server_addr);

  211.                                           

  212.                                                   

  213.                                           

  214.                                           }

  215.                   

  216.             }else if(is_upload_wav==2){       

  217.                          

  218.                          

  219.                                  sprintf(request, "GET %s HTTP/1.0\r\nHost: %s\r\nUser-Agent:Mozilla/5.0 (Windows; U; Windows NT 6.1; en-us) AppleWebKit/534.50 (KHTML, like Gecko) Version/5.1 Safari/534.50\r\n\r\n", web_addr, server_addr);

  220.                                           MP3_return_data_len=0;

  221.                          

  222.                  }

  223.                   

  224.                   //vPortFree2 (server_addr);

  225.         if(web_addr != NULL)

  226.         {

  227.             /* 万一没提取到,就是NULL,如果是NULL,那么也不用继续了. */

  228.                                    ////改为全局变量式,可以防止内存泄露:

  229.             //vPortFree2 web_addr);

  230.         }

  231.         else

  232.         {

  233.             vPortFree2 (request);

  234.                           

  235.                            printf("HTTP_NOT_VALID_ADDR");

  236.             return HTTP_NOT_VALID_ADDR;

  237.         }

  238.          

  239.                   

  240.         /* 4)开始访问 */

  241.         conn = netconn_new(NETCONN_TCP);

  242.                            

  243.                   

  244.         err_msg = netconn_connect(conn, &server_ip, 80); /* 目前也只能支持80端口,比较常用,不考虑特殊情况. */

  245.                        

  246.                   



  247.                   

  248.         if (err_msg == ERR_OK)

  249.         {

  250.                             //  struct netbuf *inBuf_g = NULL;

  251.                           

  252.                           

  253.                         if(is_upload_wav==1){

  254.             netconn_write(conn, request, head_and_wav_len1, NETCONN_COPY);

  255.                                

  256.                         }else if(is_upload_wav==0){

  257.                            netconn_write(conn, request, strlen((char *)request), NETCONN_COPY);

  258.                                

  259.                                

  260.                         }else if(is_upload_wav==2){

  261.                                

  262.                                   netconn_write(conn, request, strlen((char *)request), NETCONN_COPY);

  263.                        

  264.                                

  265.                         }

  266.                        

  267.                        

  268.             vPortFree2 (request);

  269.             conn->recv_timeout = 15000;//15s

  270.                

  271.             recvPos = 0;



  272.                         if(is_upload_wav==2){

  273.                                

  274.                                 u32 offsetptr;

  275.                                

  276.                

  277.           void *data;

  278.           u16_t len;

  279.                                

  280.        

  281.                                



  282.                recvPos = 0;







  283.             ret_lens=0;

  284.                                 offsetptr=0;

  285.             while(1)

  286.                                 {

  287.                                         err=netconn_recv(conn, &inBuf);

  288.                                        

  289.                                         if(inBuf==NULL){

  290.                                                

  291.                                                 break;

  292.                                         }

  293.                

  294.                                 do

  295.             {

  296.               netbuf_data(inBuf, &data, &len);

  297.             

  298.                                        

  299.                                         memcpy(MP3_return_data+ret_lens,data,len);

  300.                                        

  301.                                                  ret_lens+=len;

  302.                                        

  303.                                        

  304.             }

  305.             while (netbuf_next(inBuf) >= 0);

  306.                                        



  307.                                

  308.                                          printf("ret_lens=%d\r\n",ret_lens);

  309.                                      netbuf_delete(inBuf);

  310.             }













  311.             // printf (MP3_return_data);













  312.             netconn_close(conn);

  313.             netconn_delete(conn);

  314.            // netbuf_delete(inBuf);

  315.                     

  316.                                



  317.                                

  318.                                

  319.                                

  320.                                

  321.             /* 5)分析数据(分析HTTP头,暂时不打算支持301之类的)        */

  322.             for(i = 0; MP3_return_data[i]; ++i)

  323.             {

  324.                 if (MP3_return_data[i] == '2' && MP3_return_data[i + 1] == '0' && MP3_return_data[i + 2] == '0')

  325.                 {

  326.                     /* 证明200 OK */

  327.                     for(; MP3_return_data[i]!='\0'; ++i)

  328.                     {

  329.                         /* 响应头的结束也是两个回车 */

  330.                         if(MP3_return_data[i] == '\r' && MP3_return_data[i + 1] == '\n' && MP3_return_data[i + 2] == '\r' && MP3_return_data[i + 3] == '\n')

  331.                         {

  332.                             /* 6)复制正文内容 */

  333.                             i += 4;

  334.                             k = ret_lens - i;

  335.                             if(k == 0) return HTTP_NO_CONTENT;



  336.                                                                          

  337.                                                                          MP3_return_data_len=k;

  338.                                                                          

  339.                                                                          MP3_return_data_start_offset=i;

  340.                                                                          

  341.                                                                                                                          

  342.                                                                                 printf("MP3_return_data_len=%d\r\n",MP3_return_data_len);

  343.                                                                                

  344.                                                                                

  345.                                                                                

  346.                                                                                 //printf(MP3_return_data);

  347.                             return HTTP_OK;

  348.                         }

  349.                     }

  350.                 }

  351.             }

  352.                                

  353.                                

  354.                                

  355.                                

  356.                                

  357.                         }else{

  358.                                

  359.                                

  360.                                

  361.                                

  362.           void *data;

  363.           u16_t len;

  364.                                

  365.        

  366.                                

  367.                            u32 offsetptr;

  368.                 recvBuf = pvPortMalloc2( 1024*1024);

  369.                                             recvPos = 0;



  370.                        

  371.             ret_lens=0;

  372.                                 offsetptr=0;

  373.             while(1)

  374.                                 {

  375.                                                         netconn_recv(conn, &inBuf);

  376.                                                        

  377.                                                         if(inBuf==NULL){

  378.                                                                

  379.                                                                 break;

  380.                                                         }

  381.                                                        

  382.                                                                

  383.                                                         do

  384.                                                         {

  385.                                                           netbuf_data(inBuf, &data, &len);

  386.                                                          

  387.                                                                

  388.                                                                 memcpy(recvBuf+ret_lens,data,len);

  389.                                                                

  390.                                                                          ret_lens+=len;

  391.                                                                

  392.                                                                

  393.                                                         }

  394.                                                         while (netbuf_next(inBuf) >= 0);

  395.                                                                

  396.                                                        

  397.                                                         recvBuf[ret_lens]='\0';

  398.                                                                

  399.                                                                

  400.                                                        

  401.                                                                         netbuf_delete(inBuf);

  402.                                                

  403.                                                        

  404.                                                        

  405.             }



  406.             netconn_close(conn);

  407.             netconn_delete(conn);

  408.             

  409.                     

  410.                                

  411.                                

  412. //            if(err_msg != ERR_OK) {

  413. //                                       

  414. //                                         printf("HTTP_OUT_OF_RAM in err_msg != ERR_OK");

  415. //                                       

  416. //                                        return HTTP_OUT_OF_RAM;

  417. //                                       

  418. //                                       

  419. //                                       

  420. //                                }



  421.                                

  422.                                

  423.                                

  424.             /* 5)分析数据(分析HTTP头,暂时不打算支持301之类的)        */

  425.             for(i = 0; recvBuf[i]; ++i)

  426.             {

  427.                 if (recvBuf[i] == '2' && recvBuf[i + 1] == '0' && recvBuf[i + 2] == '0')

  428.                 {

  429.                     /* 证明200 OK */

  430.                     for(; recvBuf[i]!='\0'; ++i)

  431.                     {

  432.                         /* 响应头的结束也是两个回车 */

  433.                         if(recvBuf[i] == '\r' && recvBuf[i + 1] == '\n' && recvBuf[i + 2] == '\r' && recvBuf[i + 3] == '\n')

  434.                         {

  435.                             /* 6)复制正文内容 */

  436.                             i += 4;

  437.                             k = ret_lens - i;

  438.                             if(k == 0) return HTTP_NO_CONTENT;

  439.                             *pageBuf = pvPortMalloc2 (k);

  440.                             if(*pageBuf == NULL)

  441.                             {

  442.                                 vPortFree2 (recvBuf);

  443.                                                                                  

  444.                                                                                  

  445.                                                                                           printf("HTTP_OUT_OF_RAM in malloc pageBuf");

  446.                                

  447.                                 return HTTP_OUT_OF_RAM;

  448.                             }

  449.                                                                          

  450.                                                                          memset((char *)*pageBuf,0,k);

  451.                                                                          

  452.                             memcpy((char *)*pageBuf, (const char *)recvBuf + i, k); /* 用HTTP1.0是没http chunked response的.方便处理,否则还要分段接收网页,大的网页反正MCU也接不下. */

  453.                             vPortFree2  (recvBuf);

  454.                                                                          

  455.                                                                          

  456.                                                                          ((char *)*pageBuf)[k]='\0';

  457.                                                                          

  458.                                                                          

  459.                                                                          

  460.                             return HTTP_OK;

  461.                         }

  462.                     }

  463.                 }

  464.             }

  465.                                

  466.                                

  467.                        

  468.                                 printf("NOY_HTTP_OK:");

  469.                                

  470.                                 printf(recvBuf);

  471.                                



  472.             if(recvBuf != NULL)        {vPortFree2 (recvBuf);}



  473.                                

  474.                                

  475.                          }

  476.                        

  477.                        

  478.                                

  479.             return HTTP_NOT_200OK;

  480.         }

  481.         else

  482.         {

  483.             vPortFree2 (request);

  484.                            printf("HTTP_SERVER_REFUSE");

  485.             return HTTP_SERVER_REFUSE;

  486.         }



  487.     }

  488.     else

  489.     {

  490.                  

  491.                  printf("HTTPS_NOT_SUPPORT");

  492.                  

  493.         return HTTPS_NOT_SUPPORT;

  494.     }

  495. }

复制代码



上面这个实现了单片机调用网站地址并返回网页内容,下面就用这个函数具体调用百度http://vop.baidu.com/server_api? ... uid=%s&token=%s 接口,

哈,只能展示这么多,


void process_asr(){
       
        int err = HTTP_OK;
          uint16_t  ret_code1;
       
                  
                                        // printf("start ASR...");
                                                 
                                                            
                                //------------------------------------------------------------------------------------

                                 reflsh_token(0);
                       
                                         
                                        memset(urlgg,'\0',urlchar_maxlen);
                                          
                                          //dev_pid=1536是普通话,1537        =普通话(纯中文识别),dev_pid=1936是远场普通话
                                         sprintf(urlgg,"http://vop.baidu.com/server_api?dev_pid=1536&cuid=%s&token=%s",cuid,g_access_token);
                                       
       
                  
                  
                                                 err = WebClient(urlgg, reco_temp_ram, &abuf,1,reco_temp_ram_len);
                                                 
                                                 
                  
                                                 
                                                 if(abuf != NULL && err == HTTP_OK)
                                                  {





回复

使用道具 举报

1653

TA的帖子

0

TA的资源

版主

Rank: 6Rank: 6

发表于 2018-11-9 15:21:03 | 显示全部楼层
牛XXXXXX


回复

使用道具 举报

2182

TA的帖子

0

TA的资源

纯净的硅(高级)

Rank: 6Rank: 6

发表于 2018-11-9 15:37:20 | 显示全部楼层
是不是只有百度语音识别接口是开放的??最近看好几个人弄得都是这个接口


回复

使用道具 举报

您需要登录后才可以回帖 登录 | 注册

本版积分规则

  • 论坛活动 E手掌握

    扫码关注
    EEWORLD 官方微信

  • EE福利  唾手可得

    扫码关注
    EE福利 唾手可得

小黑屋|手机版|Archiver|电子工程世界 ( 京ICP证 060456 )

GMT+8, 2018-11-19 17:16 , Processed in 0.113541 second(s), 18 queries , Gzip On, MemCache On.

快速回复 返回顶部 返回列表