树莓派上搭建自己的 python 开发环境

一般情况下,在烧录完镜像以后就可以直接在树莓派上通过 thony idle 去进行 python 的开发了.

但是用惯了 pycharm 和习惯了 vim 编程的我怎么可以直接用文本编辑器写代码呢?

效率完全没有了啊!

安装完镜像环境后,就可以在树莓派上开发了,为了开发opencv for python,我在树莓派上搭建了vim的python开发环境,除了配置.vimrc以外还要给各位小伙伴安利一款VIM python 自动补全插件:pydiction。

这是在纯shell环境下进行python编程的一款利器, 全屏编辑器结合这款利器各种 python 补全不再是问题。
pydiction可以实现下面python代码的自动补全:

简单python关键词补全
python 函数补全带括号
python 模块补全
python 模块内函数,变量补全
from module import sub-module 补全


  1. 安装 vim

sudo apt-get  update

sudo apt-get -y install vim git

2. 下载插件

mkdir -p ~/.vim/bundle

cd ~/.vim/bundle

git clone https://github.com/rkulla/pydiction.git

3. 配置~/.vimrc

vim ~/.vimrc

4. 在配置文件最下面填写

#载入文件类型插件

filetype plugin on

#配置插件路径

let g:pydiction_location = ‘~/.vim/bundle/pydiction/complete-dict’

#设置补全菜单的高度

let g:pydiction_menu_height = 3

然后就可以通过 vim 进行代码编写了.这时候就有了自动补全的功能.

#配色方案(可用 :highlight 查看配色方案细节)

colorscheme murphy

#打开语法高亮

syntax on

#侦测文件类型

filetype on

#载入文件类型插件

filetype plugin on

#为不同文件类型使用不用缩进

filetype indent on

#显示行号

set number

#打开自动缩进

set autoindent

#使用 C/C++ 的缩进方式

set cindent

#为 C 程序提供自动缩进

set smartindent

#设置自动缩进长度为四个空格

set shiftwidth=4

#按退格键时可以一次删掉 4 个空格

set softtabstop=4

#设定 tab 键长度为 4

set tabstop=4

#将 tab 展开为空格

set expandtab

#去掉输入错误时的提示声音

set noerrorbells

#右下角显示光标位置

set ruler

#总是显示状态行

set laststatus=2

#自定义状态行
set statusline=%F%m%r%h%w[%L][%{&ff}]%y[%p%%][%04l,%04v]

#当前列数+当前行数+当前光标位置百分比+使用的语法高亮器+文件格式+文件总行数+预览标志+帮助文件标志+只读标志+已修改标志+当前文件绝对路径

#强调匹配的括号

set showmatch

#光标短暂跳转到匹配括号的时间, 单位是十分之一秒

set matchtime=2

#显示当前正在键入的命令

set showcmd

# 设置自动切换目录为当前文件所在目录,用 :sh 时候会很方便

set autochdir

# 搜索时忽略大小写

set ignorecase

#随着键入即时搜索

set incsearch

#有一个或以上大写字母时仍大小写敏感

set smartcase

#代码折叠

set foldenable

set foldmethod=indent

#在左侧显示折叠的层次

set foldcolumn=4

#针对 Python 文件的设定

if has(“autocmd”)

autocmd FileType python set tabstop=4 shiftwidth=4 expandtab

endif

#配置pydiction插件路径

let g:pydiction_location = ‘/home/pi/.vim/bundle/pydiction/complete-dict’

#设置pydiction补全菜单的高度

let g:pydiction_menu_height = 3

希望对大家有用,谢谢!

使用 Adafruit 读取 DHT11 温湿度传感器

DHT11 温湿度传感器尽管不是使用效率最高的温湿度传感器,但价格便宜被广泛应用。之前我们介绍了用树莓派从 DHT11 温度湿度传感器读取数据的教程,其原理理解起来较为复杂,下面我们介绍另一种基于Adafruit DHT 库读取 DHT11 数据的方法。

DHT11 规格

DHT11 有四个引脚,但是其中一个没有被使用到。所有有的模块会简化成3个引脚。

  • 湿度检测范围 : 20-80% (5% 精度)
  • 温度检测范围 : 0-50°C (±2°C 精度)

该厂商不建议读取频率小于2秒,如果这么做数据可能会有误。

硬件连接

需要在电源和数据脚之间串联一个上拉电阻(4.7K-10K),通常情况下,购买DHT11模块的话都自带了这个电阻。不同的模块型号引脚位置略有不同,下面以图上模块为说明:

DHT Pin Signal Pi Pin
1 3.3V 1
2 Data/Out 11 (GPIO17)
3 not used
4 Ground 6 or 9

数据引脚可以根据你的需要自行修改。

Python 库

DHT11 的读取需要遵循特定的信号协议完成,为了方便我们使用Adafruit DHT 库。

软件安装

开始之前需要更新软件包:

sudo apt-get update
sudo apt-get install build-essential python-dev

从 GitHub 获取 Adafruit 库:

sudo git clone https://github.com/adafruit/Adafruit_Python_DHT.git
cd Adafruit_Python_DHT

给 Python 2 和 Python 3 安装该库:

sudo python setup.py install
sudo python3 setup.py install

示例程序

Adafruit 提供了示例程序,运行下面的命令测试。

cd ~
cd Adafruit_Python_DHT
cd examples
python AdafruitDHT.py 11 17

这两个参数分别表示 DHT11 和数据引脚所接的树莓派 GPIO 编号。成功的话会输出:

Temp=22.0* Humidity=68.0%

如何在其他 Python 程序中使用这个库

参照下面的方法引入 Adafruit 库,然后就可以使用 “read_retry” 方法来读取 DHT11 的数据了:

import Adafruit_DHT
  
# Set sensor type : Options are DHT11,DHT22 or AM2302
sensor=Adafruit_DHT.DHT11
  
# Set GPIO sensor is connected to
gpio=17
  
# Use read_retry method. This will retry up to 15 times to
# get a sensor reading (waiting 2 seconds between each retry).
humidity, temperature = Adafruit_DHT.read_retry(sensor, gpio)
  
# Reading the DHT11 is very sensitive to timings and occasionally
# the Pi might fail to get a valid reading. So check if readings are valid.
if humidity is not None and temperature is not None:
  print('Temp={0:0.1f}*C  Humidity={1:0.1f}%'.format(temperature, humidity))
else:
  print('Failed to get reading. Try again!')

另外,温度传感器还有 DS18B20,这个传感器虽然没有湿度数据,但是其易用且稳定。

本文来自:树莓派实验室

用树莓派DIY自动“气象站”

自动气象站可以实时探测气温、湿度、气压、风速、风向、降雨量、紫外线辐射等气象信息,通过不同的传感器采集地面气象数据,数据采集完成后通过网络统一传输到气象服务器上,再经气象采集软件处理各项数据,最后通过专业气象软件传出。

网上搜索到之前大部分的设计都是基于DSP的方案,但是IoT时代,我们需要速成的设计,网上现成的传感器和树莓派教程能帮助我们迅速的设计出一个小型气象站。

正好我在网上看到 DIY hacking 上 Arvind Sanjeev 做了个类似项目。这个完整的天气系统,只用树莓派的基础硬件,摄像头,和一些我们使用的杂七杂八的模拟和数字传感器。

风速计和雨量计也都是自己做的。

产品特点:

  • 在RRD和CSV上记录信息,方便被导出/导入到其它格式
  • 使用天气地下API来得到历史高点和低点,月相和日出/日落等信息
  • 使用树莓派相机拍摄一分钟一次的图片(可以用它来制作延时录像)
  • 有显示当前天气状况和历史天气状况的数据网页(最后一小时,一天,七天,月,年)
  • 网站主题随不同时间而改变(四个选项:日出,日落,白天和夜间)。

所有的进行记录和显示信息的软件在GitHub上开源

这个项目是很好的学习经验,能帮助真正深入理解树莓派的能力,尤其是GPIO。

所需的材料

1、电子元件

  • 9个簧片开关(8个用于风向,1个用于雨计,1个可选用为风速来代替霍尔传感器
  • 1个霍尔传感器 (用于风速,称为风速计)
  • 温度传感器
  • 湿度传感器(许多湿度传感器集成了温度传感器),我用的DHT11
  • 压力传感器(许多也集成了温度传感器),我用的BMP180
  • 光敏电阻
  • GPS芯片或USB GPS
  • 4个强磁体(2个用于风速计,1个用于方向,1个用于雨量计)
  • 各类电阻器
  • MCP3008用来把模拟转换为数字输入

2、硬件

  • 树莓派,我使用的B +
  • 无线适配器
  • 树莓派摄像头
  • 5V电源适配器

3、材料

  • 2个推力轴承 (或滑板或滑旱冰的轴承也行)
  • 2个防水罩——我用的是超市的电器罩,找一个大小合适,有足够的空间且能保护设备的就可以。
  • 一些PVC管和盖子(各种尺寸)
  • PVC安装支架
  • 一些薄有机玻璃片(不用太花哨)
  • 塑料支架
  • 塑料螺钉
  • 2个塑料圣诞树装饰品——用于风速计。
  • 小木钉
  • 小胶合板

4、工具

  • 达美电磨
  • 胶枪
  • 烙铁
  • 万用表
  • 钻孔机

机箱

一个能装进树莓派、摄像头、GPS和光传感器的盒子。需要选防水的,因为它装进了所有关键元件,测量环境风吹雨打。

机箱包含:

  • 树莓派(螺母上)——需要Wi-Fi芯片。
  • 摄像头(螺母上)
  • GPS芯片通过USB连接(我用的FTDI电缆 )。GPS能提供纬度和经度,更重要的是,我可以从GPS获取精确的时间!
  • 2个以太网/CAT5个插口,连接到主外壳与其它传感器。两个容器之间这样链接很方便。我用了大致12跟线缆,两个CAT5提供16个可能的连接,所以有空间做扩展。

测温度、湿度、压力的机箱

这是我放置温度、湿度和压力传感器的板子,以及用于雨量计,风向和风速传感器挂钩。

这一切都非常简单。。

制作雨量器

我大多沿用这个教程进行实际测量仪。

我是用有机玻璃来做的。总的来说,有机玻璃效果不错,结合胶枪,橡胶密封材料,以及整体切割和钻孔就更棒了。

关键点:

  • 该传感器是一个简单的簧片开关和磁体,树莓派上充当按钮。我简单地计算随着时间的推移桶里的水位,后来转换为“雨/英寸。”
  • 让它大到足以容纳足够的水来翻转,但不用太大因为需要很多个。我的第一个制作失败了因为不够大,所以它会被填满,并开始在它倾斜之前开始排水。

风向

这很简单。

关键点:

  • 这是一种模拟传感器。
  • 拧在风向标的后面,您需要校准它,“这个方向就是指向北方。”
  • 我做了一个木试验台,有所以我可以在全量程内轻松切换电阻器。
  • 我使用的推力轴承工作得很好。

软件

该软件也是开源的,可以在同一个GitHub库拿到。

软件是用Python写的,记录来自传感器的数据。 我第三方的库,获得来自传感器和GPS信息。

看起来很不错吧?

 

本文来自:树莓派实验室

 

 

Python+树莓派制作IoT(物联网)门控设备

前些天写了篇文章是利用树莓派制作一个开关门监控设备的雏形《Python+树莓派 是谁在开门?》,但是这个设备运行的前提是需要树莓派正常供电并已经连接了网络,但是如果需要在没有电、没有宽带网络的户外实现随时掌控开关门的状态该怎么办?今天就和大家分享一个正在制作的物联网开关门监控设备。

因为考虑需要在户外使用这套物联网门控设备,所以利用树莓派完成这个设备有两个问题需要解决,
第一是需要解决树莓派和相关模块的供电问题。
第二就是需要户外没有宽带网络情况下的信号传输问题。
只要解决这两个问题那么剩下来的问题就是编程方面的了,针对以上两个问题,这里我们采用比较大众化的方式解决,设备的供电问题我们使用太阳能配合蓄电池进行实现7X24小时供电,信号的传输问题我们使用一块叫做SIM868的通讯模块来实现。下面来介绍一下设备制作的材料准备、制作过程以及程序的编写和调试。

1.准备材料及工具
1.树莓派(Raspberry Pi 3B) 数量:1块

2.SIM868通讯模块(这里使用的是适配树莓派的微雪电子的SIM868通讯模块) 数量:1块

3.电磁感应磁条(常开常闭型) 数量:1组

4.SIM868模块外接天线 数量:1根(根据现场安设实际情况确定)

5.树莓派T型扩展板 数量:1块

6.实验面包板 数量:1块

7.杜邦线(公对公,公对母) 数量:若干

8.太阳能板 数量:1块

9.带保护板的锂电池 数量:2组(根据电池使用的性能情况可适当增加)

10.电压电流转换板 数量:1块

11.连接电线 数量:(根据现场安设实际情况确定)

12.两芯屏蔽线 数量:10米(0.3粗即可根据现场安设实际情况确定)

13.防爆箱 (防尘、防雾) 数量:1个(规格根据实际情况确定)

14.Micro USB充电线 数量:2根

15.SIM卡(移动和联通均可,模块暂不支持电信CDMA) 数量:1张

16.电烙铁及焊锡

2.设备供电及模块链接说明
(1)供电原理:设备的供电依靠太阳能板配合锂电池进行供电,需要一块可以将太阳能板和锂电池的输出电压和电流转换成树莓派和SIM868通讯模块工作电压和电流的转换板,设备供电链接图如图。
实现效果,白天可以通过太阳能负责给树莓派及通讯模块供电并同时给锂电池充电。晚上将由充电完毕的锂电池负责给设备供电。

(2)设备链接:树莓派的GPIO PIN# 2针脚(5V)和 PIN# 23针脚 链接电磁感应模块的引线。负责接收电磁感应模块的开关状态,树莓派的GPIO PIN# 4(5V),PIN# 6(Ground) ,PIN# 8(TX),PIN# 10(RX)分别链接SIM868通讯模块的5V,ground,串口TX和RX,负责实现模块的树莓派与SIM868通讯模块的串口通讯和供电链接,并将信号树莓派的接收到的电磁感应磁条开关信号,通过SIM868通讯模块出输出去(这里采用的是http传输协议,具体实现方法见程序编码部分)

3.程序代码:
(1)python程序源码:

import  RPi.GPIO as GPIO
import time
import serial  
def gpio_init():
    GPIO.setwarnings(False)
    GPIO.setmode(GPIO.BOARD)
    GPIO.setup(23,GPIO.OUT)
def send_data(param):
    W_http_6='AT+HTTPPARA="URL","http://**************/iot.php?status='+param+'"\r\n'
    ser.write(W_http_6)
    time.sleep(2)
    W_http_7='AT+HTTPACTION=0\r\n'
    ser.write(W_http_7)
    time.sleep(3)
if __name__ == '__main__':
    ser = serial.Serial("/dev/ttyS0",115200)
    W_http_1='AT+HTTPTERM\r\n'
    ser.write(W_http_1)
    time.sleep(3)
    W_http_2='AT+SAPBR=3,1,"CONTYPE","GPRS"\r\n'
    ser.write(W_http_2)
    time.sleep(3)
    W_http_3='AT+SAPBR=3,1,"APN","CMNET"\r\n'
    ser.write(W_http_3)
    time.sleep(3)
    W_http_4='AT+SAPBR=1,1\r\n'
    ser.write(W_http_4)
    time.sleep(3)
    W_http_5='AT+HTTPINIT\r\n'
    ser.write(W_http_5)
    time.sleep(3)
    gpio_init()
    status=1
    while True:
        if GPIO.input(23) == True:
            if status==1:
                send_data(2)
                status=2
                print "门的状态:关闭"
            else:
                pass
        else:
            if status==2:
                send_data(1)
                status=1
                print "门的状态:打开"
            else:
                pass
        time.sleep(3)
    GPIO.cleanup()

(2)php程序源码:

require_once("../../func/dbaccess.php");
if (doConnect($cn) == false) {         
    return false;
}
$strSQL = "insert into iot_tbl (position,status,create_time) values ("'.第一号门.'",'".
            $_GET['status']."',now())"; 
doInsertUpdate($strSQL);                
doClose($cn);

4.代码解析:
这里使用的Python版本号为2.7.9

import  RPi.GPIO as GPIO
import time
import serial

引用了python的3个类库GPIO,time以及串口调试库serial,为实现程序的调试可编写,在使用serial串口调试库前,要实现树莓派的串口配置和Linux系统下的串口调试工具minicom的安装。具体方法可参考之前的文章《树莓派串口配置及minicom的安装》

ser = serial.Serial("/dev/ttyS0",115200)
W_http_1='AT+HTTPTERM\r\n'
ser.write(W_http_1)
time.sleep(3)
W_http_2='AT+SAPBR=3,1,"CONTYPE","GPRS"\r\n'
ser.write(W_http_2)
time.sleep(3)
W_http_3='AT+SAPBR=3,1,"APN","CMNET"\r\n'
ser.write(W_http_3)
time.sleep(3)
W_http_4='AT+SAPBR=1,1\r\n'
ser.write(W_http_4)
time.sleep(3)
W_http_5='AT+HTTPINIT\r\n'
ser.write(W_http_5)
time.sleep(3)

以上代码实在通过调用serial库,设置树莓派串口通信的波特率为115200,并使用 ser.write()函数向串口写入可操作SIM868模块进行通讯的AT指令,这里的AT指令是对SIM868进行HTTP通讯前的配置,具体AT指令的含义在这里不再赘述,可自行百度查找。这是使用time.sleep()函数控制程序执行的等待时间,确保串口写入数据成功。

def gpio_init():
    GPIO.setwarnings(False)
    GPIO.setmode(GPIO.BOARD)
    GPIO.setup(23,GPIO.OUT)

gpio_init()函数是实现对接收电磁感应模块的GPIO PIN#23针脚的初始化配置。

status=1
    while True:
        if GPIO.input(23) == True:
            if status==1:
                send_data(2)
                status=2
                print "门的状态:关闭"
            else:
                pass
        else:
            if status==2:
                send_data(1)
                status=1
                print "门的状态:打开"
            else:
                pass
        time.sleep(3)

这里使用status变量初始化门的状态为1表示门已打开,并使用while True循环分割三秒钟(time.sleep(3))检测GPIO PIN#23 号针脚的电流状态,从而判断门的开关状态,并调用send_data()函数进行数据的发送。

def send_data(param):
    W_http_6='AT+HTTPPARA="URL","http://**************/iot.php?status='+param+'"\r\n'
    ser.write(W_http_6)
    time.sleep(2)
    W_http_7='AT+HTTPACTION=0\r\n'
    ser.write(W_http_7)
    time.sleep(3)

这里将门的状态status变量的值当做参数传送给你个send_data()函数,在添加到HTTP请求的URL中,在服务器端写了个PHP程序iot.php(程序源码j解析如下)用以接收SIM868通讯模块发送过来的HTTP请求,并使用GET的方式获得到HTTP请求URL中传入的status值,并插入到MySQL数据库中。

require_once("../../func/dbaccess.php");//封装链接操作MySQL数据库的函数
if (doConnect($cn) == false) {           //链接数据库
    return false;
}
$strSQL = "insert into iot_tbl (position,status,create_time) values ("'.第一号门.'",'".
            $_GET['status']."',now())";  //将数据插入MySQL数据库的SQL语句
doInsertUpdate($strSQL);                 //执行SQL
doClose($cn);                            //关闭数据库链接

4.程序拓展:
以上程序完成的是对开关门信号的检测、发送和接收数据,属于整个设备接收和处理数据的核心部分,对接收到的数据,还要做进一步的展示,这里我采用了HTML+JQuery+AJAX的方式,并配合在HTML中播放音频文件和刷新开关门状态图表,来动态展示开关门的效果。实现原理是使用AJAX操作PHP程序循环实时读取MySQL数据库,查看当前门的开关状态,并循环局部刷新HTML页面播放音频和刷新html页面图标,对门的开关效果进行动态展示。每个人的需求不同,展示部分的代码就不做说明,也参照上诉方案自行编写。

本文来自:树莓派实验室

 

 

 

使用MQTT连接树莓派IoT设备

有时候,你可能会发现自己处于一种你想让设备通过互联网相互通信的情况。例如,当我到另一个城市旅行的时候,我意识到我忘了关掉我房间的灯光。在这种情况下,我希望有一个Android应用程序或一个网站,我可以监视我家的灯光状态,并能打开或关闭它们。

所以,假设你想在一个可以在世界任何地方操作的房间里连接一个电灯开关。一个快速而稳定的选项是使用MQTT。

什么是MQTT?

MQTT(消息队列遥测传输)是一种轻量级消息传递协议,非常适用于物联网连接设备的通信。

MQTT有三个组件:代理,发布者和订阅者。经纪人是处理设备之间进行通信的中介实体。发布者是发送消息的设备。订阅者收听发布者发送的消息。

在MQTT中还有一件更重要的事情,那就是一个话题。不同设备之间的通信需要一个主题。例如,设备A想要向设备B发送消息。为此,两者之间应该有一些共同之处,那就是主题。把它想象成一个电话号码。

CloudMQTT

CloudMQTT是为特定数量的设备提供免费MQTT通信的代理服务。

设置MQTT

  • 在“名称”字段中输入CMQTT

  • 点击创建
  • 记下您的数据,如下图所示

 

 

  • 在同一页面上,在管理用户中添加一个用户:
    • 名字:pi
    • 密码:pi

 

  • 点击“保存”
  • 再次在最后的同一页上:
    • 用户:pi
    • 主题:pi

 

  • 并点击“保存”
  • 现在,在顶部的栏中,点击“WebSocket UI”

 

 

  • 你会看到一个页面,所有的传感器数据将被显示
  • 将以下代码上传到Arduino

下面的代码是用虚拟字符串代替传感器的示例代码。您可以用来自传感器的值替换字符串。

String sensorsData=""; 
String randSensorsData=""; 
void setup() {
   // put your setup code here, to run once: 
Serial.begin(9600); 
pinMode(A0,INPUT);//temperature sensor 
pinMode(A1,INPUT);//windspeed sensor 
pinMode(A2,INPUT);//wind direction sensor 
pinMode(A3,INPUT);//rain fall sensor 
pinMode(A4,INPUT);///barometric pressure sensor
} 

void loop() {
   // put your main code here, to run repeatedly:      
sensorsData=String("-")+String("S1=")+String(analogRead(A0))+String(",")+String("S2=")+String(analogRead(A1))+ \
String(",")+String("S3=")+String(analogRead(A2))+String(",")+String("S4=")+  \
String(analogRead(A3))+String(",")+String("S5=")+String(analogRead(A4))+String("+");     
randSensorsData=String("-")+String("S1=")+String(random(100))+String(",")+String("S2=")+ \
String(random(200))+String(",")+String("S3=")+String(random(125))+String(",")+String("S4=")+\
String(random(500))+String(",")+String("S5=")+String(random(50))+String("+");     
   Serial.println(sensorsData);     
   Serial.println(randSensorsData);   
   delay(200); 
}

此代码使用Arduino的模拟引脚来获取传感器的值,并传递到Raspberry Pi进行处理和MQTT通信。上面的代码使用随机函数来生成随机值来模拟模拟引脚。

  • 传感器应连接到A0,A1,A2,A3,A4引脚,
  • Serial.println(randSensorsData);
  • 这一行发送随机数据来检查服务器。
  • 您也可以检查在WebSocket UI中显示的随机数据。
  • 打开python 2.7并在其中编写下面的代码:
import paho.mqtt.client as mqtt
import time
data=”Hello from Raspberry Pi!”
while True:
    print(data)
    try:
        client=mqtt.Client()
        client.username_pw_set("yoyojacky","MyRPiPr0J")#替换成你的用户名和密码
        client.connect("m13.cloudmqtt.com",13017,60)
        client.publish("pi",data) #这里的 pi 是你的话题,客户端就订阅这个话题
        time.sleep(1)
    except KeyboardInterrupt:
        print("end")
        client.disconnect()
  • 现在使用python 2.7运行代码
  • 您将在每秒钟后看到传感器数据显示在CloudMQTT的WebScoket UI中。

  • 在这里,您将看到从Raspberry Pi发送的数据。

令人惊讶的是,CloudMQTT提供了一个完整的dashboard用于测试目的。您可以使用此dashboard订阅或发布主题.

在接下来就可以去配置你的 arduino 和树莓派来管理家里的设备或者查询家里的设备信息了!

 

[找回失落的记忆]树莓派+Pygame模块编写俄罗斯方块

昨天晚上,在家整理东西的时候, 突然翻找出来很早以前小时候的 Gameboy(可能不是这个名字了), 装电池的那种,很古老,只有一款游戏就是俄罗斯方块, 突然回忆就拉回了小学时代和同学一起比拼俄罗斯方块分数的日子,每天都无忧无虑的,不用考虑房贷,车保险….然后突然有一个想法,为什么不用树莓派做一个游戏机呢? 网上教程一堆一堆的, 都是用 retropie, lakka之类的系统实现一个模拟器的平台, 我觉得不够极客, 如果自己用 python 写一个游戏不是更好? 又能巩固 python 的代码能力,又可以让树莓派一机多用, 不仅只是个游戏机, 还可以是下载器,gitlab, 或者是一个 OSMC, 家庭媒体中心呢?

翻找了一下我的 Maker 材料箱, 找到一个吃灰已久的树莓派3B, 通过官方下载全新的镜像,然后烧录系统, 更新系统,配置 ssh, 配置主机名,配置字符集,配置 IP 地址等等一系列操作后. 利用 python 命令执行一下看看版本信息:

$ python -V
Python 2.7.10

就用默认版本吧, 然后去检查一下 pygame 的状态,默认情况下, pygame 已经集成在系统里面了, 如果没有要去官方站点上下载一下并安装, 连接如下: http://pygame.org/wiki/tutorials,官方的这个链接上已经说明:http://pygame.org/wiki/GettingStarted#Raspberry PI

Raspberry PI

This comes with pygame already installed on the default raspberian installation.

那么接下来的事儿就简单多了. 下面是我准备的材料:

  1. 树莓派3 B 型  x1
  2. 16GB class 10 的 TF 卡一张, 最好有SD 卡套方便进行系统烧录
  3. 5v2.5A 电源一套,为了方便,我这里采用的是52Pi 官方的 USB-HUB, 专为树莓派设计, 购买点我
  4. 5寸电阻触摸屏( GPIO 引脚控制), 购买点我 
  5. 外壳你可以自己 DIY 或者利用以下链接下载 STL 文件然后转码成 Gcode 交给3D 打印机打印.3D打印外壳链接

好了,我要开始操作了,首先你要做的事儿是把设备接驳起来,像这样:

然后启动后配置好网络后执行我写好的脚本就可以进行分辨率调节:

git clone https://github.com/yoyojacky/52Pi.git

cd ~/52Pi/

chmod +x restool.sh

sudo ./restool.sh

然后重启, 屏幕的分辨率和电容触摸的驱动就加载好了.

后面需要执行屏幕校准:

cd ~/52Pi/

chmod +x calibrator.sh

sudo ./calibrator.sh

基本配置告一段落了,然后检查 pygame 的版本:

pip list

或者通过 python 的 IDE 直接进行查询,在终端键入python 然后回车继续输入如下 python 代码:

 import  pygame

pygame.ver

看到如下图示:

说明pygame 的模块已经安装过,系统中包含这个模块了,就可以开始下面的操作了.

然后创建一个目录:

mkdir -pv  /home/pi/mygame/music

sudo vim.tiny  /home/pi/mygame/russianblock.py

我一次性创建了一个目录结构, mygame 目录下面创建一个 python 文件, 名字为: russianblock.py

然后可以两首 MP3的歌曲进去, 也可以直接下载我提供的素材:

Have A Drink On Me,Rolling in the Deep

然后继续添加如下python 代码:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
import random, time, pygame, sys
from pygame.locals import *

FPS = 25
WINDOWWIDTH = 640
WINDOWHEIGHT = 480
BOXSIZE = 20
BOARDWIDTH = 10
BOARDHEIGHT = 20
BLANK = '.'

MOVESIDEWAYSFREQ = 0.15
MOVEDOWNFREQ = 0.1

XMARGIN = int((WINDOWWIDTH - BOARDWIDTH * BOXSIZE) / 2)
TOPMARGIN = WINDOWHEIGHT - (BOARDHEIGHT * BOXSIZE) - 5
#        R  G  B
WHITE    = (255, 255, 255)
GRAY    = (185, 185, 185)
BLACK    = ( 0,  0,  0)
RED     = (155,  0,  0)
LIGHTRED  = (175, 20, 20)
GREEN    = ( 0, 155,  0)
LIGHTGREEN = ( 20, 175, 20)
BLUE    = ( 0,  0, 155)
LIGHTBLUE  = ( 20, 20, 175)
YELLOW   = (155, 155,  0)
LIGHTYELLOW = (175, 175, 20)

BORDERCOLOR = BLUE
BGCOLOR = BLACK
TEXTCOLOR = WHITE
TEXTSHADOWCOLOR = GRAY
COLORS   = (   BLUE,   GREEN,   RED,   YELLOW)
LIGHTCOLORS = (LIGHTBLUE, LIGHTGREEN, LIGHTRED, LIGHTYELLOW)
assert len(COLORS) == len(LIGHTCOLORS) # each color must have light color

TEMPLATEWIDTH = 5
TEMPLATEHEIGHT = 5

S_SHAPE_TEMPLATE = [['.....',
           '.....',
           '..OO.',
           '.OO..',
           '.....'],
          ['.....',
           '..O..',
           '..OO.',
           '...O.',
           '.....']]

Z_SHAPE_TEMPLATE = [['.....',
           '.....',
           '.OO..',
           '..OO.',
           '.....'],
          ['.....',
           '..O..',
           '.OO..',
           '.O...',
           '.....']]

I_SHAPE_TEMPLATE = [['..O..',
           '..O..',
           '..O..',
           '..O..',
           '.....'],
          ['.....',
           '.....',
           'OOOO.',
           '.....',
           '.....']]

O_SHAPE_TEMPLATE = [['.....',
           '.....',
           '.OO..',
           '.OO..',
           '.....']]

J_SHAPE_TEMPLATE = [['.....',
           '.O...',
           '.OOO.',
           '.....',
           '.....'],
          ['.....',
           '..OO.',
           '..O..',
           '..O..',
           '.....'],
          ['.....',
           '.....',
           '.OOO.',
           '...O.',
           '.....'],
          ['.....',
           '..O..',
           '..O..',
           '.OO..',
           '.....']]

L_SHAPE_TEMPLATE = [['.....',
           '...O.',
           '.OOO.',
           '.....',
           '.....'],
          ['.....',
           '..O..',
           '..O..',
           '..OO.',
           '.....'],
          ['.....',
           '.....',
           '.OOO.',
           '.O...',
           '.....'],
          ['.....',
           '.OO..',
           '..O..',
           '..O..',
           '.....']]

T_SHAPE_TEMPLATE = [['.....',
           '..O..',
           '.OOO.',
           '.....',
           '.....'],
          ['.....',
           '..O..',
           '..OO.',
           '..O..',
           '.....'],
          ['.....',
           '.....',
           '.OOO.',
           '..O..',
           '.....'],
          ['.....',
           '..O..',
           '.OO..',
           '..O..',
           '.....']]

PIECES = {'S': S_SHAPE_TEMPLATE,
     'Z': Z_SHAPE_TEMPLATE,
     'J': J_SHAPE_TEMPLATE,
     'L': L_SHAPE_TEMPLATE,
     'I': I_SHAPE_TEMPLATE,
     'O': O_SHAPE_TEMPLATE,
     'T': T_SHAPE_TEMPLATE}


def main():
  global FPSCLOCK, DISPLAYSURF, BASICFONT, BIGFONT
  pygame.init()
  FPSCLOCK = pygame.time.Clock()
  DISPLAYSURF = pygame.display.set_mode((WINDOWWIDTH, WINDOWHEIGHT))
  BASICFONT = pygame.font.Font('freesansbold.ttf', 18)
  BIGFONT = pygame.font.Font('freesansbold.ttf', 100)
  pygame.display.set_caption('Tetromino')

  showTextScreen('YoYoJacky')
  while True: # game loop
    if random.randint(0, 1) == 0:
      pygame.mixer.music.load('music/Have A Drink On Me.mp3')
    else:
      pygame.mixer.music.load('music/Rolling In The Deep.mp3')
    pygame.mixer.music.play(-1, 0.0)
    runGame()
    pygame.mixer.music.stop()
    showTextScreen('Game Over')


def runGame():
  # setup variables for the start of the game
  board = getBlankBoard()
  lastMoveDownTime = time.time()
  lastMoveSidewaysTime = time.time()
  lastFallTime = time.time()
  movingDown = False # note: there is no movingUp variable
  movingLeft = False
  movingRight = False
  score = 0
  level, fallFreq = calculateLevelAndFallFreq(score)

  fallingPiece = getNewPiece()
  nextPiece = getNewPiece()

  while True: # game loop
    if fallingPiece == None:
      # No falling piece in play, so start a new piece at the top
      fallingPiece = nextPiece
      nextPiece = getNewPiece()
      lastFallTime = time.time() # reset lastFallTime

      if not isValidPosition(board, fallingPiece):
        return # can't fit a new piece on the board, so game over

    checkForQuit()
    for event in pygame.event.get(): # event handling loop
      if event.type == KEYUP:
        if (event.key == K_p):
          # Pausing the game
          DISPLAYSURF.fill(BGCOLOR)
          pygame.mixer.music.stop()
          showTextScreen('Paused') # pause until a key press
          pygame.mixer.music.play(-1, 0.0)
          lastFallTime = time.time()
          lastMoveDownTime = time.time()
          lastMoveSidewaysTime = time.time()
        elif (event.key == K_LEFT or event.key == K_a):
          movingLeft = False
        elif (event.key == K_RIGHT or event.key == K_d):
          movingRight = False
        elif (event.key == K_DOWN or event.key == K_s):
          movingDown = False

      elif event.type == KEYDOWN:
        # moving the piece sideways
        if (event.key == K_LEFT or event.key == K_a) and isValidPosition(board, fallingPiece, adjX=-1):
          fallingPiece['x'] -= 1
          movingLeft = True
          movingRight = False
          lastMoveSidewaysTime = time.time()

        elif (event.key == K_RIGHT or event.key == K_d) and isValidPosition(board, fallingPiece, adjX=1):
          fallingPiece['x'] += 1
          movingRight = True
          movingLeft = False
          lastMoveSidewaysTime = time.time()

        # rotating the piece (if there is room to rotate)
        elif (event.key == K_UP or event.key == K_w):
          fallingPiece['rotation'] = (fallingPiece['rotation'] + 1) % len(PIECES[fallingPiece['shape']])
          if not isValidPosition(board, fallingPiece):
            fallingPiece['rotation'] = (fallingPiece['rotation'] - 1) % len(PIECES[fallingPiece['shape']])
        elif (event.key == K_q): # rotate the other direction
          fallingPiece['rotation'] = (fallingPiece['rotation'] - 1) % len(PIECES[fallingPiece['shape']])
          if not isValidPosition(board, fallingPiece):
            fallingPiece['rotation'] = (fallingPiece['rotation'] + 1) % len(PIECES[fallingPiece['shape']])

        # making the piece fall faster with the down key
        elif (event.key == K_DOWN or event.key == K_s):
          movingDown = True
          if isValidPosition(board, fallingPiece, adjY=1):
            fallingPiece['y'] += 1
          lastMoveDownTime = time.time()

        # move the current piece all the way down
        elif event.key == K_SPACE:
          movingDown = False
          movingLeft = False
          movingRight = False
          for i in range(1, BOARDHEIGHT):
            if not isValidPosition(board, fallingPiece, adjY=i):
              break
          fallingPiece['y'] += i - 1

    # handle moving the piece because of user input
    if (movingLeft or movingRight) and time.time() - lastMoveSidewaysTime > MOVESIDEWAYSFREQ:
      if movingLeft and isValidPosition(board, fallingPiece, adjX=-1):
        fallingPiece['x'] -= 1
      elif movingRight and isValidPosition(board, fallingPiece, adjX=1):
        fallingPiece['x'] += 1
      lastMoveSidewaysTime = time.time()

    if movingDown and time.time() - lastMoveDownTime > MOVEDOWNFREQ and isValidPosition(board, fallingPiece, adjY=1):
      fallingPiece['y'] += 1
      lastMoveDownTime = time.time()

    # let the piece fall if it is time to fall
    if time.time() - lastFallTime > fallFreq:
      # see if the piece has landed
      if not isValidPosition(board, fallingPiece, adjY=1):
        # falling piece has landed, set it on the board
        addToBoard(board, fallingPiece)
        score += removeCompleteLines(board)
        level, fallFreq = calculateLevelAndFallFreq(score)
        fallingPiece = None
      else:
        # piece did not land, just move the piece down
        fallingPiece['y'] += 1
        lastFallTime = time.time()

    # drawing everything on the screen
    DISPLAYSURF.fill(BGCOLOR)
    drawBoard(board)
    drawStatus(score, level)
    drawNextPiece(nextPiece)
    if fallingPiece != None:
      drawPiece(fallingPiece)

    pygame.display.update()
    FPSCLOCK.tick(FPS)


def makeTextObjs(text, font, color):
  surf = font.render(text, True, color)
  return surf, surf.get_rect()


def terminate():
  pygame.quit()
  sys.exit()


def checkForKeyPress():
  # Go through event queue looking for a KEYUP event.
  # Grab KEYDOWN events to remove them from the event queue.
  checkForQuit()

  for event in pygame.event.get([KEYDOWN, KEYUP]):
    if event.type == KEYDOWN:
      continue
    return event.key
  return None


def showTextScreen(text):
  # This function displays large text in the
  # center of the screen until a key is pressed.
  # Draw the text drop shadow
  titleSurf, titleRect = makeTextObjs(text, BIGFONT, TEXTSHADOWCOLOR)
  titleRect.center = (int(WINDOWWIDTH / 2), int(WINDOWHEIGHT / 2))
  DISPLAYSURF.blit(titleSurf, titleRect)

  # Draw the text
  titleSurf, titleRect = makeTextObjs(text, BIGFONT, TEXTCOLOR)
  titleRect.center = (int(WINDOWWIDTH / 2) - 3, int(WINDOWHEIGHT / 2) - 3)
  DISPLAYSURF.blit(titleSurf, titleRect)

  # Draw the additional "Press a key to play." text.
  pressKeySurf, pressKeyRect = makeTextObjs('Press a key to play.', BASICFONT, TEXTCOLOR)
  pressKeyRect.center = (int(WINDOWWIDTH / 2), int(WINDOWHEIGHT / 2) + 100)
  DISPLAYSURF.blit(pressKeySurf, pressKeyRect)

  while checkForKeyPress() == None:
    pygame.display.update()
    FPSCLOCK.tick()


def checkForQuit():
  for event in pygame.event.get(QUIT): # get all the QUIT events
    terminate() # terminate if any QUIT events are present
  for event in pygame.event.get(KEYUP): # get all the KEYUP events
    if event.key == K_ESCAPE:
      terminate() # terminate if the KEYUP event was for the Esc key
    pygame.event.post(event) # put the other KEYUP event objects back


def calculateLevelAndFallFreq(score):
  # Based on the score, return the level the player is on and
  # how many seconds pass until a falling piece falls one space.
  level = int(score / 10) + 1
  fallFreq = 0.27 - (level * 0.02)
  return level, fallFreq

def getNewPiece():
  # return a random new piece in a random rotation and color
  shape = random.choice(list(PIECES.keys()))
  newPiece = {'shape': shape,
        'rotation': random.randint(0, len(PIECES[shape]) - 1),
        'x': int(BOARDWIDTH / 2) - int(TEMPLATEWIDTH / 2),
        'y': -2, # start it above the board (i.e. less than 0)
        'color': random.randint(0, len(COLORS)-1)}
  return newPiece


def addToBoard(board, piece):
  # fill in the board based on piece's location, shape, and rotation
  for x in range(TEMPLATEWIDTH):
    for y in range(TEMPLATEHEIGHT):
      if PIECES[piece['shape']][piece['rotation']][y][x] != BLANK:
        board[x + piece['x']][y + piece['y']] = piece['color']


def getBlankBoard():
  # create and return a new blank board data structure
  board = []
  for i in range(BOARDWIDTH):
    board.append([BLANK] * BOARDHEIGHT)
  return board


def isOnBoard(x, y):
  return x >= 0 and x < BOARDWIDTH and y < BOARDHEIGHT


def isValidPosition(board, piece, adjX=0, adjY=0):
  # Return True if the piece is within the board and not colliding
  for x in range(TEMPLATEWIDTH):
    for y in range(TEMPLATEHEIGHT):
      isAboveBoard = y + piece['y'] + adjY < 0
      if isAboveBoard or PIECES[piece['shape']][piece['rotation']][y][x] == BLANK:
        continue
      if not isOnBoard(x + piece['x'] + adjX, y + piece['y'] + adjY):
        return False
      if board[x + piece['x'] + adjX][y + piece['y'] + adjY] != BLANK:
        return False
  return True

def isCompleteLine(board, y):
  # Return True if the line filled with boxes with no gaps.
  for x in range(BOARDWIDTH):
    if board[x][y] == BLANK:
      return False
  return True


def removeCompleteLines(board):
  # Remove any completed lines on the board, move everything above them down, and return the number of complete lines.
  numLinesRemoved = 0
  y = BOARDHEIGHT - 1 # start y at the bottom of the board
  while y >= 0:
    if isCompleteLine(board, y):
      # Remove the line and pull boxes down by one line.
      for pullDownY in range(y, 0, -1):
        for x in range(BOARDWIDTH):
          board[x][pullDownY] = board[x][pullDownY-1]
      # Set very top line to blank.
      for x in range(BOARDWIDTH):
        board[x][0] = BLANK
      numLinesRemoved += 1
      # Note on the next iteration of the loop, y is the same.
      # This is so that if the line that was pulled down is also
      # complete, it will be removed.
    else:
      y -= 1 # move on to check next row up
  return numLinesRemoved


def convertToPixelCoords(boxx, boxy):
  # Convert the given xy coordinates of the board to xy
  # coordinates of the location on the screen.
  return (XMARGIN + (boxx * BOXSIZE)), (TOPMARGIN + (boxy * BOXSIZE))


def drawBox(boxx, boxy, color, pixelx=None, pixely=None):
  # draw a single box (each tetromino piece has four boxes)
  # at xy coordinates on the board. Or, if pixelx & pixely
  # are specified, draw to the pixel coordinates stored in
  # pixelx & pixely (this is used for the "Next" piece).
  if color == BLANK:
    return
  if pixelx == None and pixely == None:
    pixelx, pixely = convertToPixelCoords(boxx, boxy)
  pygame.draw.rect(DISPLAYSURF, COLORS[color], (pixelx + 1, pixely + 1, BOXSIZE - 1, BOXSIZE - 1))
  pygame.draw.rect(DISPLAYSURF, LIGHTCOLORS[color], (pixelx + 1, pixely + 1, BOXSIZE - 4, BOXSIZE - 4))


def drawBoard(board):
  # draw the border around the board
  pygame.draw.rect(DISPLAYSURF, BORDERCOLOR, (XMARGIN - 3, TOPMARGIN - 7, (BOARDWIDTH * BOXSIZE) + 8, (BOARDHEIGHT * BOXSIZE) + 8), 5)

  # fill the background of the board
  pygame.draw.rect(DISPLAYSURF, BGCOLOR, (XMARGIN, TOPMARGIN, BOXSIZE * BOARDWIDTH, BOXSIZE * BOARDHEIGHT))
  # draw the individual boxes on the board
  for x in range(BOARDWIDTH):
    for y in range(BOARDHEIGHT):
      drawBox(x, y, board[x][y])


def drawStatus(score, level):
  # draw the score text
  scoreSurf = BASICFONT.render('Score: %s' % score, True, TEXTCOLOR)
  scoreRect = scoreSurf.get_rect()
  scoreRect.topleft = (WINDOWWIDTH - 150, 20)
  DISPLAYSURF.blit(scoreSurf, scoreRect)

  # draw the level text
  levelSurf = BASICFONT.render('Level: %s' % level, True, TEXTCOLOR)
  levelRect = levelSurf.get_rect()
  levelRect.topleft = (WINDOWWIDTH - 150, 50)
  DISPLAYSURF.blit(levelSurf, levelRect)


def drawPiece(piece, pixelx=None, pixely=None):
  shapeToDraw = PIECES[piece['shape']][piece['rotation']]
  if pixelx == None and pixely == None:
    # if pixelx & pixely hasn't been specified, use the location stored in the piece data structure
    pixelx, pixely = convertToPixelCoords(piece['x'], piece['y'])

  # draw each of the boxes that make up the piece
  for x in range(TEMPLATEWIDTH):
    for y in range(TEMPLATEHEIGHT):
      if shapeToDraw[y][x] != BLANK:
        drawBox(None, None, piece['color'], pixelx + (x * BOXSIZE), pixely + (y * BOXSIZE))


def drawNextPiece(piece):
  # draw the "next" text
  nextSurf = BASICFONT.render('Next:', True, TEXTCOLOR)
  nextRect = nextSurf.get_rect()
  nextRect.topleft = (WINDOWWIDTH - 120, 80)
  DISPLAYSURF.blit(nextSurf, nextRect)
  # draw the "next" piece
  drawPiece(piece, pixelx=WINDOWWIDTH-120, pixely=100)


if __name__ == '__main__':
  main()

写好以后,先用命令执行测试一下:

sudo python russianblock.py

执行结果看到如下内容就说明成功了:

随便按一个键就可以开始玩儿了,使用键盘的上下左右控制移动, 用空格控制反转,记得把你的耳机插入树莓派3.5mm 的音频复合接口, 然后开始享受游戏的乐趣吧!

如果失败,音乐就停啦!

好了! 这个简单的教程就写到这里, 后期教大家利用 pygame 和树莓派制作更多的好玩儿的小游戏!

树莓派3B 爬虫蓝牙播放器

  

一直没有尝试使用一下树莓派3B 的蓝牙功能,今天特别想试试,于是就烧录了最新的raspbian镜像,然后接上5寸GPIO触摸屏和键盘鼠标,开始了调试,网上看了看其他人的教程,发现都很老了,有的还不能用。所以就诞生了这篇我自己能用的文章,算是做个记录吧。

首先你需要做的准备工作:

  1. 树莓派3B  如果你是2B ,那么你还需要一个USB 的蓝牙接收器(马云家可买)
  2. 树莓派电源5v/2A
  3. 8GB TF 卡一张,读卡器1个
  4. 树莓派外壳(可选) 为了好看和防尘, 还可以选择散热片和风扇,更加专业.
  5. 小米蓝牙小音箱.
  6. 无线网络环境.
  7. 去官方网站下载最新的 Raspbian 系统并且通过 win32_diskimager 烧录到你的 TF卡

好了,万事俱备, 只欠500万,接下来直接进入主题,插上电源,等待RPI开机后,系统中通过点选 wifi 图标先连入网络,然后打开一个终端,执行下面的命令进行更新和安装蓝牙软件:

sudo apt-get  update

sudo apt-get  -y  install  –no-install-recommends bluetooth

sudo service bluetooth status

检查是否有蓝牙服务,如果没有就再重启一下设备。或者用下面的命令尝试扫描一下:

hcitool scan

我之前还尝试了使用blueman,那个在图形上设置更加方便。

sudo apt-get  -y  install  bluetooth  bluez  blueman

但是我更倾向于这样设置:

蓝牙配对

如果看不清楚就看这里:

sudo  bluetoothctl

然后进入bluetooth的交互界面输入

agent  on

default-agent

然后开始扫描

scan on

当找到你的蓝牙设备后,执行配对就好了。

pair  B8:78:2E:12:0F:29   #这里要根据你实际情况选择.

这里输入你的蓝牙的MAC地址,就是类似B8:78:2E:12:0F:29这种

如果要用蓝牙音箱,记得使用blueman,那个有图形界面可以在图形上选择audio的输出方式,可以找到你的蓝牙设备,然后选择成为输出设备,然后就可以用我写好的python爬虫来进行音乐的搜索和播放了。

git  clone   https://github.com/yoyojacy/52Pi.git

cd  52Pi/

python   music.py

第一次执行的时候可能时间比较长,因为在更新系统和安装mplayer,不用担心,通过后就可以看到提示了,输入歌名或者歌手的名字就可以听到歌曲了。如果还想调整一下音量大小可以用:

alsamixer

然后按上下键调整就好了,最后记得ESC退出。

最后,转发的童鞋请注明出处! 谢谢~

20分钟理解并写出简易的网速监控API

这是一篇学习笔记。用于快速理解,并在Raspbian(或者其他Linux系统)上,利用Python的Flask框架快速写出一份简易的网速监控API。

0 序言

我目前成为了树莓派的重度使用者。平时Python的练习可以在上面做,同时它也是我的NAS(简易版)、离线下载机、无线路由器……

对于我来说,对某台机器网速的监控有很大的需求,因此之前尝试利用基于PHP的探针提供的API来监控实时网速

PHP探针在建站环境上的主机会非常方便。但是对于没有PHP环境的主机,专门为了一个探针而配置PHP,则过于臃肿。

今天写了这篇文章,同时也作为我自己的笔记,用Python的Flask框架快速写出一份简易的网速监控API。

进行操作后,不只是网速监控API,可以根据自身需求推广到其他API的快速搭建。

我们最终的目标是,HTTP访问目标ip:端口,得到json形式的返回结果:

{
"interface": "eth0",
"rx": "58829838538",
"time": "1506500429.11",
"tx": "59272128479"
}

包含网口名,rx和tx字节数,此时的时间戳(api提供端无状态,只提供时间戳。网速信息在api获取端运算)。

注:JSON(JavaScript Object Notation, JS 对象标记) 是一种轻量级的数据交换格式。它基于 ECMAScript (w3c制定的js规范)的一个子集,采用完全独立于编程语言的文本格式来存储和表示数据。简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言。 易于人阅读和编写,同时也易于机器解析和生成,并有效地提升网络传输效率。

1 了解 /proc

Linux 内核提供了一种通过 /proc 文件系统,在运行时访问内核内部数据结构、改变内核设置的机制。proc文件系统是一个伪文件系统,它只存在内存当中,而不占用外存空间。它以文件系统的方式为访问系统内核数据的操作提供接口。

pi@raspberrypi:/proc $ ls
1     1158  1323  1452  1673  2057  2474  45   576  66    77    8032  904        bus          interrupts   modules        timer_list
10    1180  1336  146   1674  2058  25    46   579  67    7791  8035  912        cgroups      iomem        mounts         timer_stats
1009  1184  1350  1460  1691  21    26    47   58   670   7797  8097  915        cmdline      ioports      net            tty
104   1187  1356  148   1695  2122  27    48   580  68    78    8134  916        consoles     irq          pagetypeinfo   uptime
1076  124   1357  1482  17    2126  273   49   582  69    7804  8136  917        cpu          kallsyms     partitions     vc-cma
1077  1259  1358  15    1736  22    28    5    59   6948  7811  82    918        cpuinfo      keys         sched_debug    version
1078  1260  1361  1536  1742  222   29    50   60   7     7813  83    919        crypto       key-users    self           vmallocinfo
1079  1269  1363  1585  1777  223   3     51   61   70    79    85    922        devices      kmsg         slabinfo       vmstat
108   1272  1364  1625  1780  224   31    52   619  71    7901  879   932        device-tree  kpagecgroup  softirqs       zoneinfo
1081  1290  1365  1626  18    228   32    53   62   72    7936  88    933        diskstats    kpagecount   stat
1085  1291  1378  1646  1813  2288  322   54   63   73    7940  89    937        driver       kpageflags   swaps
1097  13    1379  1648  1871  23    33    55   64   738   8     892   946        execdomains  loadavg      sys
11    1309  14    1651  19    238   34    56   65   75    80    898   960        fb           locks        sysrq-trigger
1108  1312  1402  1652  2     239   35    57   658  7669  8025  9     asound     filesystems  meminfo      sysvipc
1154  1321  1442  1668  2056  24    44    575  659  7691  8030  90    buddyinfo  fs           misc         thread-self

详情可参考 Linux下/proc目录简介 [1]

对于状态监控,我们一般关心的信息如下:
/proc/cpuinfo cpu的信息
/proc/loadavg 根据过去一段时间内CPU和IO的状态得出的负载状态
/proc/meminfo RAM使用的相关信息
/proc/uptime 系统已经运行了多久
/proc/net 网卡设备信息
/proc/net/dev 显示网络适配器及统计信息
/proc/diskstats 取得磁盘信息

这样,我们就可以各取所需。在本例中,我使用了/proc/net/dev 显示网络适配器及统计信息。

Inter-|   Receive                                                |  Transmit
 face |bytes    packets errs drop fifo frame compressed multicast|bytes    packets errs drop fifo colls carrier compressed
  tun0: 3852102709 17680346    0    0    0     0          0         0 1974345633 21150157    0 182375    0     0       0          0
 wlan0: 7886340   51924    0    4    0     0          0       248 15654713   23263    0    0    0     0       0          0
    lo: 1109576    6222    0    0    0     0          0         0  1109576    6222    0    0    0     0       0          0
  eth0: 1357382867 17758879    0 32317    0     0          0         0 354351259 21157222    0    0    0     0       0          0
  eth1: 145114110 1581538    0    0    0     0          0         0 2151465834 4647523    0    0    0     0       0          0

/proc/net/dev就是我们流量监控的数据来源。

我关心eth0的网卡流量。因此我只要抓出eth0(第六行)行的RX字节数和TX字节数即可,再在api中返回此时的时间戳。

对于 /proc/net/dev 文件中我关心的信息,我使用的部分Python代码如下。

f = open('/proc/net/dev','r')
 for x in range(5):
       f.readline()
 line = f.readline()
 strline = line.split(' ')
 strline2 = []
 for a in strline:
         if a != ' ':
                 if a !='':
                         strline2.append(a)

至此,我们得到的strline2就是eth0行中包含的数据列表。根据/proc/net/dev 格式,rx数据量是strline2[1],tx数据量是strline2[9]。当然,你也可以用正则表达式来实现。

毕竟是自己使用的简易API,如果不是特别在意的话,实现方法不优雅也无妨。

至此我们就能把自己需要的信息提取出来了。

2 熟悉 flask 框架

Flask是一个使用Python编写的轻量级Web应用框架。基于Werkzeug WSGI工具箱和Jinja2 模板引擎。 Flask使用BSD授权。 Flask也被称为“microframework”,因为它使用简单的核心,用extension增加其他功能。Flask没有默认使用的数据库、窗体验证工具。然而,Flask保留了扩增的弹性,可以用Flask-extension加入这些功能:ORM、窗体验证工具、文件上传、各种开放式身份验证技术。

Flask有提供文档 http://docs.jinkan.org/docs/flask/

用简单的话说,Flask可以让你快速搭建起来一个web服务端,而省去一些技术细节。

不要误解,Flask的能力足以支撑大型的商业项目。但由于其轻量易上手,使得我们也可以在自己的项目中轻松使用。我们来看一下其helloworld代码。

from flask import Flask
app = Flask(__name__)
 
@app.route("/")
def hello():
    return "Hello World!"

如你所见,短短几行代码实现了基本的web静态服务。

我们将上面获取网速的代码加入,就可以实现我们的API功能。

具体操作如下:

安装flask

sudo pip3 install flask

在我们的目录下新建一个app.py并编辑

#!flask/bin/python
from flask import Flask
 
app = Flask(__name__)
 
@app.route('/')
def index():
    return "Hello, World!"
 
if __name__ == '__main__':
    app.run(host='0.0.0.0',port='5050',debug=True)

注意,相比helloworld,最后一行代表的含义是:在0.0.0.0(本地/不检查ip)上开放,端口5050,开启调试,然后执行。

此时访问 http://localhost:5050 或者 http://目标机器ip:5050 即可返回HelloWorld。(访问失败,注意防火墙设置)

具体特性如调试、路由等等使用方法,本文不多提及,请参照官方文档。

3 写出服务端

我们最终的目标是,HTTP访问目标ip:端口,得到json形式的返回结果:

{
"interface": "eth0",
"rx": "58829838538",
"time": "1506500429.11",
"tx": "59272128479"
}

接下来将上面两部分结合,写出服务端即可。我的代码如下:

#!flask/bin/python
from flask import Flask, jsonify
import time
 
app = Flask(__name__)
 
net =   {
                'interface':'eth0',
                'rx':'0',
                'tx':'0',
                'time': '0'
        }
 
 
@app.route('/')
def index():
    try:
                f = open('/proc/net/dev','r')
                f.readline()
                f.readline()
                f.readline()
                f.readline()
                line = f.readline()
                strline = line.split(' ')
                strline2 = []
                for a in strline:
                        if a != ' ':
                                if a !='':
                                        strline2.append(a)
                net['rx']=strline2[1]
                net['tx']=strline2[9]
                net['time']=str(time.time())
 
        finally:
                if f:
                        f.close()
                strline=[]
                strline2=[]
        return jsonify(net)
 
 
if __name__ == '__main__':
    app.run(host='0.0.0.0',port=5050,debug=True)

说明:
1 jsonify是flask提供的快速打包工具。使用jsonify(net),即可将net打包为json,然后直接返回即可。
2 成功实现后,请取消debug。

我提供一个示例:

http://sfo01.misaka.cc:5050/

访问得到

{
"interface": "eth0",
"rx": "58829838538",
"time": "1506500429.11",
"tx": "59272128479"
}

关于此api的利用,可以参阅我之前的文章。定期刷新获取json,解析后,两次请求数据量差与time时间戳之差之商即为网速。

4 持久运行与使用

可以使用一切使进程持续运行的方法。

可以使用tmux

开启新对话时使用 tmux

在新的会话中使用

sudo python app.py

终端即可直接关闭

5 小结

至此。我们使用flask完成了一个最简单的API的搭建。下一步可以考虑更广的用途。

最后,笔者为生活在一个不需要重复造轮子的时代而感到幸运。

6 相关阅读

[1] Linux下/proc目录简介 http://blog.csdn.net/zdwzzu2006/article/details/7747977
[2] 百度百科-JSON https://baike.baidu.com/item/JSON
[2] Flask框架中文文档 http://docs.jinkan.org/docs/flask/

原文来自 https://steinslab.xyz/archives/1275

 

microPython高级应用

内部文件系统

microPython支持标准的Python的文件模块,可以使用open()这类原生函数。

需要注意的是esp32上实时资源少,需要及时关闭掉一些file、socket。

创建一个文件

>>> f = open('data.txt', 'w')
>>> f.write('some data')
9
>>> f.close()

其中这个9是指write()函数写进去的字节数

查看一个文件

>>> f = open('data.txt')
>>> f.read()
'some data'
>>> f.close()

文件目录操作

>>> import os   # 引用os模块
>>> os.listdir()    # 查看当前目录下的所有文件
['boot.py', 'port_config.py', 'data.txt']
>>> os.mkdir('dir') # 创建目录
>>> os.remove('data.txt')   # 删除文件

esp启动顺序

首先运行_boot.py这个脚本,把文件系统挂载上,这个部分一般是固定的,不推荐用户来修改,可能会出很多奇怪的问题。

当文件系统挂载成功后,运行boot.py,在这个脚本里面,用户可以设置一些在REPL里面需要使用的变量或者函数,每次重启esp32,这个脚本也会运行一次,但是如果这个地方写错了代码, 比如进入了死循环之类的,你就需要重新刷固件了。

最后系统会从文件系统运行main.py(如果不存在,就不会运行),这个文件就是用来每次启动的时候运行用户程序而不是进入REPL的,对于一些小的脚本,你可以直接写成一个main.py名字的文件,不过也会推荐你把一个大应用分散来写,写成多个小程序,在main.py里面这么写就好了:

import my_app

my_app.main()

设置开机自启动的脚本

对boot.py和main.py这两个文件进行修改都可以,比如对main.py进行修改:

>>> file = open("main.py", 'w')
>>> file.write("""import time
... for i in range(0,10):
...     time.sleep(1)
...     print(i)""")
64
>>> file.close()

通过快捷键ctrl+D,软启动esp32,就能看到上面的效果了

>>>
PYB: soft reboot
0
1
2
3
4
5
6
7
8
9
MicroPython v1.9.1-394-g79feb956 on 2017-08-03; ESP32 module with ESP32
Type "help()" for more information.
>>>

网络socket应用

简单的连接WiFi和设置热点可以看上一篇教程,成功之后就可以考虑TCP socket连接了。

在这里我们可以用socket模块,但其实有更加方便的模块,urequests(u表示这个模块和标准python的模块相比有许多没有方法没有实现):

import urequests

r = urequests.get('http://www.baidu.com')   # 发起HTTP的GET请求
r.text  # 查看服务器返回的内容<span id="mce_marker" data-mce-type="bookmark" data-mce-fragment="1">​</span>

urequests实现了主要的几个方法,比如get、post、put、delete这几种请求,在网络方面使用起来非常方便。 

Thonny——树莓派上Python的最新IDE

Thonny是最新的Raspbian系统中直接自带的Python IDE,支持Python3.6,更新到最新的Raspbian之后无需安装其他,就能打开使用。

在Menu>Programming中就能找到这个IDE

 

打开之后可以看到主要是两个区域,包括一个代码编辑区和一个shell的窗口,前者用来编写代码,后者可以用来更加直接地交互。

与IDLE相比,Thonny还有一大堆更加强大的适合学习编程地特性,比如他的debug模式,在debug模式中可以逐行运行代码,同时可以看到所有对象或变量的状态,在其他的一些IDE里面,它们会需要用户来设置断点,但是Thonny不需要,它有更加方便的方法。

如何使用Thonny

在代码编辑区正常地编写代码,代码高亮是有的,当然补全还是不存在的,写完一部分代码之后单击上方的三角形来运行代码,运行结果就会在下方地shell窗口中显示出来。

 

用Thonny来Debug

选择View>Variables,就会有一个新的变量小窗口显示出来,并且可以看到当前的n的值(0),单击上方的Debug图标,就会开始调试模式,第一行会高亮,接着再点击Step Into就会高亮变量,接着点击,变量会变成他的高亮的值(10);另外单机Step Out就能跳出while这个循环。

在Thonny中理解递归

对于这样一段代码

n = 3

def count(n):
  if n > 0:
    print(n)
    count(n-1)
  else:
    print("Blast off!")

count(n)

通过Thonny的Debug模式,就能非常直观地来看懂这段递归的代码。

在Thonny中观察程序运行时的堆和对象

选择VIew > Heap和View > Objects,那么当你调试下面的面向对象的代码的时候,就能很方便地在调试过程中看每个对象的属性和方法。

class Animal():
  def __init__(self, c, n):
    self.creature = c
    self.name = n
    
  def get_creature(self ):
    return self.creature

  def get_name(self):
    return self.name
    
animals = []

animals.append(Animal("Dog", "Fido"))
animals.append(Animal("Cat", "Claws"))
animals.append(Animal("Mouse","Nibbles"))

for animal in animals:
  name = animal.get_name()
  creature = animal.get_creature()
  print(name + " is a " + creature)

 

总体而言,这是一个轻量级的、同时又有不错的调试模式的IDE,非常适合在树莓派上学习Python时使用。