Author: 互联网

国家耗数亿元巨资打造的天河、太湖之光等超级计算机，使中国得以在超级计算机排名中长期霸榜。不过除了砸大钱盖超级计算机之外，美国国家实验室则是选泽了更节省成本的方式，来打造超级计算机，利用750片树莓派开发板组成的运算丛集，成功打造出一台更省钱的超级计算机，未来更要扩大至1万个节点扩充，挑战挤进全球百大Peta级超级计算机排名。目前这套HPC系统已经实际展开测试，未来也将用于科学研究之用。这台树莓派超级计算机本周也在美国丹佛举行的2017超级计算机展上公开展出 。

这套系统藉由5套每个包含150张Raspberry Pi 3 B的6U机箱模块构成，且由于Raspberry Pi 3 B搭载了64位的四核心ARMv8 1.2GHz，高达750张Raspberry Pi 3 B也意味著有超过3000个以上的核心，足以满足特定超级计算机的多核需求。

值得一提的是，Raspberry Pi 3 Model B的国内售价为240元左右，所以750张树莓派组成的超级计算机售价大概为18万元，这对于一台拥有3000核心以上的超级计算机来说已经是最低价格了。

其实利用树莓派来打造超级计算机，早已不是新鲜事。火柴盒大小外型的树莓派，因为具备有迷你电脑的功能，2012年一推出就十分受到欢迎，甚至还掀起了一股自造者（Maker）风潮。一台千元有找的树莓派开发板，因为价格便宜，不只成为许多新创公司开发及验证产品的首选，这股DIY热潮甚至也蔓延到科学界，开始有人将它用在科学研究，例如，2012年就有美国树城州立大学博士生Joshua Kiepert用32个树莓派组成运算丛集，成本不到2,000美元。

后来，更有英国南安普敦大学一名电脑工程师，使用64个树莓派和乐高积木，来打造出超级计算机Iridis-Pi，成本只花不到台币13万元。这次由美国能源部两大国家实验室之一的洛斯阿拉莫斯国家实验室（ Los Alamos National Laboratory）自建的树莓派超级计算机，使用的树莓派更是当时数量的10倍，多达成750片树莓派开发板组成的运算丛集。

用750片树莓派打造世界级的超级计算机

洛斯阿拉莫斯国家实验室自建的超级计算机，主要采用BitScope提供的模组式刀锋机柜来搭建，因为全采用树莓派开发板来设计超级计算机，所以成本上也比一般超级计算机还便宜，甚至使用上也更省电，每个运算节点平均耗电只有2到3瓦而已。

根据洛斯阿拉莫斯国家实验室高效能运算部门负责人Gary Grider表示，这个树莓派超级计算机系统内，总共内建750个CPU计算节点（采用1.2 GHz Quad Core ARMv8处理器），拥有高达3,000颗核心可供计算使用，已经具备有等同超级计算机的计算能力。该实验室未来还要扩大规模挑战1万个，甚至最多5万个节点扩充，单以运算效能来看，理论上，跟自家的Grizzly超级计算机系统（全球排名85，运算效能达到1.5 PFLOPS）相比，将毫不逊色，甚至比台湾国网中心自行研发排行全球95名的Peta超级计算机（运算效能有1.325PFLOPS）都还快。

不只目标要挤进前百大，这台树莓派超级计算机的建置成本，比起一般超级计算机还更加便宜，虽然Gary Grider并未透露实际的建置成本，但若以他们使用的Raspberry Pi3 Model B（售价35美元）来计算的话，750个树莓派加总成本差不多2万6千美元（约台币78万元），即使在加上其他的基础建置费用，还是远比一般动辄上亿美元的超级计算机建置成本低许多。

Gary Grider表示，开发人员可以利用树莓派的模组及软体，在超级计算机上来编写应用，而不需要花费数亿美元购买高成本的软硬体，来搭建HPC测试平台，而且更耗电，需要数百万瓦（MW）的电力才可供系统正常运作。 Gary Grider也透露，他们自建的树莓派超级计算机，每个运算节点平均耗电只有2到3瓦，即使是将750个节点全部加总起来，耗电量也远低于目前许多的超级计算机，不只省钱也省电，而且系统还可以依需求弹性扩充。

树莓派超级计算机的机箱共有5个刀锋模组组成，每个模组可以装下150片树莓派开发板，上图为其中一个刀峰模组，并经由乙太网路连接，来建立运算丛集，机箱内也整合交换器，还配备一组48伏特的电源供应器设备来供电。

然而，要用数千到数万台树莓派组出一台Peta级的超级计算机，并不是件容易的事，因为随着运算丛集规模变大，不同运算节点和节点之间连接和传输也将变得更加复杂，而容易造成存取延迟与传输频宽不足的问题，而影响了系统的效能，这也是系统扩充的挑战。即使是洛斯阿拉莫斯国家实验室一开始，也只能扩充到最多40个运算节点，后来，他们找来了HPC厂商BitScope及SICORP共同合作，重新设计机箱和进行系统整合，来解决系统扩充的难题，才从原来最多40个节点，增加到144个，到现在的750个节点，未来还要挑战数千到数万个节点的扩充。

根据SICORP网站的介绍，树莓派超级计算机是采用BitScope提供的模组式刀锋机柜来搭建，机箱内由5个刀锋模组组成，每个模组一次最多可以装入150片树莓派开发板，这些运算模组可以经由乙太网路连接，来建立运算丛集，机箱内也整合网路交换器，还配备一组48伏特的电源供应器设备供电。

不过，Gary Grider也强调，这台树莓派超级计算机并非用来取代其他超级计算机，而是希望当作提供给开发人员，及研究者，另一个可用于研究测试及验证的全新HPC运算平台，不只具备高效能计算能力，而且更便宜。他也表示，未来除了会持续增加节点数量，来提高运算效能外，也将建立新的网路架构，并且结合引入（ bootstrap）、管理及灾难复原的演算法，以及聚焦系统与分散式储存研究等。

前些天写了篇文章是利用树莓派制作一个开关门监控设备的雏形《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

‘ ser.write(W_http_6) time.sleep(2) W_http_7=’AT+HTTPACTION=0\r

‘ ser.write(W_http_7) time.sleep(3) if __name__ == ‘__main__’: ser = serial.Serial(“/dev/ttyS0″,115200) W_http_1=’AT+HTTPTERM\r

‘ ser.write(W_http_1) time.sleep(3) W_http_2=’AT+SAPBR=3,1,”CONTYPE”,”GPRS”\r

‘ ser.write(W_http_2) time.sleep(3) W_http_3=’AT+SAPBR=3,1,”APN”,”CMNET”\r

‘ ser.write(W_http_3) time.sleep(3) W_http_4=’AT+SAPBR=1,1\r

‘ ser.write(W_http_4) time.sleep(3) W_http_5=’AT+HTTPINIT\r

‘ 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

‘ ser.write(W_http_1) time.sleep(3) W_http_2=’AT+SAPBR=3,1,”CONTYPE”,”GPRS”\r

‘ ser.write(W_http_2) time.sleep(3) W_http_3=’AT+SAPBR=3,1,”APN”,”CMNET”\r

‘ ser.write(W_http_3) time.sleep(3) W_http_4=’AT+SAPBR=1,1\r

‘ ser.write(W_http_4) time.sleep(3) W_http_5=’AT+HTTPINIT\r

‘ 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

‘ ser.write(W_http_6) time.sleep(2) W_http_7=’AT+HTTPACTION=0\r

‘ 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页面图标，对门的开关效果进行动态展示。每个人的需求不同，展示部分的代码就不做说明，也参照上诉方案自行编写。

作者：高杆python

链接：http://www.jianshu.com/p/c470f2ab739d

本文来自 Gloomy Ghost 的投稿，介绍了如何在树莓派2B上安装运行 Minecraft 1.8.9。

更新系统

sudo apt-get update && sudo apt-get -y upgrade

安装相应的显示程序

sudo apt-get -y install xcompmgr libgl1-mesa-dri && sudo apt-get -y install libalut0 libalut-dev && sudo apt-get -y install mesa-utils

配置显卡显示选项

sudo raspi-config

找到Advanced Options，设置GL Driver为GL (Full KMS)。

超频

这个不用我教了吧，超到 High(1000MHz)就行了。

然后重启。

sudo reboot

测试显卡是否配置完成

glxgears

一、使用官方账号游戏

获取官方启动器

mkdir ~/Minecraft; mkdir ~/Minecraft/Natives; cd ~/Minecraft && wget http://ouav818sk.bkt.clouddn.com/raspimc/Minecraft.jar

这里我创建2个文件夹，用于存放文件，运行mc启动器，下载游戏文件。

java -jar Minecraft.jar

下载配置文件

登陆

新建配置

版本选择1.8.9

下载安装

二、无账号游戏

下载 Hello Minecraft!! Launcher

mkdir ~/Minecraft; mkdir ~/Minecraft/Natives; cd ~/Minecraft && wget https://github.com/huanghongxun/HMCL/releases/download/v2.5.3/HMCL-2.5.3.88.jar

这里我创建2个文件夹，用于存放文件，运行mc启动器，下载游戏文件。

java -jar HMCL-2.5.3.88.jar

下载运行库文件

cd ~/Minecraft/Natives && wget http://ouav818sk.bkt.clouddn.com/raspimc/liblwjgl.so && wget http://ouav818sk.bkt.clouddn.com/raspimc/libopenal.so

更新lwjgl

cd ~/.minecraft/libraries/org/lwjgl/lwjgl/lwjgl/2.9.4-nightly-20150209 && rm lwjgl-2.9.4-nightly-20150209.jar; wget http://ouav818sk.bkt.clouddn.com/raspimc/lwjgl-2.9.4-nightly-20150209.jar

（基于Roger Allen的教程：http://rogerallen.github.io/jetson/2014/07/31/minecraft-on-jetson-tk1/

复制运行脚本）

cd ~/Minecraft/ && wget http://ouav818sk.bkt.clouddn.com/raspimc/run.sh && sudo chmod +x run.sh

编辑 run.sh（正版）

编辑下面的配置，填上你的游戏账户信息。

MINECRAFT_LOGIN

MINECRAFT_USERNAME

MINECRAFT_PASSWORD

完成正版登陆

运行游戏

./run.sh

相关代码如果觉得不方便，可以到这里查看，我把所有命令整合了一下。

编者按：早先我们有一篇《树莓派64位系统Debian 9先行测评：性能最高提升30倍！》的文章里面测试了按64位系统下树莓派3B的性能表现。现在有树莓派玩家放出了可用的64位系统（Ubuntu 版），有兴趣的朋友可以安装体验一下。

前言

我对于 Linux 里的 Ubuntu 情有独钟，包括对树莓派3也不放过，树莓派3有一个64位的CPU，但一直使用的是32位的系统，太憋屈了，最近看见 barnami 大神移植了 Debian stretch arm64 到树莓派上（项目地址 https://github.com/bamarni/pi64），不过，我想说的，还是 Ubuntu。

Ubuntu 的 arm64 版本可不好找，不像 Debian 有一个健壮的 arm64 移植版，所以我找了很久，找到了一个15.10(没办法，只能这样了)，对于 15.10 官方不给支持了（毕竟不是LTS）。

介绍

本系统由以下组成

boot: 原汁原味官方 Ubuntu 16.04 armhf for Raspiberry Pi 3

firmware: 由树莓派官方的 linux-rpi-4.9.y 编译的 aarch64

rootfs: Ubuntu15.10 (无力吐槽)

对于这次移植呢，有点小问题，就是开机在boot界面时会连接某服务器，但这服务器访问不了，会重试几次，但还不善罢甘休，请求 192.168.1.1 的相应地址（废话，更不行了），导致开机可能要花一点时间，不过不影响系统的正常使用，各项功能没有太大问题。

欢迎大家参与测试，优化，调试。

特点

使用了 aarch64 内核，完美搭建arm64系统底层

使用了 arm64 系统，性能更好

完美释放出了树莓派3的性能

驱动各方面迄今无太大问题

稳定性有待提高

暂时没有升级到 16.04 或 17.04，可以借助官方帮助文档进行交叉升级。

传送门

Ubuntu 15.10 arm64

GitHub 地址: https://github.com/chainsx/ubuntu64-rpi

版本说明：

默认用户：ubuntu 密码：ubuntu；root 用户密码：root

默认开启 SSH，不想要的自己去关。

默认为命令行，想要图形界面的自己装。

第一次开机时不会拓展 rootfs 分区，意思是你需要自己拓展，用 fdisk 或 gparted 来拓展吧。

Ubuntu 17.04 for rpi3(64位内核，32位系统)

GitHub 地址: https://github.com/chainsx/ubuntu-17.04-for-RaspberryPi3

版本说明：

集成了raspi-config，你只需要在命令行里输入raspi-config就行了。

默认用户名：ubuntu 密码：chainsx007

支持安装gnome, apt install gnome 即可，unity 待测（不过，gnome卡出翔）。

默认为命令行，需要桌面的自行安装，推荐lxqt，：安装apt install lxqt。

因为是源自 rpi2 移植的，所以在 boot 分区有两个内核，一个是rpi3的（默认），另外一个是rpi2的（当然不支持64位内核），需要在config.txt里将kernel=kernel8.img改为kernel=uboot.bin。我觉得，你要在pi2上用的话还不如直接在官方下载。

关于我

本人喜欢玩 Linux，更多的是喜欢乐在其中，结交更多好友，学习更多技术。

小编按：本文作者 Github 中提供了联系方式 1396219808[a]qq.com，如有项目相关问题可尝试联系原作者。

虽然只是推荐，但我相信，树莓派3的64位除了 openSUSE 的系统（Debian、Ubuntu）是非常惊人的吧！

我也亲自测试过，这两种系统完全完全的把树莓派3的64位性能给释放出来了，十分惊人，不推荐一下完全对不起原作者的苦心和树莓派的 ARMv8 芯片。

原作者表示：原文无任何版权，我们只是乐在其中，以后还要定期更新，我其实想抽空一直维护这个系统，直到Ubuntu官方的系统正式发布为止。此系统无任何风险（因为我以前制作安卓第三方ROM时就被质疑过，但最后证明了的却无任何风险，这个也一样）。

作者：CX_Dandelion

出处：http://www.jianshu.com/p/a955348083bd

来自好奇吖斌的投稿，感谢~

最近在学习树莓派，驱动OLED屏时出现了一个问题，就是花屏，折腾了两天后发现原来这个OLED的驱动芯片不是SSD1306而是SH1106，所以用Adafruit_Python_SSD1306这个库是花屏的。

OLED的驱动芯片有好几种，但是有的库只支持SSD1306芯片，所以当你的OLED屏出现花屏时就应该是芯片和库没对应上，购买OLED屏时最好购买i2c的SSD1306芯片的，库多且接线比较简单。

Python有两个可以用的OLED库：

Adafruit_Python_SSD1306库—>只支持SSD1306

Luma.oled库—>支持SSD1306 / SSD1322 / SSD1325 / SSD1331 / SH1106

Adafruit_Python_SSD1306库与Luma.oled库的安装说明(看不懂英文没关系，看下面我会说)。

本文的Luma.oled库参考了I2C接口的OLED在树莓派3上的应用 ，但这是旧版本的，新版本库不是这样安装，请看下文。

i2c接线

OLED引脚 树莓派物理BOARD引脚 VCC 1号 GND 6号 SCL 5号 SDA 3号

接好线后就是像一个L型的。

开启i2c功能

sudo apt-get install -y python-smbus sudo apt-get install -y i2c-tools sudo raspi-config

打开树莓派配置选择5 Interfacing Options。

选择P5 I2C回车激活I2C。

按回车启动就得了。

查看i2c地址

sudo i2cdetect -y 1

然后你能看到下面的地址，3c就是oled屏的i2c地址了，说明已经成功开启i2c啦

– 安装Adafruit_Python_SSD1306库

终端输入下面命令。

sudo apt-get update sudo apt-get install build-essential python-dev python-pip sudo pip install RPi.GPIO sudo apt-get install python-imaging python-smbus sudo apt-get install git git clone https://github.com/adafruit/Adafruit_Python_SSD1306.git cd Adafruit_Python_SSD1306 sudo python setup.py install

安装好Adafruit_Python_SSD1306库后，cd examples进入例程目录，ls查看文件，以shapes.py例程说明。

import time import Adafruit_GPIO.SPI as SPI import Adafruit_SSD1306 import Image import ImageDraw import ImageFont # Raspberry Pi pin configuration: RST = 24 # Note the following are only used with SPI: DC = 23 SPI_PORT = 0 SPI_DEVICE = 0 # Beaglebone Black pin configuration: # RST = ‘P9_12’ # Note the following are only used with SPI: # DC = ‘P9_15’ # SPI_PORT = 1 # SPI_DEVICE = 0 # 128×32 display with hardware I2C: disp = Adafruit_SSD1306.SSD1306_128_32(rst=RST) # 128×64 display with hardware I2C: # disp = Adafruit_SSD1306.SSD1306_128_64(rst=RST) # Alternatively you can specify an explicit I2C bus number, for example # with the 128×32 display you would use: # disp = Adafruit_SSD1306.SSD1306_128_32(rst=RST, i2c_bus=2) # 128×32 display with hardware SPI: # disp = Adafruit_SSD1306.SSD1306_128_32(rst=RST, dc=DC, spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE, max_speed_hz=8000000)) # 128×64 display with hardware SPI: # disp = Adafruit_SSD1306.SSD1306_128_64(rst=RST, dc=DC, spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE, max_speed_hz=8000000)) # Alternatively you can specify a software SPI implementation by providing # digital GPIO pin numbers for all the required display pins. For example # on a Raspberry Pi with the 128×32 display you might use: # disp = Adafruit_SSD1306.SSD1306_128_32(rst=RST, dc=DC, sclk=18, din=25, cs=22) # Initialize library. disp.begin() # Clear display. disp.clear() disp.display() # Create blank image for drawing. # Make sure to create image with mode ‘1’ for 1-bit color. width = disp.width height = disp.height image = Image.new(‘1’, (width, height)) # Get drawing object to draw on image. draw = ImageDraw.Draw(image) # Draw a black filled box to clear the image. draw.rectangle((0,0,width,height), outline=0, fill=0) # Draw some shapes. # First define some constants to allow easy resizing of shapes. padding = 2 shape_width = 20 top = padding bottom = height-padding # Move left to right keeping track of the current x position for drawing shapes. x = padding # Draw an ellipse. draw.ellipse((x, top , x+shape_width, bottom), outline=255, fill=0) x += shape_width+padding # Draw a rectangle. draw.rectangle((x, top, x+shape_width, bottom), outline=255, fill=0) x += shape_width+padding # Draw a triangle. draw.polygon([(x, bottom), (x+shape_width/2, top), (x+shape_width, bottom)], outline=255, fill=0) x += shape_width+padding # Draw an X. draw.line((x, bottom, x+shape_width, top), fill=255) draw.line((x, top, x+shape_width, bottom), fill=255) x += shape_width+padding # Load default font. font = ImageFont.load_default() # Alternatively load a TTF font. # Some other nice fonts to try: http://www.dafont.com/bitmap.php #font = ImageFont.truetype(‘Minecraftia.ttf’, 8) # Write two lines of text. draw.text((x, top), ‘Hello’, font=font, fill=255) draw.text((x, top+20), ‘World!’, font=font, fill=255) # Display image. disp.image(image) disp.display()

按照你的oled屏修改代码，程序默认是12832的，你的oled屏是这个就不用改直接运行就OK。

如果是12864的I2C就像下面那样修改，把12832加#注释，12864#注释去掉保存。

# 128×32 display with hardware I2C: #disp = Adafruit_SSD1306.SSD1306_128_32(rst=RST) # 128×64 display with hardware I2C: disp = Adafruit_SSD1306.SSD1306_128_64(rst=RST)

终端输入sudo python shapes.py或用Python打开文件运行就能看到OLED屏有显示了。

– 安装Luma.oled库

终端输入下面命令。

sudo apt-get install python-dev python-pip libfreetype6-dev libjpeg-dev sudo -H pip install –upgrade pip sudo apt-get purge python-pip sudo -H pip install –upgrade luma.oled

注：如果你需要安装Python3的Luma.oled库的则按下面对应的Python3版本修改上面的命令进行安装。

pip ⇒ pip3

python ⇒ python3

python-dev ⇒ python3-dev

python-pip ⇒ python3-pip

如果安装Luma.oled库时出现红字错误，请继续执行命令重试，那是因为网络问题下载一个叫Pillow的库不成功。

安装好Luma.oled库后新建文件命名为oled.py，复制粘贴下面代码。参考这里使用说明

from luma.core.interface.serial import i2c, spi from luma.core.render import canvas from luma.oled.device import ssd1306, ssd1325, ssd1331, sh1106 # rev.1 users set port=0 # substitute spi(device=0, port=0) below if using that interface serial = i2c(port=1, address=0x3C) # substitute ssd1331(…) or sh1106(…) below if using that device device = sh1106(serial)#这里改ssd1306, ssd1325, ssd1331, sh1106 with canvas(device) as draw: draw.rectangle(device.bounding_box, outline=”white”, fill=”black”) draw.text((30, 40), “Hello World”, fill=”white”)

如果你的oled驱动芯片是其它型号找到device = sh1106(serial)，把sh1106改成库支持的其它型号。

树莓派上用Python2打开oled.py运行就能看到下图的Hello World。

能驱动成功后我们去下载Luma.oled的examples代码。

然后是examples里面的例子怎么用呢？如果是非ssd1306芯片直接运行还是花屏的，因为那个examples的代码需要修改。

下面以pi_logo.py为例参考上面那个Hello World的例子修改成自己OLED芯片型号的(文件放在在examples内)。

#!/usr/bin/env python # -*- coding: utf-8 -*- # Copyright (c) 2014-17 Richard Hull and contributors # See LICENSE.rst for details. # PYTHON_ARGCOMPLETE_OK “”” Display the Raspberry Pi logo (loads image as .png). “”” import os.path from PIL import Image from luma.core.interface.serial import i2c, spi from luma.oled.device import ssd1306, ssd1325, ssd1331, sh1106 def main(): img_path = os.path.abspath(os.path.join(os.path.dirname(__file__), ‘images’, ‘pi_logo.png’)) logo = Image.open(img_path).convert(“RGBA”) fff = Image.new(logo.mode, logo.size, (255,) * 4) background = Image.new(“RGBA”, device.size, “white”) posn = ((device.width – logo.width) // 2, 0) while True: for angle in range(0, 360, 2): rot = logo.rotate(angle, resample=Image.BILINEAR) img = Image.composite(rot, fff, rot) background.paste(img, posn) device.display(background.convert(device.mode)) if __name__ == “__main__”: try: serial = i2c(port=1, address=0x3C) device = sh1106(serial) main() except KeyboardInterrupt: pass

Python运行上面的程序oled屏会出现一个能旋转的树莓派LOGO。

全文完。

来源：解决树莓派驱动OLED(非SSD1306)花屏问题

作者：好奇吖斌

不算是什么新功能了，在树莓派3B发布后不久，树莓派官方 Raspbian 系统久加入了允许在开机前对 WiFi 网络进行配置的机制。

注意，这个方法仅适用于全新安装树莓派系统到 SD 卡之后没有做过任何 Wi-Fi 配置的情况下有效。如果你之前配置过 Wi-Fi，再用本方法系统会默认使用已有的配置而忽略这里的配置。因此建议使用前重新安装系统。

一、WiFi 网络配置

用户可以在未启动树莓派的状态下单独修改 /boot/wpa_supplicant.conf 文件配置 WiFi 的 SSID 和密码，这样树莓派启动后会自行读取 wpa_supplicant.conf 配置文件连接 WiFi 设备。

操作方法简单：将刷好 Raspbian 系统的 SD 卡用电脑读取。在 boot 分区，也就是树莓派的 /boot 目录下新建 wpa_supplicant.conf 文件，按照下面的参考格式填入内容并保存 wpa_supplicant.conf 文件。

country=CN ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev update_config=1 network={ ssid=”WiFi-A” psk=”12345678″ key_mgmt=WPA-PSK priority=1 } network={ ssid=”WiFi-B” psk=”12345678″ key_mgmt=WPA-PSK priority=2 scan_ssid=1 }

说明以及不同安全性的 WiFi 配置示例：

#ssid:网络的ssid

#psk:密码

#priority:连接优先级，数字越大优先级越高（不可以是负数）

#scan_ssid:连接隐藏WiFi时需要指定该值为1

如果你的 WiFi 没有密码

network={ ssid=”你的无线网络名称（ssid）” key_mgmt=NONE }

如果你的 WiFi 使用WEP加密

network={ ssid=”你的无线网络名称（ssid）” key_mgmt=NONE wep_key0=”你的wifi密码” }

如果你的 WiFi 使用WPA/WPA2加密

network={ ssid=”你的无线网络名称（ssid）” key_mgmt=WPA-PSK psk=”你的wifi密码” }

如果你不清楚 WiFi 的加密模式，可以在安卓手机上用 root explorer 打开 /data/misc/wifi/wpa/wpa_supplicant.conf ，查看 WiFi 的信息。

二、开启 SSH 服务

如果通过 ssh 连接树莓派出现 Access denied 这个提示则说明 ssh 服务没有开启。要手动开启的话，和 WiFi 配置相似，同样在 boot 分区新建一个文件，空白的即可，文件命名为 ssh。注意要小写且不要有任何扩展名。

树莓派在启动之后会在检测到这个文件之后自动启用 ssh 服务。随后即可通过登录路由器找到树莓派的 IP 地址，通过 ssh 连接到树莓派了。（有关开启 SSH 服务的详细方法）

如果需要远程桌面方式操作树莓派，可以通过 ssh 安装 xrdp，再用 Windows 的远程桌面客户端连接到树莓派。

这个小技巧对于没有有线网卡、没有标准 USB 接口来直连键鼠，但集成了 WiFi 的树莓派 Zero W 尤其实用。

来自 David 的投稿，花了好多心血研究，感谢～

树莓派同Beaglebone Black，Arduino一起被称为3大开源硬件。笔者对比过这三个平台，觉得树莓派是最适合单片机工程师学习Linux的SBC，树莓派玩熟了剩下的两个平台也很容易融入。另外大家应该知道，树莓派是当前全球第三大计算机平台（另外两个Windows-PC & MacOS-PC不用我介绍了吧），树莓派现在硬件可以定制，完全可以用于产品开发！它不仅是创客玩具！

Cpu core: BCM2708/BCM2709/BCM2710 Cpu packages: BCM2835/BCM2836/BCM2837

如今Linux计算机体系从硬件到软件都很复杂，覆盖电路设计，底层内核与驱动设计，应用软件设计，系统运维多个方面，我们精力有限，无法逐一精通。像我，单片机起家的就选择专注于Linux应用软件设计（吐槽：我觉得做内核做驱动是纯技术活，枯燥，不够Business, 再说做单片机对硬件，驱动，RTOS都折腾过了，兴趣不大。但是我特别尊重那些做纯技术活的NB人，他们是灵魂工作者，保持了自我，毕竟社会太浮躁了…）

扯远了，难怪老婆说我啰嗦，言归正传！

首先需要一块树莓板，我用了Model B+, Arm11的老内核，不过都一样，Linux玩的是软件，

以下请准备：

1：FT232 USB转串口模块

2：RT2870/RT3070 Wireless Adapter USB无线网卡，兼容卡也行

3：8G class10 SD卡 + USB读卡器

4：5V，2A电源

5：RJ45网线 + USB有线网卡

6：USB转TTL串口线，用于终端命令行，我的PL2303芯片的（吐槽，还是FTDI Chip好）

7：我无奈的又用了一个USB hub，如今的笔记本USB口真TM金贵

好吧，把所有连接，连接，再连接，最后就是:

镜像下载：https://www.raspberrypi.org/downloads/raspbian/

我用了最新的OS RASPBIAN STRETCH LITE，这是Debian9的OS，BB Black也是Debian

用Win32DiskImager工具软件烧写空的SD卡，烧完就插卡上电，启动

注意USB无线网卡和USB串口此时已经被系统识别！

开始系统配置！

1：开启root权限，登陆pi账户，在命令行输入如下：

sudo passwd root

sudo passwd –unlock root

su root

跳转到root账户命令行

2：增加root账户SSH登陆权限，为了安全，默认情况OS禁止了root登陆

用nano编辑/etc/ssh/sshd_config

PermitRootLogin行处改为 ‘PermitRootLogin yes’

3: 配置各个网卡

我的笔记本USB有线网卡IP:192.168.1.71，直接连接树莓ETH0网卡

我的树莓ETH0网卡IP:192.168.1.11（ETH0有时候识别为别的name，我搞不清这个name命名机制，谁懂 Why enxb827eb957644? Call me!）

我的树莓USB无线网卡，使用DHCP，连接手机的wifi热点（吐槽: 外企Web不好用，干脆用自己的流量了）

我需要我的树莓有2个可以使用的网卡，但是无论怎么配置我发现都有使用冲突（一个静态IP,一个动态IP），网上一堆的配置教程都不Work,可把我整惨了，于是我决定自己搞:

ETH0(enxb827eb957644)配置: 修改/etc/rc.local增加一行启动脚本

#!/bin/bash x=$( ifconfig -a | grep -c “eth0” ) if [ $x -eq 1 ];then ifconfig eth0 192.168.1.11 up else ifconfig enxb827eb957644 192.168.1.11 up fi touch power_on_time.log echo “Your PI is powered up at: ” > power_on_time.log date >> power_on_time.log echo “Init…”

USB无线网卡设置：

直接修改wpa_supplicant.conf：

root@raspberrypi:/etc# cd wpa_supplicant

country=GB ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev update_config=1 network={ ssid=”david-wifi” psk=”12345678″ }

或者修改interfaces文件,追加wpa.conf

Interfaces内容:

auto wlan0 iface wlan0 inet dhcp wpa-conf /etc/wpa.conf # iface default inet dhcp

wpa.conf内容:

network={ ssid=”david-wifi” key_mgmt=WPA-PSK psk=”12345678″ }

Show log:

root@raspberrypi:~# ifconfig -a enxb827eb957644: flags=4163 mtu 1500 inet 192.168.1.11 netmask 255.255.255.0 broadcast 192.168.1.255 inet6 fe80::9de1:de0c:cb1d:462b prefixlen 64 scopeid 0x20 ether b8:27:eb:95:76:44 txqueuelen 1000 (Ethernet) RX packets 2361 bytes 206594 (201.7 KiB) RX errors 0 dropped 0 overruns 0 frame 0 TX packets 1140 bytes 180441 (176.2 KiB) TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0 lo: flags=73 mtu 65536 inet 127.0.0.1 netmask 255.0.0.0 inet6 ::1 prefixlen 128 scopeid 0x10 loop txqueuelen 1 (Local Loopback) RX packets 0 bytes 0 (0.0 B) RX errors 0 dropped 0 overruns 0 frame 0 TX packets 0 bytes 0 (0.0 B) TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0 wlan0: flags=4163 mtu 1500 inet 192.168.43.236 netmask 255.255.255.0 broadcast 192.168.43.255 inet6 fe80::eb41:da24:d28:8575 prefixlen 64 scopeid 0x20 ether f4:28:53:0e:6a:25 txqueuelen 1000 (Ethernet) RX packets 69 bytes 6756 (6.5 KiB) RX errors 0 dropped 0 overruns 0 frame 0 TX packets 101 bytes 11817 (11.5 KiB) TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0 root@raspberrypi:~# ping 192.168.1.11 PING 192.168.1.11 (192.168.1.11) 56(84) bytes of data. 64 bytes from 192.168.1.11: icmp_seq=1 ttl=64 time=0.210 ms 64 bytes from 192.168.1.11: icmp_seq=2 ttl=64 time=0.226 ms — 192.168.1.11 ping statistics — 2 packets transmitted, 2 received, 0% packet loss, time 1001ms rtt min/avg/max/mdev = 0.210/0.218/0.226/0.008 ms ^Croot@raspberrypi:~# ping www.baidu.com PING www.a.shifen.com (180.97.33.107) 56(84) bytes of data. 64 bytes from 180.97.33.107 (180.97.33.107): icmp_seq=1 ttl=50 time=45.1 ms 64 bytes from 180.97.33.107 (180.97.33.107): icmp_seq=2 ttl=50 time=47.0 ms 64 bytes from 180.97.33.107 (180.97.33.107): icmp_seq=3 ttl=50 time=39.5 ms ^C — www.a.shifen.com ping statistics — 3 packets transmitted, 3 received, 0% packet loss, time 2002ms rtt min/avg/max/mdev = 39.559/43.928/47.057/3.184 ms root@raspberrypi:~#

重启树莓派，让一切生效！

配置更新树莓派!

1：必须会用raspi-config指令，首先设置扩展SD卡容量

查看内存，查看存储器，最后重新分配一个tmp文件夹用于存放调试的临时程序文件，不用往FLASH上面写了

2: 更新OS内容

sudo apt-get update sudo apt-get upgrade sudo apt-get dist-upgrade

设置Vim，如果你喜欢Vim

sudo apt-get install vim

编辑/etc/vim/vimrc文件，在末尾添加以下内容

1: set nu #显示行号

2: syntax on #语法高亮

3: set tabstop=4 #Tab退四格

安装调试器：

sudo apt-get install gdbserver # 很重要！！！ sudo apt-get install picocom

如果以上有问题请学习：

1. https://shumeipai.nxez.com/hot-explorer

2.【开发指南】M6G2C&A6G2C系列核心板软件开发指南_V1.05.pdf。

3. 搜索引擎查找。

一点口水概念:

1：Linux里platform_driver，属于内存型设备驱动，驱动直接访问SOC内部寄存器，platform_device是位于芯片内部的所有片上外设,其它驱动均是用于SOC外部device访问

2：Linux中device tree配置主要起到了初始化板载硬件资源的作用，如初始化GPIO寄存器，UART寄存器等, 指定了这些寄存器的数值，dts源文件中还会有引脚分配等信息，配置引脚的功能，启动相应的驱动程序

3：Linux开发需要toolchains工具链，要写makefile，需要GDB(client debugger/server)调试器，这些资源需要自己找，自己匹配版本，自己编译测试，纷繁复杂（当然找个供应商就全解决了，都是钱的事，有钱可以是大爷。没钱你就跟我混，让你不花钱也能全搞定）

我真是说了一大堆的废话！赶紧上Linux-App-IDE，一定要整的像Keil-MDK一样方便好用，不用写Makefile。

吐槽： 我知道有人喜欢在终端里用VIM,GDB/CGDB,NFS远程连接目标机GDBserver调试程序，我知道有人喜欢用Ubuntu 用DDD调试程序，我也知道树莓可以本地GCC/GDB，但是考虑编辑易用性，编译速度，考虑大众化，哥依然坚持Windows交叉编译调试。或者什么事哥错过了，请大家告诉我这个井底蛙！

提示：强大的终端软件MobaXterm Home Edition，貌似很好用，树莓可以不用屏幕了。

为了探求一个免费，不断更新，官方支持，且好用的Linux应用软件开发IDE，我搜索了N个词条，尝试了：

Visual Studio + winGDB :要钱啊，VS太大了

Visual Studio + visualGDB: 要钱啊，VS太大了

Eclipse + plugins :插件设置TTMD麻烦了

Sourcery-CodeBench-Lite-Edition: 免费，但官方支持度差，对于树莓不敢折腾，觉得有坑，有精力的同学可以去折腾下，OK了告诉我，什么心情?

Arm-DS-5 Community Edition：官方的免费IDE，定制版Eclipse，设置方便不少。

使用ARM最新工具DS-5开发Linux简单Hello World应用程序，开胃菜，各位！

http://bbs.21ic.com/icview-410255-1-1.html?_dsign=2f342972

DS-5 Community Edition/ Version: 5.27.0/ Build number: 5270014 我决定用这个！

首先解决工具链问题，试过几个，包括Linaro。没找到一个明显告诉你交叉编译系统间库文件如何同步更新的工具链，顿时迷茫！这库都不同步，后面写程序还不是一堆问题啊，于是茫茫Internet坚持找寻，坚信树莓强大的生态链，终于有一天，SYSPROGS拯救了我。

完美，一切都是这么完美！注意一定要Updating Sysroot for Raspberry PI Cross-Toolchain

http://gnutoolchains.com/raspberry/tutorial/

http://gnutoolchains.com/raspberry/tutorial/sysroot

SYSPROGS官方完美支持了树莓1/2/3，SmarTTY终端软件也挺好用。

紧跟伟哥的步伐 GO GO GO！

1: 默认安装raspberry-gcc4.9.2-r4.exe，我的系统Win10。

2: 默认安装ds5-ce-windows64-27rel0.zip（setup.exe）。

3: 打开DS-5，选择工作空间，我的是(C:\Users\cn28060369\Documents\DS-5 Workspace)。

4: 拷贝C:\IT_CodeRepo\DS-5\examples\Linux_examples中hello_linux文件夹到DS-5工作空间。

5: File->Import已经存在的Workspace工程文件夹hello_linux到IDE中。

6: 设置工具链，选择安装的树莓专用工具链，然后Next，DS-5会自动检测工具链然后跟着提示Finish，我的图片里是已经设置过的。

7: 右击项目文件夹，选择Properties，设置工具链参数。

此处使能了并行编译！很棒吧！

当前工具链选择: GCC4.9.2就是树莓的。

8: 配置GDB debug设置

9: 使用DS-5 debugger新建一个调试项，如下图效果

尽量和我的图片设置一样

10: 远程SSH登陆树莓。

参考这个：http://blog.csdn.net/luyejie8888/article/details/38611293

差不多的，使用root账户登陆树莓试试。

11: 把原来hello.c源码改掉,我们玩树莓不能只玩python/wiring-pi,它们屏蔽了基础文件访问知识，方便但是缺乏学习意义，我们操作扩展的ttyUSB0串口，把TXD与RXD短接。

/************************** Demo for RaspberryPi **************************/ // MSG> Hi, I’m Automan, My WeChat account is OPC_davidlee // MSG> Let’s be technical partner, study and day day up // MSG> Use DS-5 IDE to simplify your Arm SOC development #include #include #include #include #include #include #include #include #include #include #include #include #define DATA_LEN 0xFF /* test data’s len */ //#define DEBUG 1 static int openSerial(char *cSerialName) { int iFd; struct termios opt; iFd = open(cSerialName, O_RDWR | O_NOCTTY); if (iFd < 0) { perror(cSerialName); return -1; } tcgetattr(iFd, &opt); //cfsetispeed(&opt, B57600); //cfsetospeed(&opt, B57600); cfsetispeed(&opt, B115200); cfsetospeed(&opt, B115200); //raw mode opt.c_lflag &= ~(ECHO | ICANON | IEXTEN | ISIG); opt.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON); opt.c_oflag &= ~(OPOST); opt.c_cflag &= ~(CSIZE | PARENB); opt.c_cflag |= CS8; // DATA_LEN bytes can be read by serial opt.c_cc[VMIN] = DATA_LEN; opt.c_cc[VTIME] = 150; if (tcsetattr(iFd, TCSANOW, &opt) < 0) { return -1; } return iFd; } int main(void) { char tmp[1024]; int len; int fd, i; int x = 0; printf(" [#1] Software operations demo: "); x = x + 1; printf("x=%d ", x); x = x - (-1); printf("x=%d ", x); x = x * x - 1; printf("x=%d ", x); x = (x + 5) / 2; printf("x=%d ", x); printf("[#2] Hardware ttyUSB0 operations demo: "); fd = openSerial("/dev/ttyUSB0"); for (i = 0; i < 3; i++) { tmp[i] = 'V'; } write(fd, tmp, 3); // send to ttyUSB0 for (i = 0; i < 3; i++) { tmp[i] = '0'; } len = read(fd, tmp, 3); for (i = 0; i < len; i++) { printf("Read value: %c ", tmp[i]); } printf("Finish test, DS-5 and PiB+ are OK! "); return 0; } 12: 激动人心的时刻到了，我们编译（debug版本才能调试，含符号信息），Project->Build All（注意保存后的文件才能再次编译生效）。

点击右上角小爬虫进入调试。

点击如下红色圈圈进入调试连接，hello执行文件会自动加载到/tmp文件夹下执行，并自动执行GDBserver。

如下：运行，断点，AppConsole输出，都是OK的了，完美！

如果想重新调试，可以点击绿色圈圈断开连接后重新再连接

到此，一个完美的IDE已经呈现给您，剩下的请您慢慢探索吧，虽然不用写makefile,但是笔者依旧建议后续学习使用Cross-GCC,Makefile,CGDB-debugger,GDB-server，Autotools,Cmake等传统工具，毕竟它们通用性强。当然如果您同我一样年纪大了，那就同我一样玩儿吧。

最后一点废话！

从拿到一个闲置树莓到搞完IDE,笔者花了1个星期去SETUP，宝宝心里苦啊！怎么就没人整个完整的IDE玩树莓呢，老命令行整人，一点都没有与时俱进！

大家可以使用相同的方式匹配BeagleBone Black，不过笔者对它兴趣不大，BBB生态不强但够用。调试接口程序的时候大家可以用Arduino-M0配合树莓调试，注意IO电压3V3，NOT 5V0！

发扬Armfly精神，哥决定投稿开源，造福单片机开发者，早早入门Linux开发，让这个装A后面的世界变得透彻，不再神秘！我好伟大！！！

附：老外整的Arm DS-5 for Raspberry Pi, 没细节，不过让我知道我的想法是可行的！要相信自己！

花了我1天时间整教程，真的好想问谁要点稿费！好想好想…好想好想…啊啊。

等打赏中…

原创：李伟（EnName: David Lee, QQName: AutoMan, QQid: 1694045209）, 转载请注明出处，欢迎爱好者技术交流。原稿PDF。

备注：如无特殊说明，文章内容均出自David个人真实理解，没有存心妄自揣测故意愚人耳目。由于个人水平有限，虽力求内容无误，但仍难免出错，请勿见怪，如果可以请留言告之，欢迎Email。(1694045209@qq.com)讨论。

近期把精心打理数年的水族缸给“开源共享了”，实现了远程观赏和喂鱼互动的功能，先看效果吧。

直播页面：http://make.quwj.com/program/nature-aquarium

远程喂鱼没有自己设计操作界面，而是接入了微信公众平台，通过微信发送指令实现投食。看这段现场演示视频：

投食说明在直播页面和项目主页都有详细介绍。这个项目的意义还在于你可以把自家的屏幕变成虚拟水族馆，没事看看鱼，和鱼互动一下，等同于养了一缸鱼。更让人激动的是，你根本只管投食只管享用悠然自得，维护鱼缸等琐碎繁杂的问题全都不用管，是不是好处占尽了呢？

下面分享一下搭建这套共享水族馆的 Make 过程，其中有关于树莓派上实现视频直播的几种方案近期会在树莓派实验室进行介绍，有兴趣的朋友可以参考把自家的宠物也共享出来（需要支持可以联系本项目作者）。

组件清单

普通生态鱼缸 × 1

树莓派主板 × 1

罗技 C270 摄像头 × 1

自动投食器 × 1

LED 鱼缸灯 × 1

继电器 × 2

路由器 × 1

公网IP地址 × 1

微信公众账号 × 1

系统架构

这里介绍下最关键的投食流程。用户通过微信给趣无尽微信公号发送投食指令，微信公众平台调用之前设定好的后台服务，将指令保存在控制服务器上。然后由树莓派去从控制服务器上取这个指令并执行。

这么设计主要是考虑到实际环境下的稳定性，当然最简单的方式是把树莓派直接暴露在外网，用户直接连上树莓派进行操作也完全可行。

树莓派拿到投食的指令之后，控制投食机完成投食。

没错，这个投食机怎么方便实现是小问题。我直接买了一个现成的投食机，Hack 一下开关部件，加一个继电器接入树莓派就搞定了。

Hack 投食机

Hack 前的投食机如图所示。

拆开后发现结构简单，测试了一下，最上面的开关位置短接即可启动投食机。

所以就把开关接出来，用继电器控制吧。用烙铁在旁边捅了个洞，以便把线引出来。

接好继电器。

整个树莓派控制设备如下。

投食机装到鱼缸上，大功告成。

至于直播，采用 motion、simple rtmp plublish 或 gstreamer 方案。几种方案近期会在树莓派实验室进行介绍。

其中最关键的非技术性因素是，你的 ISP 需要给你分配了公网 IP 地址，这样你才可以将树莓派的某个服务（比如视频采集）通过路由器的端口映射暴露在外网。

项目主页：http://make.quwj.com/project/4

项目补充说明：

1.视频实时采集自一台树莓派3B，由于树莓派性能、稳定性、家庭带宽等多重因素限制，在线人数较多时直播服务可能会出现卡顿或不可用。

2.请使用安装了 Flash 插件的浏览器打开，目前暂不支持 iPhone、iPad 浏览器观看，推荐使用 Chrome。

3.一般情况下，10~22点之外的时间段水族馆灭灯，这时基本上神马都看不到属于正常状况。

4.项目当前处于测试中，对性能优化尚在探索中，画质没有开到最佳。

5.项目随时会因设备维护而临时中断直播、关闭投食，属于正常状况。维护结束后会重新开放。

6.如发现水族馆存在异常状况，请联系作者处理，微信 spoony002。

7.作者组建了一个微信群，欢迎对热带鱼、草缸等有兴趣的朋友加入交流养鱼的经验和乐趣。添加作者微信号 spoony002 说明入群。

这是一篇学习笔记。用于快速理解，并在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并编辑

touch app.py nano 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，开启调试，然后执行。

pi@raspberrypi:~/dev/monitor $ python3 app.py * Running on http://0.0.0.0:5050/ * Restarting with reloader

此时访问 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

sudo apt-get install tmux

开启新对话时使用

tmux

即可

在新的会话中使用

sudo python app.py

后，终端即可直接关闭。返回会话可使用

tmux attach

直接返回

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/

来自 SPtuan 的投稿，感谢~ 原文：https://steinslab.xyz/archives/1275

编者按：树莓派实验室之前介绍过 Pi Dashboard 项目，源码中包含了网速监控的 PHP 实现，有兴趣的朋友可以了解。

来自 Archer 的投稿，感谢~

最近手贱，想剁手，于是就百无聊赖的上网买个了树莓派Zero和SPI接口enc28j60芯片的以太网卡，然后就开始了折腾。还好，树莓派接SPI网卡并不是没有先例，我找到了国外的教程，在这里就充当一下翻译。

首先，树莓派要设置打开SPI接口才可以接入SPI网卡的，这个简单。输入sudo raspi-config指令，在interfaces选项中，找到SPI选项，选择enable即可。然后关掉树莓派，开始接线。

接线如下图，不过这里不接3.3V及其附近的GND线，因为3.3V的的输电不足以让SPI网卡运作，应连接5V及其附近GND。

5V的针脚连接树莓派GPIO的2或者4号针脚，附近的GND应可以连接6或者9号针脚。这样就有足够的供电了。

最后一步是激活enc28j60网卡，在 /boot/config.txt中加入这句，放在最后面。

dtoverlay=enc28j60

重启之后，这SPI网卡就运作的了。

这网卡有一些有趣的特性，每次重启计算机，这网卡的IP地址和Mac都会改变，很难找到这玩意的准确位置，为了固定IP地址，我们可以在/etc/dhcpcd.conf后添加以下内容：

interface eth0 static ip_address=192.168.1.124/24 static routers=192.168.1.1 static domain_name_servers=202.102.152.3 114.114.114.114

保存后重启树莓派，之后树莓派的IP地址就永远是192.168.1.124了。

这样子就可以愉快的玩耍Pi Zero了。

参考资料：

http://www.jianshu.com/p/b0e6d066d6b6

Raspi.tv

近日微软Azure云计算平台上架了Raspberry Pi（树莓派）在线模拟器，开发者利用该模拟器构建不同的项目，而无需一个实体树莓派设备就可以进行调试等。

目前微软Azure上的树莓派模拟器还处于早期阶段，实际上现在的树莓派模拟器可视化界面还只是静态的图像，但你在模拟器上运行的代码仍然在一个虚拟的树莓派上执行。

微软也在计划扩展该模拟器的功能，微软Xin Shi表示该公司计划为模拟器增加更多的输入和输出相关传感器。因此，模拟器将包括一个拖放体验，用户通过添加不同的组件 (类似于插件)，可以扩展虚拟树莓派的功能。

如果你有兴趣，可以点此链接查看完整教程在Azure上设置虚拟树莓派。

目前用 Arduino、树莓派做小车、无人机、机器人的不少。趣无尽分享一款在由Roland Pelayo做的一个“六足行走机器人”。这个树莓派动力机器人能自主运行，自动避障，且也能实现手动模式由智能手机控制。 来具体看下过程。

“六足行走”Hexapod Walker概念

这个六足行走者(Hexapod Walker)将遵循大多数动物和昆虫使用的三脚架步态。三脚架步态如下图所示：

在六足行走者中有很多方法来使用这种步态。

平衡了价格和性能后，我选择构建一个三伺服电机版本。然后我添加了另一台伺服电机，用于安装机器人的“眼睛”。

机器人将有三个运动：前进，后退，右转，左转。

任何运动都会涉及机器人向右或向左倾斜，然后移动由倾斜抬起的腿部。

以下是运动的图表（腿上的灰色意味着机器人的重量在该腿上）。

右转运动基本和左转运动相反。

为了使三伺服电动机设计成为可能，在第三伺服电机倾斜步行者的同时，前后相应的后腿需要互连。

这种六足步行者可以在两种模式下操作：

在第一种模式（自主）中，步行者可以自由漫游。如果它检测到障碍物，它将向后退两步，然后向右转。

第二种模式将允许用户使用连接到与机器人相同网络的任何智能电话来控制六足步行者的移动。

根据我的设计要求，我需要一个控制器，能够做到

1）可以同时控制四个伺服器

2）从障碍物检测传感器读取输入

3）连接到一个网络进行无线控制。

创建Arduino 六足步行者是诱人的也更容易，但要增加的无线连接成本，所以我决定用树莓派。

这是我设计的框架：

所需材料

在决定要使用的控制器之后，需要选择其余的组件。

Tower Pro SG-5010伺服电机（用于腿部和倾斜）x3

Tower Pro SG-90微型伺服电机（头部）x1

Raspberry Pi 2 （带USB WiFi加密狗 ）或Raspberry Pi 3

HC-SR04超声波传感器 – 这是障碍物检测传感器。

亚克力板

1/2“x 1/8”铝棒

螺丝和螺母

电池。伺服应该有和树莓派有不同的电源，我的树莓派用了个小充电宝。

开始我们的教程

六足机器人主要由三个部分构成：主体（平台），行走足以及头部。

搭建平台

H这是一个可用于构建步行者身体的示例布局。我用亚克力板作为我的平台。腿的细节如下。

接腿

这是一个腿的布局。我使用了1/2″ x 1/8 ″的铝条。

腿应该足够坚硬，以支撑六足步行者的重量。请不要塑料！

这是倾斜的腿：

安装树莓派和头部

我在亚克力板上打了孔，然后用螺丝和螺母连接树莓派。

头部由超声波传感器和连接到电路板的微型伺服电机组成。我用热胶将微型伺服与传感器连接起来：

看下腿部运动细节：

连线

以下是我连接对应表：

tilt servo – > GPIO4 right leg -> GPIO21 left leg -> GPIO6 head -> GPIO26 HC-SR04 trigger – > GPIO23 HC-SR04 echo – > GPIO24

因为树莓派的GPIO不能接受大于3.3V的电压，所以需要为树莓派的回波连接添加一个分压器。

我还添加了一个带有公头和母头的电路板，使接线更清洁。

这是全组合六足步行者：

软件

Pigpio 用于伺服控制

Pigpio 是一个用于控制伺服电机的 Python 库，用 SSH 连接到树莓派安装它。

wget http://abyz.co.uk/rpi/pigpio/pigpio.zip unzip pigpio.zip cd PIGPIO make sudo make install

Pigpio 运行于后台，在使用 Pigpio 前，你需要先运行。

pigpiod

设置 contrab:

sudo crontab -e

在末尾添加

@reboot /usr/local/bin/pigpiod

Apache 用于服务端

安装 apache for the Raspberry Pi 用于 WiFi 控制:

sudo apt-get install apache2 -y

会创建一个目录 /var/www/html/，包含了控制页面。你可以用浏览器连接到树莓派了。RPi rover robot 可以让你在手机上控制树莓派。

Python 程序

以下是机器人控制程序。

#!/usr/bin/python import RPi.GPIO as GPIO import pigpio import time import sys import os import signal GPIO.setmode(GPIO.BCM) GPIO.setwarnings(False) tilt = 4 br = 21 bl = 6 trig = 23 echo = 24 head = 26 GPIO.setup(trig, GPIO.OUT) GPIO.setup(echo, GPIO.IN) pi = pigpio.pi() def backward(): pi.set_servo_pulsewidth(tilt, 800) time.sleep(0.15) pi.set_servo_pulsewidth(bl, 800) time.sleep(0.15) pi.set_servo_pulsewidth(tilt, 2000) time.sleep(0.15) pi.set_servo_pulsewidth(br, 1800) time.sleep(0.15) pi.set_servo_pulsewidth(tilt, 1500) time.sleep(0.15) pi.set_servo_pulsewidth(bl, 1500) time.sleep(0.15) pi.set_servo_pulsewidth(br, 1500) time.sleep(0.15) return; def forward(): pi.set_servo_pulsewidth(tilt, 800) time.sleep(0.15) pi.set_servo_pulsewidth(bl, 1800) time.sleep(0.15) pi.set_servo_pulsewidth(tilt, 2000) time.sleep(0.15) pi.set_servo_pulsewidth(br, 800) time.sleep(0.15) pi.set_servo_pulsewidth(tilt, 1500) time.sleep(0.15) pi.set_servo_pulsewidth(bl, 1500) time.sleep(0.15) pi.set_servo_pulsewidth(br, 1500) time.sleep(0.15) return; def left(): pi.set_servo_pulsewidth(tilt, 800) time.sleep(0.15) pi.set_servo_pulsewidth(bl, 1800) time.sleep(0.15) pi.set_servo_pulsewidth(tilt, 2000) time.sleep(0.15) pi.set_servo_pulsewidth(br, 1800) time.sleep(0.15) pi.set_servo_pulsewidth(tilt, 1500) time.sleep(0.15) pi.set_servo_pulsewidth(bl, 1500) time.sleep(0.15) pi.set_servo_pulsewidth(br, 1500) time.sleep(0.15) return; def right(): pi.set_servo_pulsewidth(tilt, 800) time.sleep(0.15) pi.set_servo_pulsewidth(bl, 800) time.sleep(0.15) pi.set_servo_pulsewidth(tilt, 2000) time.sleep(0.15) pi.set_servo_pulsewidth(br, 800) time.sleep(0.15) pi.set_servo_pulsewidth(tilt, 1500) time.sleep(0.15) pi.set_servo_pulsewidth(bl, 1500) time.sleep(0.15) pi.set_servo_pulsewidth(br, 1500) time.sleep(0.15) return; def stop(): pi.set_servo_pulsewidth(tilt, 0) time.sleep(0.15) pi.set_servo_pulsewidth(bl, 0) time.sleep(0.15) pi.set_servo_pulsewidth(br, 0) time.sleep(0.15) return def obstacleDetected(): backward() backward() backward() backward() backward() right() right() right() return def turnHead(): pi.set_servo_pulsewidth(head, 700) time.sleep(0.5) pi.set_servo_pulsewidth(head, 2100) time.sleep(0.5) pi.set_servo_pulsewidth(head, 1500) time.sleep(0.5) return def autoMode(): print (“Running in auto mode!”) turnHead() time.sleep(0.5) GPIO.output(trig, 0) time.sleep(0.5) GPIO.output(trig,1) time.sleep(0.00001) GPIO.output(trig,0) while GPIO.input(echo) == 0: pulse_start = time.time() while GPIO.input(echo) == 1: pulse_end = time.time() pulse_duration = pulse_end – pulse_start distance = pulse_duration * 17150 distance = round(distance, 2) if distance > 1 and distance < 35: obstacleDetected() else: forward() forward() forward() pi.set_servo_pulsewidth(head, 2100) time.sleep(0.5) return def manualMode(): move = str(sys.argv[2]) if move == "F" or move == "f": print("Moving forward!") forward() elif move == "B" or move == "b": print("Moving backward!") backward() elif move == "L" or move == "l": print("Moving left!") left() elif move == "R" or move == "r": print("Moving right!") right() else: print("Invalid argument!") return def main(): opt = str(sys.argv[1]) if opt == "A" or opt == "a": autoMode() elif opt == "M" or opt == "m": manualMode() return while True: main() GPIO.cleanup() pi.stop() 你可以通过终端指令测试机器人的控制，例如让它向前行走可以用 python hexapod.py m f 当然正式使用是需要用手机控制的，在 Apache 上部署我写好了程序吧，访问我的 Github 获取。以下是WebUI的截图： 如何操作 找到树莓派的IP地址。 用手机浏览器访问这个IP，例如192.168.1.90/hexapod。 使用WebUI操控机器人 Enjoy！ via

Arduino具有丰富的外部接口，与树莓派的IO口最大的不同在于Arduino具有模拟输入接口，可以测量IO口上的模拟值。Arduino与Raspberry通过串口（Serial）通信的方案一般有两种，一是通过树莓派GPIO串口通信，第二种是通过USB串口通信。

显然，Arduino与Raspberry通过USB串口不仅稳定，而且不用连接复杂的线缆，本篇文章介绍树莓派如何通过USB串口读取arduino获得传感器的数值。

在Arduino上连接DHT11传感器，用来获取当前的温度、湿度值，并通过串口发送出来。

一、Arduino准备

本项目所需的.zip库文件点此下载：dht11

#include dht11 DHT; #define DHT11_PIN 4 void setup(){ Serial.begin(9600); Serial.println(“DHT TEST PROGRAM “); Serial.print(“LIBRARY VERSION: “); Serial.println(DHT11LIB_VERSION); Serial.println(); Serial.println(“Type,\tstatus,\tHumidity (%),\tTemperature (C)”); } void loop(){ int chk; Serial.print(“DHT11, \t”); chk = DHT.read(DHT11_PIN); // READ DATA switch (chk){ case DHTLIB_OK: Serial.print(“OK,\t”); break; case DHTLIB_ERROR_CHECKSUM: Serial.print(“Checksum error,\t”); break; case DHTLIB_ERROR_TIMEOUT: Serial.print(“Time out error,\t”); break; default: Serial.print(“Unknown error,\t”); break; } // DISPLAT DATA Serial.print(DHT.humidity,1); Serial.print(“,\t”); Serial.println(DHT.temperature,1); delay(1000); }

将程序编译下载到Arduino中，此时可以从Arduino串口获取传感器测量到的数据。

二、树莓派安装串口调试程序

minicom是linux平台串口调试工具，相当于windows上的串口调试助手，可以用它来读取Arduino通过USB串口发送的传感器数值。

一）minicom安装

sudo apt-get install minicom

二）minicom启动

minicom -b 9600 -D /dev/ttyACM0

-b代表波特率，-D代表端口，/dev/ttyACM0 表示打开与Arduino相连的端口。

三、连接树莓派与Arduino

将Arduino通过USB线缆连接到树莓派上，这时就可以在树莓派的终端看到通过串口获得的Arduino数据，数据为所测量到的温度和湿度值。

转载自科技爱好者博客

本文链接地址: 树莓派与arduino串口通信实践 (http://blog.lxx1.com/2622)

相比 MySQL 而言，SQLite 更为轻便、易于维护和部署。本文使用Python向SQLite数据库中插入树莓派温度数据，SQLite数据库中包含一张只包含三个字段的记录表——参数名称，时间和温度值。本文重点解释Python操作SQlite的具体方法，由于网上资料众多，重复部分不再复述只做到具体情况具体分析。

相关博文：SQLite操作简述

1 创建数据库和空表

【create-table-only.sql】

PRAGMA foreign_keys=OFF; BEGIN TRANSACTION; CREATE TABLE temps( name DEFAULT ‘RPi.CPU’, tdatetime DATETIME DEFAULT (datetime(‘now’, ‘localtime’)), temperature NUMERIC NOT NULL ); COMMIT;

【简要说明】

【1】数据库包含三个字段，其中两个字段有默认值。

【2】温度值不能为空。

【3】DEFAULT与NOT NULL约束配合，简化插入操作。

【create-table-only.sh】

#!/bin/sh DBNAME=”cpu.db” rm -f $DBNAME echo 开始插入数据 sqlite3 $DBNAME < create-table-only.sql echo 插入完成 【简要说明】 【1】chmod a+x create-table-only.sh增加可执行权限 【2】运行之后在同目录下创建名为cpu.db的数据库 2 Python插入操作 新建一个名为db-insert-temp.py的文件，具体内容如下 #!/usr/bin/env python # -*- coding: utf-8 -*- import time import sqlite3 def get_cpu_temp(): # 打开文件 file = open("/sys/class/thermal/thermal_zone0/temp") # 读取结果，并转换为浮点数 temp = float(file.read()) / 1000 # 关闭文件 file.close() return temp def insert_cpu_temp(temp): # 连接数据库 conn=sqlite3.connect('cpu.db') curs=conn.cursor() # 插入数据库 strtemp = "%.1f" %(temp); curs.execute("INSERT INTO temps(temperature) VALUES((?))", (strtemp,)) conn.commit() # 关闭数据库 conn.close() def main(): while True: temp = get_cpu_temp() insert_cpu_temp(temp) time.sleep(5*60) if __name__ == '__main__': main() 【简单说明】 【1】conn=sqlite3.connect(‘cpu.db’) 连接数据库。 【2】curs=conn.cursor() 获得游标。游标可理解为文件操作句柄，有了它就可以摆弄”cpu.db”了。 【3】重点注意curs.execute(“INSERT INTO temps(temperature) VALUES((?))”, (strtemp,)) 【3.1】利用name和tdatetime的默认约束，此处仅插入温度值 【3.2】execute函数中必须使用占位符(?)，不能使用字符串格式化方法。如果还有两个占位符，建议写成这样VALUES((?),(?)) 【3.3】参数化查询时 (strtemp,)为Python元组数据类型，如果只有一个元素时逗号不可省略。如果含有两个参数，建议写成这样(paraA,paraB) 【4】勿忘提交操作conn.commit() 【5】勿忘关闭操作conn.close() 【查询插入结果】 可在控制台中输入 sqlite3 cpu-temp “SELECT * FROM temps;”，返回结果如下。 RPi.CPU|2014-08-03 10:40:40|48.7 RPi.CPU|2014-08-03 10:41:41|48.7 RPi.CPU|2014-08-03 10:42:41|49.2 RPi.CPU|2014-08-03 10:43:41|48.7 RPi.CPU|2014-08-03 10:44:41|48.7 RPi.CPU|2014-08-03 10:45:41|49.2 3 开机后台运行 【启动脚本】——auto-start.sh 在该目录下再新建一个auto-start.sh脚本，具体内容如下 #!/bin/bash cd /home/pi/python-works/cpu-temp python db-insert-temp.py & 【简单说明】 【1】python db-insert-temp.py & 后台运行db-insert-temp.py 【2】勿忘修改执行权限，chmod a+x auto-start.sh 【修改启动项】——/etc/rc.local 在最后一行exit 0之前增加 # 树莓派温度保存到数据库中 /home/pi/python-works/cpu-temp/auto-start.sh start 【重新启动树莓派】 sudo reboot 重启之后再次查看表中内容，将会发现记录一条一条增加。 4 总结 【1】python SQLite参数化操作时必须使用占位符? 【2】参数为Python元组类型，需要注意元素个数为1的情况。 【3】插入操作成功，结合Flask尝试查询操作。 5 参考资料 【1】SQLite 教程 | w3cschool菜鸟教程 【2】Python SQLite3帮助文档 原文：blog.csdn.net/xukai871105

2020.3.21 更新：树莓派安装 Nginx + PHP7.3 + Pi Dashboard

2018.4.25 更新：树莓派安装 Nginx + PHP7.0 + Pi Dashboard

Pi Dashboard (Pi 仪表盘) 是树莓派实验室发布的一款开源的 IoT 设备监控工具，目前主要针对树莓派平台，也尽可能兼容其他类树莓派硬件产品。你只需要在树莓派上安装好 PHP 服务器环境，即可方便的部署一个 Pi 仪表盘，通过炫酷的 WebUI 来监控树莓派的状态！

目前已加入的监测项目有：

CPU 基本信息、状态和使用率等实时数据

内存、缓存、SWAP分区使用的实时数据

SD卡（磁盘）的占用情况

实时负载数据

实施进程数据

网络接口的实时数据

树莓派IP、运行时间、操作系统、HOST 等基础信息

项目主页：http://make.quwj.com/project/10

GitHub地址：https://github.com/nxez/pi-dashboard

视频预览

安装方法

安装共2步，首先安装 Nginx（或 Apache）和 PHP。然后在 Nginx 目录通过 SFTP 或 GitHub 部署好本项目的程序。

1.安装 Nginx 和 PHP

在 Pi 的终端运行以下命令。

sudo apt-get update sudo apt-get install nginx php5-fpm php5-cli php5-curl php5-gd php5-mcrypt php5-cgi sudo service nginx start sudo service php5-fpm restart

如果安装成功，可通过 http://树莓派IP 访问到 Nginx 的默认页。Nginx 的根目录在 /var/www/html 。

进行以下操作来让 Nginx 能处理 PHP。

sudo nano /etc/nginx/sites-available/default

将其中的如下内容

location / { # First attempt to serve request as file, then # as directory, then fall back to displaying a 404. try_files $uri $uri/ =404; }

替换为

location / { index index.html index.htm index.php default.html default.htm default.php; } location ~ .*\.php(\/.*)*$ { #fastcgi_split_path_info ^(.+\.php)(/.+)$; fastcgi_pass unix:/var/run/php5-fpm.sock; fastcgi_index index.php; include fastcgi_params; set $real_script_name $fastcgi_script_name; if ($fastcgi_script_name ~ “(.+?\.php)(/.*)”) { set $real_script_name $1; set $path_info $2; } fastcgi_param SCRIPT_FILENAME $document_root$real_script_name; fastcgi_param SCRIPT_NAME $real_script_name; fastcgi_param PATH_INFO $path_info; }

Ctrl + O 保存再 Ctrl + X 退出。

sudo service nginx restart

最后重启 Nginx 即可，以上步骤在树莓派 Zero + Linux version 4.9.41+ 系统版本上测试通过。

对在树莓派上部署 LNMP 有兴趣可以参考实验室更详细的介绍《树莓派搭建LNMP环境》。

2.部署 Pi Dashboard

这里介绍两种方法将 Pi Dashboard 部署在 Nginx 上。

2.1. SFTP 上传

在 GitHub 下载本项目源码。通过 FileZilla 等 FTP 软件将解压出来的目录上传到树莓派的 /var/www/html 目录下。

那么可以通过 http://树莓派IP/pi-dashboard 访问部署好了的 Pi Dashboard。

如果页面无法显示，可以尝试在树莓派终端给源码添加运行权限，例如你上传之后的路径是 /var/www/html/pi-dashboard ，则运行。

cd /var/www/html sudo chown -R www-data pi-dashboard

2.2. GitHub 部署

如果你了解过 GitHub 的基本操作，通过 GitHub 来下载本项目到 Pi 上会相当方便。

cd /var/www/html sudo git clone https://github.com/nxez/pi-dashboard.git

即可通过 http://树莓派IP/pi-dashboard 访问部署好了的 Pi Dashboard。

同样如果页面无法显示，可以尝试在树莓派终端给源码添加运行权限，例如你上传之后的路径是 /var/www/html/pi-dashboard ，则运行。

cd /var/www/html sudo chown -R www-data pi-dashboard

以上步骤在树莓派 Zero + Linux version 4.9.41+ 系统版本上测试通过。

常见问题

Q：Pi Dashboard 的 WebUI 支持在哪些终端上查看？

A：任何带有浏览器的终端都可以查看，无论是在内网还是外网的电脑、Pad或是智能手机上。Pi Dashboard 对不同的设备做了响应式布局，能很好兼容手机浏览。

Q：我没法通过外网IP访问到怎么办？

A：国内很多地区的ISP都不提供独立的外网IP了，可以通过花生壳等工具实现外网访问。对于已有外网独立IP的用户，可以尝试把 Nginx 服务端口从 80 改成其他端口号，再在 IP 地址后添加端口号访问。这是因为国内ISP普遍禁用了80端口。

Q：我有一个域名，如何将域名绑定到树莓派上？

A：可以参考DNSPod动态IP解析更新程序和树莓派搭建LNMP环境。将域名指向树莓派IP后需要修改 Nginx 网站配置的 servername 这项为你的域名即可。

Q：使用遇到问题可以提供技术支持吗？

A：可以加树莓派实验室Q群 549418432 和其他用户交流获得协助。

使用条款

本项目是开源项目，NXEZ.com 保留作为发起者的权利。

允许在 GPL v3.0 协议下对项目进行使用。请务必在保证项目的出处、声明、超链接等内容完整。

完善计划

欢迎有兴趣的朋友通过 GitHub 参与到本项目的完善。下面是项目后续完善的几个方向。