随心录 2017-10-21T10:09:50.000Z /blog/ 随心录Plus Hexo 树莓派之语音识别与语音合成 /blog/2017/10/07/树莓派之语音识别与语音合成/ 2017-10-07T13:45:20.000Z 2017-10-21T10:09:50.000Z 　　入手树莓派也有两年有余了，其实有很多有趣的想法，比如智能小车，智能感知，智能捕捉等等，也买了不少传感器件，组装小车的配件都买了，买组件的激情到是很高，但缺少了去实现动力（是懒吧），也就一直尘封着，偶尔翻出来见见光之后就又再次封装了起来！

　　偶尔的一次看到了 百度语音-永久免费智能语音开放平台 感觉挻有趣的，于是决定搞起，至于动力，也许看过 树莓派之 RGB LED 跑马灯 就会明白，就不在累述，也是分享中的其中一个示例，此示例整体来说实现相对比较容易，百度语音也已为 Python 提供了在线访问的 RestApi SDK，所以需要我们自己来实现的内容相对还是比较少的。同时小米也推出了自己的 水滴平台 [水滴平台为可以落地的小米全生态硬件产品提供语音服务，使用它可以为硬件设备提供功能，使用户能够以更直观的方式使用语音与设备进行交互。] 我也算是个米粉，这里就不多说了，有兴趣的同学可以了解一下 ^_^ 。

　　软件工程师的工作不是写程序， 而是合理使用工具解决问题，对此个人是比较认同的，术业有专攻，我们只需专注于做自己想做的一块，其余的就由专业的人去完成。于 Python 而言，其提供了很强大类库供我们去使用以及去定制化自己需要的！

　　说了这么多，先让我们了解一下此次示例使用的元件 树莓派、USB 声卡、百度语音 API、开发语言是 Python （由于没有 USB 声卡，只好在笔记本上进行了演示，查看资料说树莓派端对 pyaudio 并不兼容，可以用 arecord 进行录音，目前为止还未在树莓派上做测试，当前也就只有按照 Win10 测试过程来讲了）。

　　首先需要配置 百度语音 SDK 类库，执行 sudo pip install baidu-aip ，具体使用可以查看官方 在线语音识别 Python SDK 文档 ；执行 sudo apt-get install python-wave* 安装 wave 类库，执行 sudo pip install pyaudio 安装 pyaudio 类库 （Windows系统f需要使用 pip 执行），相关环境安装好后，就可以编写代码啦。
　
　　本示例分为语音识别和语音合成以及本地录音功能，先了解一下文件目录结构：

1
2
3
4
5
|——test.py           # 测试文件
|——speech            # 语音 API 包目录
|  |——__init__.py    # 语音 API 导出类
|  |——rpi_record.py  # 本地录音 API
|  |——rpi_speech.py  # 百度语音识别、语音合成功能封装

　
　　来看一下 rpi_speech.py 文件，下面代码中的常量APP_ID 在百度云控制台中创建，常量 API_KEY 与 SECRET_KEY 是在创建完毕应用后，系统分配给用户的，均为字符串，用于标识用户，为访问做签名验证，可在 AI 服务控制台中的 应用列表 中查看，如果还没有应用则需要先创建新应用，具体示例代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
  百度语音功能封装
"""
import sys
# 引入百度 Speech SDK
from aip import AipSpeech
# 定义常量
APP_ID = '你的 App ID'
API_KEY = '你的 Api Key'
SECRET_KEY = '你的 Secret Key'
def speech(file_path):
    """
    语音识别
    ---
    *file_path 音频路径*
    原始语音的录音格式目前只支持评测 8k/16k 采样率 16bit 位深的单声道语音
    压缩格式支持：pcm（不压缩）、wav、amr
    系统支持语言种类：中文（zh）、粤语（ct）、英文（en）
    """
    print(file_path, "开始语音识别")
    file_stream = _get_file_content(file_path)
    result = speechs(file_stream)
    print("语音识别结束")
    return result
def speechs(file_stream):
    """
    语音识别
    ---
    *file_stream 音频流*
    原始语音的录音格式目前只支持评测 8k/16k 采样率 16bit 位深的单声道语音
    压缩格式支持：pcm（不压缩）、wav、amr
    系统支持语言种类：中文（zh）、粤语（ct）、英文（en）
    """
    """
     初始化AipSpeech对象
    """
    baiduAipSpeech = AipSpeech(APP_ID, API_KEY, SECRET_KEY)
    # 在线请求百度语音识别
    result = baiduAipSpeech.asr(file_stream, "wav", 16000, {'lan': 'zh'})
    return result
def _get_file_content(file_path):
    """
     读取文件
    """
    with open(file_path, 'rb') as fp:
        return fp.read()
def synthesis(text, file_path):
    """
    语音合成
    ----
    *text 需要合成语音的文字*
    *file_path 保存语音合成文件路径*
    """
    """
     初始化AipSpeech对象
    """
    baiduAipSpeech = AipSpeech(APP_ID, API_KEY, SECRET_KEY)
    print("开始语音合成")
    result = baiduAipSpeech.synthesis(
        text, 'zh', 1, {"spd": 5, "per": 4, "pit": 5})
    print("语音合成结束")
    # 识别正确返回语音二进制 错误则返回dict 参照下面错误码
    if not isinstance(result, dict):
        with open(file_path, 'wb') as f:
            f.write(result)
        print(file_path, ",语音合成保存成功")
        return True
    print(result, ",语音保存失败")
    return False

　
　　接下来是 rpi_record.py 文件，本地录音 API，本示例是使用 pyaudio 类库实现的，具体示例代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
本地录音 API
"""
import base64
import datetime
import os
import sys
import time
import wave
import numpy as np
from pyaudio import PyAudio, paInt16
class RpiApiRecord():
    """
        本地录音 API
        ---
        原始语音的录音格式目前只支持评测 8k/16k 采样率 16bit 位深的单声道语音
        压缩格式支持：pcm（不压缩）、wav、amr
        系统支持语言种类：中文（zh）、粤语（ct）、英文（en）
    """
    __NUM_SAMPLES = 2000      # pyAudio内部缓存的块的大小
    __SAMPLING_RATE = 16000   # 取样频率
    __LEVEL = 2000            # 声音保存的阈值
    def __init__(self, compressed_fromat=".wav"):
        """
        *compressed_fromat 压缩格式支持：pcm（不压缩）、wav、amr*
        """
        self.__compressed_fromat = compressed_fromat
    def __save_wave_file(self, file_patch, data):
        """将data中的数据保存到名为filename的WAV文件中"""
        wf = wave.open(file_patch, 'wb')
        wf.setnchannels(1)
        wf.setsampwidth(2)
        wf.setframerate(self.__SAMPLING_RATE)
        wf.writeframes(b"".join(data))
        wf.close()
    def record(self, total_time=5):
        """
        开启声音输入
        ----
        *total_time 录音时长，单位秒，默认5秒*
        返回结果：音频路径
        """
        save_buffer = []
        first = True
        begin_time = 0
        temp = 0
        pa = PyAudio()
        stream = pa.open(format=paInt16, channels=1, rate=self.__SAMPLING_RATE, input=True,
                         frames_per_buffer=self.__NUM_SAMPLES)
        while True:
            if first:
                # 读入NUM_SAMPLES个取样
                string_auto_data = stream.read(self.__NUM_SAMPLES)
                # 将读入的数据转换为数组
                audio_data = np.fromstring(string_auto_data, dtype=np.long)
                temp = np.max(audio_data)
                print(temp)
            if temp > self.__LEVEL and first:
                first = False
                temp = 0
                print("检测到信号，五秒后开始")
                for i in range(1, 6, 1):
                    print(i, "s")
                    time.sleep(1)
                print('开始录音,计时', total_time, '秒')
                begin_time = time.time()
            if first:
                continue
            # NUM_SAMPLES 取样
            string_auto_data = stream.read(self.__NUM_SAMPLES)
            save_buffer.append(string_auto_data)
            time_count = time.time() - begin_time
            print("录音进行中，第", time_count, "s")
            if time_count > total_time:
                """
                压缩格式支持
                pcm（不压缩）、wav、amr
                """
                file_path = sys.path[0] + "\\" + datetime.datetime.now().strftime(
                    "%Y-%m-%d_%H_%M_%S") + self.__compressed_fromat
                self.__save_wave_file(file_path, save_buffer)
                save_buffer = []
                first = True
                print(file_path, "保存成功正在进行语音识别")
                return file_path

　
　　然后就是导出类文件 __init__.py，具体示例代码如下：

1
2
3
4
5
6
7
8
9
10
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
音频 API
"""
from .rpi_record import RpiApiRecord
from .rpi_speech import speech, speechs
__version__ = "0.0.0.1"

　
　　最后就是见证奇迹的时刻了，是不是有些激动，创建 test.py 文件，具体示例代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import datetime
import sys
from speech import RpiApiRecord, rpi_speech
def test_speech():
    """
    百度语音识别功能
    ----
    *返回：语音识别的结果*
    """
    file_path = sys.path[0] + "\\2017-09-22_09_37_45.wav"
    """调用百度语音识别接口，接收语音识别结果"""
    result = rpi_speech.speech(file_path)
    print(result)
    return result
def test_speechs():
    """
    测试本地录音，百度语音识别功能
    ----
    *返回：语音识别的结果*
    """
    # 初始化 本地录音PAI RpiApiRecord
    api_record = RpiApiRecord(".wav")
    """接收本地录音存放地址"""
    file_path = api_record.record(10)
    """调用百度语音识别接口，接收语音识别结果"""
    result = rpi_speech.speech(file_path)
    print(result)
    return result
def test_synthesis():
    """
    测试百度语音合成功能
    ----
    *返回：语音合成文件路径*
    """
    """保存语音合成文件路径"""
    file_path = sys.path[0] + "\\" + datetime.datetime.now().strftime(
        "%Y-%m-%d_%H_%M_%S") + ".wav"
    result = rpi_speech.synthesis("你好吗，最近过得怎么样呢，嘿嘿！", file_path)
    print("语音合成结果：", result)
    return file_path
def test_synthesis_speech():
    """
    百度语音合成后，使用百度语音识别
    """
    file_path = test_synthesis()
    """调用百度语音识别接口，接收语音识别结果"""
    result = rpi_speech.speech(file_path)
    print(result)
if __name__ == "__main__":
    print("进入 main 方法")
    # test_speech()
    test_speechs()
    # test_synthesis()
    # test_synthesis_speech() # 这个示例并没有成功，总是返回错误码：3301（请上传清晰的音频），不知道是不是因为百度对音频做了处理
    print("离开 main 方法")

　
　　最基础的语音识别是不是感觉挻容易实现，其实可以在此基础上做些扩展，比如当前我想的，可以通过声音定位声源，测试声距，通过测定声源位置，启动并驱动电机，使摄像头捕捉人像并跟踪，同时摄像头也可以识别出人脸等，是不是很有画面感呢！再者还可以实现人机对话，声音感知等等，越想是不是越激动啦，过程还是需要自己动手去实现，乐趣更多的还是在实践的过程中 ^_^。
　
参考文档：

文中图片引用：

]]> <p>　　入手树莓派也有两年有余了，其实有很多有趣的想法，比如智能小车，智能感知，智能捕捉等等，也买了不少传感器件，组装小车的配件都买了，买组件的激情到是很高，但缺少了去实现动力<em>（是懒吧）</em>，也就一直尘封着，偶尔翻出来见见光之后就又再次封装了起来！</p> <p>　　偶尔的一次看到了 <a href="http://yuyin.baidu.com/" target="_blank" rel="external">百度语音-永久免费智能语音开放平台</a> 感觉挻有趣的，于是决定搞起，至于动力，也许看过 <a href="/blog/2017/10/07/树莓派之-RGB-LED-跑马灯/">树莓派之 RGB LED 跑马灯</a> 就会明白，就不在累述，也是分享中的其中一个示例，此示例整体来说实现相对比较容易，百度语音也已为 Python 提供了在线访问的 <a href="http://yuyin.baidu.com/sdk" target="_blank" rel="external"> RestApi SDK</a>，所以需要我们自己来实现的内容相对还是比较少的。同时小米也推出了自己的 <a href="https://shuidi.mi.com/" target="_blank" rel="external">水滴平台</a> <em>[水滴平台为可以落地的小米全生态硬件产品提供语音服务，使用它可以为硬件设备提供功能，使用户能够以更直观的方式使用语音与设备进行交互。]</em> 我也算是个米粉，这里就不多说了，有兴趣的同学可以了解一下 ^_^ 。</p> <p>　　<strong>软件工程师的工作不是写程序， 而是合理使用工具解决问题</strong>，对此个人是比较认同的，术业有专攻，我们只需专注于做自己想做的一块，其余的就由专业的人去完成。于 Python 而言，其提供了很强大类库供我们去使用以及去定制化自己需要的！<br></p> 树莓派之 RGB LED 跑马灯 /blog/2017/10/07/树莓派之-RGB-LED-跑马灯/ 2017-10-07T06:48:21.000Z 2017-10-21T10:09:24.000Z 　　很早之前就有写过使用 Arduino 开发板（C++） 和 树莓派的 GPIO（Python） 控制 LED 灯相关示例，只是比较的零碎，完全是个人兴趣驱动，当时过程中遇到的一些问题，也没有很好的记录下来，由于当时比较懒吧（不过，现在仍是依旧）。

　　最近由于工作需要，于是乎又拾起了兴趣，拼凑了一个相对比较完善的示例，过程中也入了一些坑，由于对 RGB 全彩 LED 特性不是很了解，特别在调试时，用了不少时间，真的是眼睛快被闪瞎了！

　　之所以能更加完善，完全是因为需要为组内来一场生动的分享（是不是真的生动，我也无从而知了），分享主题为 趣玩 Python，Python 还能玩 LED？嗯，是的，既然是趣玩，当然是拿些大家不太熟悉，但又不太陌生的东东来玩玩吖，于是乎我拿出了百分之一百二精力，一个月的时间里，时常搞到凌晨一二点，第二天又需早早爬起来上班，当然啦，该示例只是其中之一，其实在较早的时候，这样的作息也属于常态，加班几乎成为了程序员的代名词，问我累不累，不，怎么会累呢，一切为工作！哈哈，价值观还可以吧！其实更多的是习惯了这样的生活，也就不觉得怎样了！

　　好了，回归正题，先了解一下，示例中使用的元件 树莓派、RGB LED、220Ω 电阻、面包板，公母杜邦线，开发语言是 Python （Python 分 2.X 版本 和 3.X 版本，语法上是有区别的，示例使用的 Python3.X 版本），不得不说，这是我做过的 PPT 中最好看和最满意的了。

　
　　了解过 树莓派 的同学应该知道，树莓派之所以很畅销，个人认识最大的原因是树莓派集成了 丰富的 GPIO（General Purpose Input-Output），它们是程序与外部世界对话的窗口，增强了趣味性。再有就是强大的开源社区以及第三方对树莓派大力支持，这也是当下最有趣味的板子之一。本示例是使用 Python，树莓派搭载的系统是基于 Debian Stretch 的 Raspbian，Python 和 Linux 有者强大的开源社区。掌握了这两样工具的工具（元工具），网上遍地是趁手的兵器。先让我们了解一下树莓派的 GPIO 引脚。

　　RGB LED 多元的特性，可以通过程序实现色彩绚丽灯光效果，不过，在使用之前需要先确认一下手中的 RGB LED 是共阴还是共阳，所谓共阴就是公共端接负极 -，而共阳就是公共端接正极 +，一般商品介绍上会有说明，或者如果看到 RGB LED 的引脚有 GND 字样，说明是共阴的，也可以自行测试；这点很重要，这会影响接下来的灯光效果实现及调试。调试时建议串连一个 220Ω 的电阻，防止因电流过大而烧坏了 RGB LED。

　　 首先确保树莓派安装了 Python3.X ，一般系统会自带 Pthon2.7 以及 RPi.GPIO 模块程序包（该包提供了一个在 Raspberry Pi 中控制 GPIO 的类），如果未安装，则执行 sudo apt-get install python3 进行安装 Python3，执行 sudo apt-get install RPi.GPIO 安装 RPi.GPIO 模块程序包（Python 是区分大小写的，你没看错，就是 RPi.GPIO ，i 是小写的，写错了会报错的），必要的软件安装好，就可以愉快的编码了。

　　开始之前还是需要再了解一下 PWM，PWM 脉冲宽度调制的英文缩写，在一个脉冲循环内，通电时间相对于总时间所占的比例叫占空比，方波的占空比为50%，占空比为0.5，说明正电平所占时间为0.5个周期。是不是似懂非懂，在本示例只需要知道 PWM 可以控制 RGB LED 亮度即可，但真正做一个产品时，对相关知识点不能完全明白的掌握，会遇到不少麻烦，也是会有很大的风险的。

　　相信很多同学对万能充电器，在熟悉不过了，此时就不得不说那时是 诺基亚 王朝，是否还记得高中时为了给手机充器，不得不像防贼似的防着班主任，话说你的东东有没有被班主任撞见过呢！对，该示例就是实现那迷人的万能充电器里面的跑马灯，嗯，那我们开始吧，执行 sudo nano led.py 创建一个名称为 led.py 文件， 将下面的代码复制到该文件中保存，执行 sudo python led.py 就可以看到效果了，聪明的你对 RGB LED 的接线应该不在话下吧，具体示例代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import RPi.GPIO as GPIO
import time
import random
# 指定引脚 共阴LED（R、G、B、-）
R, G, B, GND = 11, 13, 15, 9
# BOARD 编码方式
GPIO.setmode(GPIO.BOARD)
# 设置引脚为输出模式
GPIO.setup(R, GPIO.OUT)
GPIO.setup(G, GPIO.OUT)
GPIO.setup(B, GPIO.OUT)
# PWM 来制作呼吸灯效果，创建频率为 70HZ 的 PWM 实例
pwmR = GPIO.PWM(R, 70)
pwmG = GPIO.PWM(G, 70)
pwmB = GPIO.PWM(B, 70)
# 开始脉宽调制，参数范围为： (0.0 <= dc <= 100.0)
# 共阴时，方波的占空比 100 代表全亮，0 代表全暗
# 共阳时，方波的占空比 100 代表全暗，0 代表全亮
pwmR.start(50)
pwmG.start(50)
pwmB.start(50)
def open_led():
    """开启 LED"""
    try:
        count = 0
        while True:
            count = count + 1
            if count > 1:
                return
            t = 0.4
            # 红色灯全亮，绿灯，蓝灯全暗（红色）
            set_change_duty_cycle(100, 0, 0, t)
            # 绿色灯全亮，红灯，蓝灯全暗（绿色）
            set_change_duty_cycle(0, 100, 0, t)
            # 蓝色灯全亮，红灯，绿灯全暗（蓝色）
            set_change_duty_cycle(0, 0, 100, t)
            # 红灯，绿灯全亮，蓝灯全暗（黄色）
            set_change_duty_cycle(100, 100, 0, t)
            # 红灯，蓝灯全亮，绿灯全暗（洋红色）
            set_change_duty_cycle(100, 0, 100, t)
            # 绿灯，蓝灯全亮，红灯全暗（青色）
            set_change_duty_cycle(0, 100, 100, t)
            # 红灯，绿灯，蓝灯全亮（白色）
            set_change_duty_cycle(100, 100, 100, t)
            # 调整红绿蓝LED的各个颜色的亮度组合出各种颜色
            for_set_change_duty_cycle()
    except Exception as e:
        print(e)
    finally:
        stop()
def set_change_duty_cycle(_r, _g, _b, _t):
    "设置 RGB 亮度"
    pwmR.ChangeDutyCycle(_r)
    pwmG.ChangeDutyCycle(_g)
    pwmB.ChangeDutyCycle(_b)
    time.sleep(_t)
def set_single_change_duty_cycle(_pwm, _l, _t):
    """设置单 RGB 亮度"""
    _pwm.ChangeDutyCycle(_l)
    time.sleep(_t)
def for_set_change_duty_cycle():
    "设置 RGB 亮度-跑马灯"
    t = 0.01
    pwmG.ChangeDutyCycle(0)
    pwmB.ChangeDutyCycle(0)
    for r in range(0, 101, 1):  # 红全亮，绿、蓝全暗
        set_single_change_duty_cycle(pwmR, r, t)
    for r in range(0, 101, 1):  # 红、绿、蓝全暗
        set_single_change_duty_cycle(pwmR, 100 - r, t)
    pwmR.ChangeDutyCycle(0)
    pwmB.ChangeDutyCycle(0)
    for g in range(0, 100, 1):  # 绿全亮，红、蓝全暗
        set_single_change_duty_cycle(pwmG, g, t)
    for g in range(0, 100, 1):  # 红、绿、蓝全暗
        set_single_change_duty_cycle(pwmG, 100 - g, t)
    pwmR.ChangeDutyCycle(0)
    pwmG.ChangeDutyCycle(0)
    for b in range(0, 101, 1):  # 蓝全亮，红、绿全暗
        set_single_change_duty_cycle(pwmB, b, t)
    for b in range(0, 101, 1):  # 红、绿、蓝全暗
        set_single_change_duty_cycle(pwmB, 100 - b, t)
    count, denominator = 0, 7
    for n in range(0, 101, 10):
        print(n)
        count += 1
        if count % denominator == 0:  # 红全亮，绿、蓝全暗
            for g in range(0, 101, 1):
                set_change_duty_cycle(g, g, 100 - g, t)
            for g in range(0, 101, 1):
                set_single_change_duty_cycle(pwmG, 100 - g, t)
        if count % denominator == 1:  # 绿全亮，红、蓝全暗
            for b in range(0, 101, 1):
                set_change_duty_cycle(100 - b, b, b, t)
            for b in range(0, 101, 1):
                set_single_change_duty_cycle(pwmB, 100 - b, t)
        if count % denominator == 2:  # 蓝全亮，红、绿全暗
            for r in range(0, 101, 1):
                set_change_duty_cycle(r, 100 - r, r, t)
            for r in range(0, 101, 1):
                set_single_change_duty_cycle(pwmR, 100 - r, t)
        if count % denominator == 3:  # 红全亮
            for g in range(0, 101, 1):
                set_single_change_duty_cycle(pwmR, g, t)
        if count % denominator == 4:  # 绿全亮
            for b in range(0, 101, 1):
                set_single_change_duty_cycle(pwmG, b, t)
        if count % denominator == 5:  # 红、绿、蓝全暗
            for r in range(0, 101, 1):
                set_change_duty_cycle(100 - r, 100 - r, 100 - r, t)
        if count % denominator == 6:  # 红、绿、蓝全暗
            set_change_duty_cycle(50, 50, 50, t)
            for r in range(0, 61, 1):  # 红、绿、蓝随机
                set_change_duty_cycle(random.choice([0, 50, 0, 0, 100, 0, 100]), random.choice(
                    [100, 50, 0, 0, 100, 100, 0, 0]), random.choice([50, 50, 50, 0, 100, 0, 100]), t + 0.08)
            for r in range(0, 101, 1):  # 红、绿、蓝全暗
                set_change_duty_cycle(100 - r, 100 - r, 100 - r, t)
    for r in range(0, 101, 1):  # 红、绿、蓝全暗
        set_change_duty_cycle(100 - r, 100 - r, 100 - r, t)
def stop():
    """停止闪烁，并释放资源"""
    pwmR.stop()
    pwmG.stop()
    pwmB.stop()
    GPIO.cleanup()  # 防止烧坏板子
if __name__ == "__main__":
    open_led()

　
参考文档：

]]> <p> 　　很早之前就有写过使用 Arduino 开发板（<code>C++</code>） 和 树莓派的 GPIO（<code>Python</code>） 控制 LED 灯相关示例，只是比较的零碎，完全是个人兴趣驱动，当时过程中遇到的一些问题，也没有很好的记录下来，由于当时比较懒吧<em>（不过，现在仍是依旧）</em>。</p> <p> 　　最近由于工作需要，于是乎又拾起了兴趣，拼凑了一个相对比较完善的示例，过程中也入了一些坑，由于对 RGB 全彩 LED 特性不是很了解，特别在调试时，用了不少时间，真的是眼睛快被闪瞎了！</p> <p> 　　之所以能更加完善，完全是因为需要为组内来一场生动的分享<em>（是不是真的生动，我也无从而知了）</em>，分享主题为 <strong>趣玩 Python</strong>，Python 还能玩 LED？嗯，是的，既然是趣玩，当然是拿些大家不太熟悉，但又不太陌生的东东来玩玩吖，于是乎我拿出了百分之一百二精力，一个月的时间里，时常搞到凌晨一二点，第二天又需早早爬起来上班，当然啦，该示例只是其中之一，其实在较早的时候，这样的作息也属于常态，<strong>加班</strong>几乎成为了程序员的代名词，问我累不累，不，怎么会累呢，一切为工作！哈哈，价值观还可以吧！其实更多的是习惯了这样的生活，也就不觉得怎样了！<br></p> 树莓派搭建 GitLab /blog/2017/10/05/莓派搭建-GitLab/ 2017-10-05T12:43:35.000Z 2017-10-21T10:09:11.000Z 　　不记得是什么时候，在树莓派上搭建了供个人使用的 Git 仓库，不是 GitLab 或者是其他 Git 管理平台，就是最原生的 Git 服务，也不觉得有什么奇怪，就这样使用了很久 ：)

　　八天国庆假期，少了往年游玩的激情，也没有其他什么事情，整日宅在自己的小窝里躲避风和雨，省得过于清闲而又浮想翩翩，于是乎想利用树莓派搭建 GIT 管理平台；当下最为流行开源平台为 GitLab 吧，日常工作中几乎每天与其打交道（无外乎最多的就是 pull、push 吧，偶尔配置一二，算不上熟络）。

首先让我们先了解安装 GitLab 的需求

操作系统
  • GitLab 是专为 Unix 操作系统开发的。 GitLab 不可 运行在 Windows 操作系统上，而且近期也没有考虑支持 Windows。可以在 Linux 虚拟机上或者 Docker 上来安装 GitLab。
CPU
  • 1 核心 CPU 最多支持100个用户，所有的 Workers 和后台任务都在同一个核心工作这将导致 GitLab 服务响应会有点缓慢。
  • 2核心 支持500用户，这也是 官方推荐 的最低标准。
    …
Memory
  • 1GB 物理内存 + 3GB 交换分区 是最低的要求，但我们 强烈反对 使用这样的配置。 查看下面 Unicorn Workers 章节获取更多建议。
  • 2GB 物理内存 + 2GB 交换分区 支持100用户，但服务响应会很慢。
  • 4GB 物理内存 支持100用户，也是 官方推荐 的配置。
    …

再来了解 树莓派 配置

系统
CPU
  • 四核 1.2GHz 64位 ARM Cortex-A53 CPU
Memory
  • 1GB RAM
Other
  • BCM43438 无线局域网和蓝牙低功耗（BLE）

GitLab 安装

　　嗯，是的，官方推荐的最低配置是 CPU 2核，4G 物理内存，能正常访问 GitLab 而不会太缓慢，这点很重要，在调试过程中也被这个坑了良久；而能运行 GitLab 最低配置是 CPU 1核，内存 1G + 3GB 交换分区 （比 1G 还小的内存估计也不好找了吧），嗯，是的，是能运行，在不考虑性能的前提下，而且也很是考验使用者的耐心，堪比 2G 时代的速度，不多说了，忍，自行体会吧！

　　了解了软硬件的需求，接下来按照 官方文档 进行安装 GitLab ，这一步应该没什么问题，要选择对应的系统版本，我的硬件是树莓派，选择的 raspberry-pi-2 版本，安装到最后应该会看到打印的 GitLab 官方 Logo ，此时说明已经安装完成。

如果在安装中下载过慢，可以直接使用迅雷加速下载对应的版本 GitLab 安装文件，然后上传到系统中安装路径中进行安装，如 Debian 文件路径 /var/cache/apt/archives/partial。

GitLab 配置

接下来就对 GitLab 进行必要的配置，访问地址、存储地址等，打开 GitLab 配置文件【官方配置文档】
　　sudo nano /etc/gitlab/gitlab.rb

1、配置 GitLab 域名，启用 HTTPS 时，防火墙必须打开端口 443 以允许入站 HTTPS 流量，可以使用 防火墙配置工具 进行管理。
　　external_url 'https://192.168.2.222' # 我配置的是 HTTPS 请求，此处换成你对应的域名或 IP 地址

2、将 HTTP 重定向到 HTTPS， 默认情况下，当您以 https 开头指定一个 external_url 时，Nginx 将不再侦听端口 80 上未加密的 HTTP 流量。如果要将所有 HTTP 流量重定向到 HTTPS，您可以使用该 redirect_http_to_https 设置。
　　nginx['enable'] = true # 开启代理
　　nginx['redirect_http_to_https'] = true # 开启将 HTTP 重定向到 HTTPS
　　nginx['redirect_http_to_https_port'] = 80 # 将 HTTP 80 端口重定向到 HTTPS

3、更改 SSL 证书位置，首先你需要有证书，如你是域名或者是公网 IP，很多网友推荐免费的 Let’s Encrypt，不过有效期为90天，过期后需要再次申请，也提供了在线 免费获取HTTPS证书，如果对于生成私钥不熟悉，可以在线生成私钥；由于我是局域网 IP 不能申请免费证书，就使用自签的证书，然后将自签的证书手动安装到电脑根证书中，当然 Chrome 并不承认自签证书有效，而此时 IE 是承认自签证书是有效的。
　　nginx['ssl_certificate'] = "/etc/gitlab/ssl/192.168.2.222.crt"
　　nginx['ssl_certificate_key'] = "/etc/gitlab/ssl/192.168.2.222.key"

4、GitLab 电子邮件服务器 SMTP 配置，我使用的 QQ 个人邮箱，首先要开启邮件 POP3/SMTP 服务或者是 IMAP/SMTP 服务，并获取 授权码。

　　gitlab_rails['smtp_enable'] = true # 开启 smtp
　　gitlab_rails['smtp_address'] = "smtp.qq.com" # smtp 服务器地址
　　gitlab_rails['smtp_port'] = 465 # smtp 服务器端口
　　gitlab_rails['smtp_user_name'] = "demo@qq.com" # 邮箱地址
　　gitlab_rails['smtp_password'] = "授权码" # 申请的授权码
　　gitlab_rails['smtp_authentication'] = "login"
　　gitlab_rails['smtp_enable_starttls_auto'] = true
　　gitlab_rails['smtp_tls'] = true # 启用 tls

　　gitlab_rails['gitlab_email_enabled'] = true
　　gitlab_rails['gitlab_email_from'] = "demo@qq.com" # 发送人地址
　　gitlab_rails['gitlab_email_display_name'] = "demo-GitLab" # 邮件发送人
　　gitlab_rails['gitlab_email_reply_to'] = "demo@qq.com" # 回复邮件地址
　　gitlab_rails['gitlab_email_subject_suffix'] = "demo" # 邮件主题后缀，没有发现在哪里呈现

  • 测试 SMTP 配置，可以验证 GitLab 使用 Rails 控制台正确发送电子邮件的能力。在 GitLab 服务器上，执行 sudo gitlab-ctl reconfigure重新生成配置，再执行gitlab-rails console 进入控制台。然后，可以在控制台提示符下输入以下命令，使 GitLab 发送测试电子邮件 Notify.test_email('demo.test@qq.com', 'Message Subject', 'Message Body').deliver_now。

5、可选项，配置非默认目录来存储 Git 数据
默认的文件路径为：/var/opt/gitlab/git-data/repositories

1
2
3
4
5
git_data_dirs({
  "default": {
    "path": "/home/git/code" # 此换成你的地址， git 数据会保存在该地址 repositories 文件夹中
  }
})

6、可选项，如果需要调整Unicorn超时或工作人员数量
　　unicorn['worker_processes'] = 2 # 最低要求 worker_processes 为2，以便网页编辑器正常工作
　　unicorn['worker_timeout'] = 80 # 超时 80s，即使这样，还是时常 502，知道有多慢了吧

目前为止所有前期工作已准备完毕，可以愉快的访问了 GtiLab 了 ^_^

提示：操作 Git 代码库，可以直接使用 GitLab 提供的 SSH git@192.168.2.222:rpi/raspberry.git 和 HTTPS https://192.168.2.222/rpi/raspberry.git。
另一种，直接访问 Git 服务，此方式支持外网直接访问，但需要对路由器做端口转发配置，非默认端口访问方式 ssh://git@公网IP:22200/home/git/code/repositories/rpi/raspberry.git

维护命令

  • 修改任何配置文件后都要输入如下命令使配置生效（或者是修复权限设置）：
    sudo gitlab-ctl reconfigure
  • 页面缓存清除：
    sudo gitlab-rake cache:clear RAILS_ENV=production
  • GtiLab 各组件启动：
    sudo gitlab-ctl start
  • GtiLab 各组件停止：
    sudo gitlab-ctl stop
  • GtiLab 各组件重启：
    sudo gitlab-ctl restart
  • 禁用 GtiLab 开机自启动：
    sudo systemctl disable gitlab-runsvdir
  • 启用 GtiLab 开机自启动：
    sudo systemctl enable gitlab-runsvdir
  • 查看 GtiLab 运行状态：
    sudo gitlab-ctl status

遇到的问题

1、Unicorn 默认端口为 8080，若有端口冲突，调整 Unicorn 端口。

　　unicorn['listen'] = '127.0.0.1'
　　unicorn['port'] = 8082
　　gitlab_workhorse['auth_backend'] = "http://localhost:8082" # 这里是否需要调整，有些不太确定了

2、502网关错误，这个问题排查了良久，后来发现内存不足，导致 GitLab 相关组件启动缓慢，或者启动后树莓派出现假死状态。

  • 症状：访问 GitLab 未等待就直接返回 502，或者请求处理等待无响应，同时对树莓派发出的指令也无响应，树莓派处于假死状态，只好断电重启，就这样弄了 n 次。

  • 解决方案：对于个体用户来说，GitLab 显得有些臃肿，同时硬件也是硬伤，只能软件上来解决，在文章上半部分有提到 GitLab 对硬件最低要求是 1GB 物理内存 + 3GB 交换分区，查看树莓派的当前的交换分区只有 100M 完全不满足最低要求，然后就创建 4G 的交换分区，嗯，真的好了，GitLab 可以正常访问，并且树莓派也再未出现假死状态。

  • 创建交换分区

    • 用dd命令创建一个 4G 的文件，它将在 /var/swapfile 路径创建一个名为 swapfile 、大小为 4G 的分区文件，该分区文件拥有1024000个扇区（block)，每个扇区大小为 4K 。
      sudo dd if=/dev/zero of=/var/swapfile bs=4k count=1000k

    • 将新创建的文件创建为 Linux Swap 交换区文件：
      sudo mkswap /var/swapfile

    • 把新建的交换区加入的交换内存：
      sudo swapon /var/swapfile

    • 确认交换分区是否挂载成功：
      sudo swapon -s # 查看交换分区
      free -h # 当前内存使用情况

    • 如果需要每次启动时激活当前交换分区，编辑 sudo nano /etc/fstab，添加一行命令：
      /var/swapfile swap swap defaults 0 0

  • SWAP 分区即虚拟内存，它可以突破物理内存的限制，增加运行内存，也就是我们平时所说的 RAM，Swappiness 是一个 Linux 内核参数, 它控制了换出运行时内存的相对权重，默认值是60，可以的取值范围是0-100，建议修改10（不过，没有感觉到有什么不同）

    • 查看你的系统里面的 swappiness：
      sudo cat /proc/sys/vm/swappiness # 不出意外的话，你应该看到是 60

    • 修改 swappiness 值为 10：
      sudo sysctl vm.swappiness=10

    • 即时生效：
      sudo sysctl -p

    • 重启保留当前配置，编辑配置文件 sudo nano /etc/sysctl.conf 添加一行命令：
      vm.swappiness=30

  • 最后，重启树莓派查看配置是否正常：
    sudo restart

　
居然感冒了，上次应该是去年的时候吧，嗯，天气冷了，注意保暖 ^_^

]]> <p>　　不记得是什么时候，在树莓派上搭建了供个人使用的 Git 仓库，不是 GitLab 或者是其他 Git 管理平台，就是最原生的 Git 服务，也不觉得有什么奇怪，就这样使用了很久 ：)</p> <p>　　八天国庆假期，少了往年游玩的激情，也没有其他什么事情，整日宅在自己的小窝里躲避风和雨，省得过于清闲而又浮想翩翩，于是乎想利用树莓派搭建 GIT 管理平台；当下最为流行开源平台为 GitLab 吧，日常工作中几乎每天与其打交道（无外乎最多的就是 pull、push 吧，偶尔配置一二，算不上熟络）。<br></p> Hello World /blog/2017/08/25/hello-world/ 2017-08-25T03:02:02.000Z 2017-10-21T09:58:22.000Z Hello World.
学过编程的同学，也许在熟悉不过了， 相信对大多数同学来说，它是一切的开始 ，也成为了惯例 : )

较早之前就有搭建博客想法，但对于写点东西都要绞尽脑汁也挤不出几句的我来说，也就没有太多动力了，域名、ECS 也就闲置了。

也许是有些清闲，就又开始倒弄起来了，也许是机缘巧合，有些网友推荐 Hexo，了解后感觉还不错，就使用了。

使用到现在（其实也没用过几次），基本的需求也都满足，支持 GitHub Flavored Markdown 标记语言，也比较有趣；也有一些主题可供选择（我使用的是 hexo-theme-apollo），对于有些想法，又不想动手花太多时间的同学，也许是个不错的选择。

注：Hexo 官网文档 和 GitHub 中的安装命令有些不一样，如果安装进行不下去时，可以参考一下 GitHub 。

]]> <p>Hello World.<br>学过编程的同学，也许在熟悉不过了， 相信对大多数同学来说，它是一切的开始 ，也成为了惯例 : )</p> <p>较早之前就有搭建博客想法，但对于写点东西都要绞尽脑汁也挤不出几句的我来说，也就没有太多动力了，域名、ECS 也就闲置了。</p> <p>也许是有些清闲，就又开始倒弄起来了，也许是机缘巧合，有些网友推荐 <a href="https://hexo.io/zh-cn/" target="_blank" rel="external">Hexo</a>，了解后感觉还不错，就使用了。</p> <p>使用到现在（其实也没用过几次），基本的需求也都满足，支持 <a href="https://help.github.com/categories/writing-on-github/" target="_blank" rel="external">GitHub Flavored Markdown</a> 标记语言，也比较有趣；也有一些<a href="https://hexo.io/themes/" target="_blank" rel="external">主题</a>可供选择（我使用的是 <a href="https://github.com/pinggod/hexo-theme-apollo" target="_blank" rel="external">hexo-theme-apollo</a>），对于有些想法，又不想动手花太多时间的同学，也许是个不错的选择。<br></p>