smartpi 1.1.4__py3-none-any.whl → 1.1.5__py3-none-any.whl

smartpi/servo.py

@@ -0,0 +1,178 @@
+# coding=utf-8
+import time
+from typing import List, Optional
+from smartpi import base_driver
+
+#小舵机控制 port:连接P端口；angle:角度0~270；
+def steer_angle(port:bytes,angle:bytes) -> Optional[bytes]:
+    servo_str=[0xA0, 0x0E, 0x01, 0x71, 0x00, 0xBE]
+    servo_str[0]=0XA0+port
+    servo_str[4]=angle
+#    response = base_driver.single_operate_sensor(servo_str,0)
+    time.sleep(0.005)
+    base_driver.write_data(0X01, 0X02, servo_str)
+#    if response == None:
+#        return None
+#    else:
+    return 0
+        
+#小舵机延时控制 port:连接P端口；angle:角度0~270；second:1~256
+def steer_angle_delay(port:bytes,angle:bytes,second:bytes) -> Optional[bytes]:
+    servo_str=[0xA0, 0x10, 0x01, 0x81, 0x00, 0x00, 0x81, 0x00, 0xBE]
+    servo_str[0]=0XA0+port
+    servo_str[4]=angle//256
+    servo_str[5]=angle%256
+    servo_str[7]=second
+#    response = base_driver.single_operate_sensor(servo_str,0)
+    time.sleep(0.005)
+    base_driver.write_data(0X01, 0X02, servo_str)
+#    if response == None:
+#        return None
+#    else:
+    return 0
+        
+#数字舵机设置转动方向(绝对角度) port:连接P端口；dir:0:不跨越0°;1:最短距离旋转;2:顺时针旋转;3:逆时针旋转
+def set_dir(port:bytes,dir:bytes) -> Optional[bytes]:
+    servo_str=[0xA0, 0x24, 0x01, 0x71, 0x00, 0xBE]
+    servo_str[0]=0XA0+port
+    servo_str[4]=dir
+#    response = base_driver.single_operate_sensor(servo_str,0)
+    time.sleep(0.005)
+    base_driver.write_data(0X01, 0X02, servo_str)
+#    if response == None:
+#        return None
+#    else:
+    return 0
+        
+#BE-9528数字舵机以速度转至角度 port:连接P端口；angle:角度(0~360)；speed:速度(0~100)；
+def set_angle_speed(port:bytes,angle:bytes,speed:bytes) -> Optional[bytes]:
+    servo_str=[0xA0, 0x0D, 0x01, 0x81, 0x00, 0x00, 0x81, 0x00, 0xBE]
+    servo_str[0]=0XA0+port
+    servo_str[4]=angle//256
+    servo_str[5]=angle%256
+    servo_str[7]=speed
+    #response = base_driver.single_operate_sensor(servo_str,0)
+    time.sleep(0.005)   
+    base_driver.write_data(0X01, 0X02, servo_str)
+#    if response == None:
+#        return None
+#    else:
+    return 0
+        
+#数字舵机转动到角度延时时间 port:连接P端口；angle:角度(0~360)；ms:延时时间(0~65535)；
+def set_angle_ms(port:bytes,angle:bytes,ms:int) -> Optional[bytes]:
+    servo_str=[0xA0, 0x11, 0x01, 0x81, 0x00, 0x00, 0x81, 0x00, 0x00, 0xBE]
+    servo_str[0]=0XA0+port
+    servo_str[4]=angle//256
+    servo_str[5]=angle%256
+    servo_str[7]=ms//256
+    servo_str[8]=ms%256
+#    response = base_driver.single_operate_sensor(servo_str,0)
+    time.sleep(0.005)
+    base_driver.write_data(0X01, 0X02, servo_str)
+#    if response == None:
+#        return None
+#    else:
+    return 0
+
+#数字舵机复位 port:连接P端口；
+def set_init(port:bytes) -> Optional[bytes]:
+    servo_str=[0xA0, 0x12, 0x01, 0xBE]
+    servo_str[0]=0XA0+port
+#    response = base_driver.single_operate_sensor(servo_str,0)
+    time.sleep(0.005)
+    base_driver.write_data(0X01, 0X02, servo_str)
+#    if response == None:
+#        return None
+#    else:
+    return 0
+        
+#获取数字舵机角度 port:连接P端口；
+def get_angle(port:bytes) -> Optional[bytes]:
+    servo_str=[0xA0, 0x13, 0x01, 0xBE]
+    servo_str[0]=0XA0+port
+    time.sleep(0.005)
+    response = base_driver.single_operate_sensor(servo_str,0)       
+    if response == None:
+        return None
+    else:
+        angle_data=response[4:-1]
+        angle_num=int.from_bytes(angle_data, byteorder='big', signed=True)
+        return angle_num
+        
+#数字舵机速度转动 port:连接P端口；
+def set_speed(port:bytes,speed:int) -> Optional[bytes]:
+    servo_str=[0xA0, 0x14, 0x01, 0x71, 0x00, 0xBE]
+    servo_str[0]=0XA0+port
+    if speed>100:
+        m_par=100
+    elif speed>=0 and speed<=100:
+        m_par=speed        
+    elif speed<-100:
+        m_par=156
+    elif speed<=0 and speed>=-100:
+        m_par=256+speed
+        
+    servo_str[4]=m_par
+#    response = base_driver.single_operate_sensor(servo_str,0)
+    time.sleep(0.005)
+    base_driver.write_data(0X01, 0X02, servo_str)
+#    if response == None:
+#        return None
+#    else:
+    return 0      
+        
+#数字舵机编码转动 port:连接P端口；code:编码(0~65535)；speed:速度(-100~100)；
+def set_code_speed(port:bytes,code:int,speed:int) -> Optional[bytes]:
+    servo_str=[0xA0, 0x15, 0x01, 0x81, 0x00, 0x00, 0x71, 0x00, 0xBE]
+    servo_str[0]=0XA0+port
+    
+    servo_str[4]=code//256
+    servo_str[5]=code%256
+    
+    if speed>100:
+        m_par=100
+    elif speed>=0 and speed<=100:
+        m_par=speed        
+    elif speed<-100:
+        m_par=156
+    elif speed<=0 and speed>=-100:
+        m_par=256+speed      
+    servo_str[7]=m_par
+
+#    response = base_driver.single_operate_sensor(servo_str,0)
+    time.sleep(0.005)
+    base_driver.write_data(0X01, 0X02, servo_str)
+#    if response == None:
+#        return None
+#    else:
+    return 0  
+
+#数字舵机编码值清零 port:连接P端口；
+def reset_encode(port:bytes) -> Optional[bytes]:
+    servo_str=[0xA0, 0x16, 0x01, 0xBE]
+    servo_str[0]=0XA0+port
+#    response = base_driver.single_operate_sensor(servo_str,0)
+    time.sleep(0.005)
+    base_driver.write_data(0X01, 0X02, servo_str)
+#    if response == None:
+#        return None
+#    else:
+    return 0
+        
+#获取数字舵机编码值 port:连接P端口；
+def get_encoder(port:bytes) -> Optional[bytes]:
+    servo_str=[0xA0, 0x17, 0x01, 0xBE]
+    servo_str[0]=0XA0+port
+    time.sleep(0.005)
+    response = base_driver.single_operate_sensor(servo_str,0)        
+    if response == None:
+        return None
+    else:
+        code_data=response[4:-1]
+        code_num=int.from_bytes(code_data, byteorder='big', signed=True)
+        return code_num
+
+
+
+

smartpi/temperature.py

@@ -0,0 +1,18 @@
+# coding=utf-8
+import time
+from typing import List, Optional
+from smartpi import base_driver
+
+
+#温度读取 port:连接P端口；正常返回：温度数据; 读取错误：-1
+def get_value(port:bytes) -> Optional[bytes]:
+    temp_str=[0XA0, 0X0C, 0X01, 0X71, 0X00, 0XBE]
+    temp_str[0]=0XA0+port
+    temp_str[4]=0 
+    time.sleep(0.005)
+    response = base_driver.single_operate_sensor(temp_str,0)
+    if response == None:
+        return None
+    else:
+        return response[4]
+        

smartpi/tencentcloud-speech-sdk-python/__init__.py

@@ -0,0 +1 @@
+# -*- coding:utf-8 -*-

smartpi/tencentcloud-speech-sdk-python/asr/flash_recognizer.py

@@ -0,0 +1,178 @@
+# -*- coding: utf-8 -*-
+import requests
+import hmac
+import hashlib
+import base64
+import time
+import random
+import os
+import json
+from common import credential
+
+#录音识别极速版使用
+class FlashRecognitionRequest:
+    def __init__(self, engine_type):
+        self.engine_type = engine_type
+        self.speaker_diarization = 0
+        self.hotword_id = ""
+        self.hotword_list = ""
+        self.input_sample_rate = 0
+        self.customization_id = ""
+        self.filter_dirty = 0
+        self.filter_modal = 0
+        self.filter_punc = 0
+        self.convert_num_mode = 1
+        self.word_info = 0
+        self.voice_format = ""
+        self.first_channel_only = 1
+        self.reinforce_hotword = 0
+        self.sentence_max_length = 0
+
+    def set_first_channel_only(self, first_channel_only):
+        self.first_channel_only = first_channel_only
+
+    def set_speaker_diarization(self, speaker_diarization):
+        self.speaker_diarization = speaker_diarization
+
+    def set_filter_dirty(self, filter_dirty):
+        self.filter_dirty = filter_dirty
+
+    def set_filter_modal(self, filter_modal):
+        self.filter_modal = filter_modal
+
+    def set_filter_punc(self, filter_punc):
+        self.filter_punc = filter_punc
+
+    def set_convert_num_mode(self, convert_num_mode):
+        self.convert_num_mode = convert_num_mode
+
+    def set_word_info(self, word_info):
+        self.word_info = word_info
+
+    def set_hotword_id(self, hotword_id):
+        self.hotword_id = hotword_id
+
+    def set_hotword_list(self, hotword_list):
+        self.hotword_list = hotword_list
+
+    def set_input_sample_rate(self, input_sample_rate):
+        self.input_sample_rate = input_sample_rate
+
+    def set_customization_id(self, customization_id):
+        self.customization_id = customization_id
+
+    def set_voice_format(self, voice_format):
+        self.voice_format = voice_format
+
+    def set_sentence_max_length(self, sentence_max_length):
+        self.sentence_max_length = sentence_max_length
+
+    def set_reinforce_hotword(self, reinforce_hotword):
+        self.reinforce_hotword = reinforce_hotword
+
+
+
+class FlashRecognizer:
+    '''
+    reponse:  
+    字段名            类型
+    request_id        string
+    status            Integer    
+    message           String    
+    audio_duration    Integer
+    flash_result      Result Array
+
+    Result的结构体格式为:
+    text              String
+    channel_id        Integer
+    sentence_list     Sentence Array
+
+    Sentence的结构体格式为:
+    text              String
+    start_time        Integer    
+    end_time          Integer    
+    speaker_id        Integer    
+    word_list         Word Array
+
+    Word的类型为:
+    word              String 
+    start_time        Integer 
+    end_time          Integer 
+    stable_flag：     Integer 
+    '''
+
+    def __init__(self, appid, credential):
+        self.credential = credential
+        self.appid = appid
+
+    def _format_sign_string(self, param):
+        signstr = "POSTasr.cloud.tencent.com/asr/flash/v1/"
+        for t in param:
+            if 'appid' in t:
+                signstr += str(t[1])
+                break
+        signstr += "?"
+        for x in param:
+            tmp = x
+            if 'appid' in x:
+                continue
+            for t in tmp:
+                signstr += str(t)
+                signstr += "="
+            signstr = signstr[:-1]
+            signstr += "&"
+        signstr = signstr[:-1]
+        return signstr
+
+    def _build_header(self):
+        header = dict()
+        header["Host"] = "asr.cloud.tencent.com"
+        return header
+
+    def _sign(self, signstr, secret_key):
+        hmacstr = hmac.new(secret_key.encode('utf-8'),
+                           signstr.encode('utf-8'), hashlib.sha1).digest()
+        s = base64.b64encode(hmacstr)
+        s = s.decode('utf-8')
+        return s
+
+    def _build_req_with_signature(self, secret_key, params, header):
+        query = sorted(params.items(), key=lambda d: d[0])
+        signstr = self._format_sign_string(query)
+        signature = self._sign(signstr, secret_key)
+        header["Authorization"] = signature
+        requrl = "https://"
+        requrl += signstr[4::]
+        return requrl
+
+    def _create_query_arr(self, req):
+        query_arr = dict()
+        query_arr['appid'] = self.appid
+        query_arr['secretid'] = self.credential.secret_id
+        query_arr['timestamp'] = str(int(time.time()))
+        query_arr['engine_type'] = req.engine_type
+        query_arr['voice_format'] = req.voice_format
+        query_arr['speaker_diarization'] = req.speaker_diarization
+        if req.hotword_id != "":
+            query_arr['hotword_id'] = req.hotword_id
+        if req.hotword_list != "":
+            query_arr['hotword_list'] = req.hotword_list
+        if req.input_sample_rate != 0:
+            query_arr['input_sample_rate'] = req.input_sample_rate
+        query_arr['customization_id'] = req.customization_id
+        query_arr['filter_dirty'] = req.filter_dirty
+        query_arr['filter_modal'] = req.filter_modal
+        query_arr['filter_punc'] = req.filter_punc
+        query_arr['convert_num_mode'] = req.convert_num_mode
+        query_arr['word_info'] = req.word_info
+        query_arr['first_channel_only'] = req.first_channel_only
+        query_arr['reinforce_hotword'] = req.reinforce_hotword
+        query_arr['sentence_max_length'] = req.sentence_max_length
+        return query_arr
+
+    def recognize(self, req, data):
+        header = self._build_header()
+        query_arr = self._create_query_arr(req)
+        req_url = self._build_req_with_signature(self.credential.secret_key, query_arr, header)
+        r = requests.post(req_url, headers=header, data=data)
+        return r.text

smartpi/tencentcloud-speech-sdk-python/asr/speech_recognizer.py

@@ -0,0 +1,311 @@
+# -*- coding: utf-8 -*-
+import sys
+import hmac
+import hashlib
+import base64
+import time
+import json
+import threading
+import websocket
+import uuid
+import urllib
+from common.log import logger
+
+
+def is_python3():
+    if sys.version > '3':
+        return True
+    return False
+
+
+#实时识别语音使用
+class SpeechRecognitionListener():
+    '''
+    reponse:  
+    on_recognition_start的返回只有voice_id字段。
+    on_fail 只有voice_id、code、message字段。
+    on_recognition_complete没有result字段。
+    其余消息包含所有字段。
+    字段名	类型	
+    code	Integer	
+    message	String	
+    voice_id	String
+    message_id	String
+    result	Result	
+    final	Integer	
+
+    Result的结构体格式为:
+    slice_type	Integer	
+    index	Integer	
+    start_time	Integer	
+    end_time	Integer	
+    voice_text_str	String	
+    word_size	Integer	
+    word_list	Word Array
+
+    Word的类型为:
+    word    String 
+    start_time Integer 
+    end_time Integer 
+    stable_flag：Integer 
+    '''
+
+    def on_recognition_start(self, response):
+        pass
+
+    def on_sentence_begin(self, response):
+        pass
+
+    def on_recognition_result_change(self, response):
+        pass
+
+    def on_sentence_end(self, response):
+        pass
+
+    def on_recognition_complete(self, response):
+        pass
+
+    def on_fail(self, response):
+        pass
+
+
+NOTOPEN = 0
+STARTED = 1
+OPENED = 2
+FINAL = 3
+ERROR = 4
+CLOSED = 5
+
+#实时识别语音使用
+class SpeechRecognizer:
+
+    def __init__(self, appid, credential, engine_model_type, listener):
+        self.result = ""
+        self.credential = credential
+        self.appid = appid
+        self.engine_model_type = engine_model_type
+        self.status = NOTOPEN
+        self.ws = None
+        self.wst = None
+        self.voice_id = ""
+        self.new_start = 0
+        self.listener = listener
+        self.filter_dirty = 0
+        self.filter_modal = 0
+        self.filter_punc = 0
+        self.convert_num_mode = 0
+        self.word_info = 0
+        self.need_vad = 0
+        self.vad_silence_time = 0
+        self.hotword_id = ""
+        self.hotword_list = ""
+        self.reinforce_hotword = 0
+        self.noise_threshold = 0
+        self.voice_format = 4
+        self.nonce = ""
+        self.replace_text_id = ""
+
+    def set_filter_dirty(self, filter_dirty):
+        self.filter_dirty = filter_dirty
+
+    def set_filter_modal(self, filter_modal):
+        self.filter_modal = filter_modal
+
+    def set_filter_punc(self, filter_punc):
+        self.filter_punc = filter_punc
+
+    def set_convert_num_mode(self, convert_num_mode):
+        self.convert_num_mode = convert_num_mode
+
+    def set_word_info(self, word_info):
+        self.word_info = word_info
+
+    def set_need_vad(self, need_vad):
+        self.need_vad = need_vad
+
+    def set_vad_silence_time(self, vad_silence_time):
+        self.vad_silence_time = vad_silence_time
+
+    def set_hotword_id(self, hotword_id):
+        self.hotword_id = hotword_id
+
+    def set_hotword_list(self, hotword_list):
+        self.hotword_list = hotword_list
+
+    def set_voice_format(self, voice_format):
+        self.voice_format = voice_format
+
+    def set_nonce(self, nonce):
+        self.nonce = nonce
+
+    def set_reinforce_hotword(self, reinforce_hotword):
+        self.reinforce_hotword = reinforce_hotword
+
+    def set_noise_threshold(self, noise_threshold):
+        self.noise_threshold = noise_threshold
+
+    def set_replace_text_id(self, replace_text_id):
+        self.replace_text_id = replace_text_id
+
+    def format_sign_string(self, param):
+        signstr = "asr.cloud.tencent.com/asr/v2/"
+        for t in param:
+            if 'appid' in t:
+                signstr += str(t[1])
+                break
+        signstr += "?"
+        for x in param:
+            tmp = x
+            if 'appid' in x:
+                continue
+            for t in tmp:
+                signstr += str(t)
+                signstr += "="
+            signstr = signstr[:-1]
+            signstr += "&"
+        signstr = signstr[:-1]
+        return signstr
+
+    def create_query_string(self, param):
+        signstr = "wss://asr.cloud.tencent.com/asr/v2/"
+        for t in param:
+            if 'appid' in t:
+                signstr += str(t[1])
+                break
+        signstr += "?"
+        for x in param:
+            tmp = x
+            if 'appid' in x:
+                continue
+            for t in tmp:
+                signstr += str(t)
+                signstr += "="
+            signstr = signstr[:-1]
+            signstr += "&"
+        signstr = signstr[:-1]
+        return signstr
+
+    def sign(self, signstr, secret_key):
+        hmacstr = hmac.new(secret_key.encode('utf-8'),
+                           signstr.encode('utf-8'), hashlib.sha1).digest()
+        s = base64.b64encode(hmacstr)
+        s = s.decode('utf-8')
+        return s
+
+    def create_query_arr(self):
+        query_arr = dict()
+
+        query_arr['appid'] = self.appid
+        query_arr['sub_service_type'] = 1
+        query_arr['engine_model_type'] = self.engine_model_type
+        query_arr['filter_dirty'] = self.filter_dirty
+        query_arr['filter_modal'] = self.filter_modal
+        query_arr['filter_punc'] = self.filter_punc
+        query_arr['needvad'] = self.need_vad
+        query_arr['convert_num_mode'] = self.convert_num_mode
+        query_arr['word_info'] = self.word_info
+        if self.vad_silence_time != 0:
+            query_arr['vad_silence_time'] = self.vad_silence_time
+        if self.hotword_id != "":
+            query_arr['hotword_id'] = self.hotword_id
+        if self.hotword_list != "":
+            query_arr['hotword_list'] = self.hotword_list
+        if self.replace_text_id != "":
+            query_arr['replace_text_id'] = self.replace_text_id
+        query_arr['secretid'] = self.credential.secret_id
+        query_arr['voice_format'] = self.voice_format
+        query_arr['voice_id'] = self.voice_id
+        query_arr['timestamp'] = str(int(time.time()))
+        if self.nonce != "":
+            query_arr['nonce'] = self.nonce
+        else:
+            query_arr['nonce'] = query_arr['timestamp']
+        query_arr['expired'] = int(time.time()) + 24 * 60 * 60
+        query_arr['reinforce_hotword'] = self.reinforce_hotword
+        query_arr['noise_threshold'] = self.noise_threshold
+        return query_arr
+
+    def stop(self):
+        if self.status == OPENED: 
+            msg = {}
+            msg['type'] = "end"
+            text_str = json.dumps(msg)
+            self.ws.sock.send(text_str)
+        if self.ws:
+            if self.wst and self.wst.is_alive():
+                self.wst.join()
+        self.ws.close()
+        
+
+    def write(self, data):
+        while self.status == STARTED:
+            time.sleep(0.1)
+        if self.status == OPENED: 
+            self.ws.sock.send_binary(data)
+
+    def start(self):
+        def on_message(ws, message):
+            response = json.loads(message)
+            response['voice_id'] = self.voice_id
+            if response['code'] != 0:
+                logger.error("%s server recognition fail %s" %
+                             (response['voice_id'], response['message']))
+                self.listener.on_fail(response)
+                return
+            if "final" in response and response["final"] == 1:
+                self.status = FINAL
+                self.result = message
+                self.listener.on_recognition_complete(response)
+                logger.info("%s recognition complete" % response['voice_id'])
+                return
+            if "result" in response.keys():
+                if response["result"]['slice_type'] == 0:
+                    self.listener.on_sentence_begin(response)
+                    return
+                elif response["result"]["slice_type"] == 2:
+                    self.listener.on_sentence_end(response)
+                    return
+                elif response["result"]["slice_type"] == 1:
+                    self.listener.on_recognition_result_change(response)
+                    return
+
+        def on_error(ws, error):
+            if self.status == FINAL :
+                return
+            logger.error("websocket error %s  voice id %s" %
+                         (format(error), self.voice_id))
+            self.status = ERROR
+
+        def on_close(ws):
+            self.status = CLOSED
+            logger.info("websocket closed  voice id %s" %
+                          self.voice_id)
+
+        def on_open(ws):
+            self.status = OPENED
+
+        query_arr = self.create_query_arr()
+        if self.voice_id == "":
+            query_arr['voice_id'] = str(uuid.uuid1())
+            self.voice_id = query_arr['voice_id']
+        query = sorted(query_arr.items(), key=lambda d: d[0])
+        signstr = self.format_sign_string(query)
+
+        autho = self.sign(signstr, self.credential.secret_key)
+        requrl = self.create_query_string(query)
+        if is_python3():
+            autho = urllib.parse.quote(autho)
+        else:
+            autho = urllib.quote(autho)
+        requrl += "&signature=%s" % autho
+        self.ws = websocket.WebSocketApp(requrl,  None,
+                on_error=on_error, on_close=on_close, on_message=on_message)
+        self.ws.on_open = on_open
+        self.wst = threading.Thread(target=self.ws.run_forever)
+        self.wst.daemon = True
+        self.wst.start()
+        self.status = STARTED
+        response = {}
+        response['voice_id'] = self.voice_id
+        self.listener.on_recognition_start(response)
+        logger.info("%s recognition start" % response['voice_id'])