Author: 互联网

MCC 172是一个两通道DAQ HAT，用于通过IEPE传感器（如加速度计和麦克风）进行声音和振动测量。它的每个通道具有24位A/D，最大采样率为51.2 kS/s/Ch。

无意间在慕课看到的一篇教程，跟着研究了下。教程使用的是PHP的 HTTP_POS 组件实现上传功能。

PS.本人是代码小白…出错的地方可能挺多…各位大大不要见怪….

说一下可能会出现的问题：

1、乱码，解决方法 请检查浏览器是否为UTF-8

2、文件上传失败，文件超过服务器设定大小！解决方法:更改PHP.ini设置中的dpload_max_filesize

3、文件上传失败，文件超过服务器表设定！解决方法：更改PHP.ini设置中的MAX_FILE_SIZE

更多问题可以参考压缩包里的 Readme.txt

正题：

首先当然得安装PHP等相关服务，参考：在树莓派上搭建LAMP服务

LAMP的含义是：

Linux － 操作系统

Apache － 网络服务器（HTTP）软件

Mysql － 数据库服务

PHP or Perl － 编程语言

安装完PHP后就可以直接把我的包（解压后）通过SFTP上传到www目录下即可（百度网盘）

Pi端解压后应该是这样的

我们尝试上传一个文件（允许的文件列表在put.php中，默认设定只能上传图片否则报错）

电脑端访问Pi的IP弹出我们的上传页面

此时Pi端的文件夹是空的

我们在电脑端选择文件并点击上传

页面提示上传成功后，Pi端的文件夹便多出了一个文件。

附上各平台的测试(ios,安卓,windows)

ios

安卓

windows

上传成功enjoy!

最后：

程序下载地址：百度网盘

via Chris

本文所介绍的内容基于树莓派瑞士军刀扩展板（SAKS），由于 SAKS 基于树莓派通用的 GPIO 设计，文中的原理和代码也适用于其他情况。

本文由树莓派实验室创作，遵循CC协议（署名-非商业性使用-禁止演绎-相同方式共享），欢迎树莓派爱好者们遵循协议内容转载传播。谢绝不遵守协议的转载和抄袭。

本节非常简单，因为搞定树莓派的 GPIO 开发环境只需要几行指令。

目前在树莓派上流行的 GPIO 开发环境主要有两种，Python GPIO 和基于 C 语言的 wiringPi。我们推荐没有 C 语言基础的朋友直接选择 Python GPIO，因为 Python 不仅上手简单，而且其解释语言的特性使得程序不用编译，对代码做了任何修改之后就能直接运行，极大方便了调试。下面我们将分别对这两种开发环境的安装进行介绍。

Python GPIO 的安装

sudo apt-get install python-dev sudo apt-get install python-rpi.gpio

安装完成之后，试着写一段简单的程序来验证下。就以点亮 SAKS 上红色的 LED 为例吧。

# -*- coding: utf-8 -*- import RPi.GPIO as GPIO import time # BOARD编号方式，基于插座引脚编号 GPIO.setmode(GPIO.BOARD) # 输出模式 GPIO.setup(24, GPIO.OUT) while True: GPIO.output(24, GPIO.HIGH) time.sleep(1) GPIO.output(24, GPIO.LOW) time.sleep(1)

保存为 led.py，接着运行这个 Python 程序。

sudo python led.py

红色 LED 亮起，说明马上可以开始尽情开发了！

wiringPi 的安装

#如果之前没有安装过 git，执行下面的命令安装一下 sudo apt-get install git-core sudo apt-get update #下载 wiringPi git clone git://git.drogon.net/wiringPi #编译 wiringPi cd wiringPi ./build

编译完成后，使用如下命令可以验证是否安装成功。

#显示版本信息 gpio -v #显示GPIO信息 gpio readall

同样编写点亮红色 LED 的程序。

#include int main(void) { wiringPiSetup(); pinMode (10, OUTPUT); for(;;) { digitalWrite(10, HIGH); delay (500); digitalWrite(10, LOW); delay (500); } }

保存为 led.c，然后编译、运行。

gcc -Wall -o led led.c -lwiringPi sudo ./led

注意：以上IO的编号方式略有不同，采用wiring编码方式。 -lwiringPi 表示动态加载 wiringPi 共享库。

好了，环境我们已经准备好了，后面我们后面将开始介绍如何基于 SAKS 扩展板 DIY 各种有趣、实用的东西，欢迎持续关注！

本文属于《树莓派瑞士军刀扩展板（SAKS）DIY 教程》系列文章，查看系列文章目录，请访问：https://shumeipai.nxez.com/swiss-army-knife-shield-for-raspberry-pi-diy-tutorials

本文所介绍的内容基于树莓派瑞士军刀扩展板（SAKS），由于 SAKS 基于树莓派通用的 GPIO 设计，文中的原理和代码也适用于其他情况。

本文由树莓派实验室创作，遵循CC协议（署名-非商业性使用-禁止演绎-相同方式共享），欢迎树莓派爱好者们遵循协议内容转载传播。谢绝不遵守协议的转载和抄袭。

本节将以绚丽、有趣的流水灯功能为基础，来说明如何通过 GPIO 来玩转 SAKS 扩展板。

SAKS 扩展板配备了8个 LED，这8个 LED 实际上被精心设计为两组，每组4个，一组是与数码管共享GPIO 引脚的透明蓝光 LED。要启用这一组 LED，请先确保 LED 的跳线被置为“ON”。另一组是独享GPIO 引脚的绿、黄、红色 LED。

功能 注释 BOARD

编码 BCM

编码 wiringPi

编码 LED排灯 LED-D2 第1个LED（蓝） 29 5 21 LED-D5 第2个LED（蓝） 31 6 22 LED-D3 第3个LED（蓝） 33 13 23 LED-D4 第4个LED（蓝） 35 19 24 LED-D6 第5个LED（绿） 27 0 30 LED-D7 第6个LED（绿） 28 1 31 LED-D8 第7个LED（黄） 26 7 11 LED-D9 第8个LED（红） 24 8 10

先试着点亮所有的 LED。要注意，给 SAKS 扩展板上 LED 低电平才能点亮它们，而高电平将会关闭它们。

#!/usr/bin/env python # -*- coding: utf-8 -*- import RPi.GPIO as GPIO import time #引脚采用BCM编码 GPIO.setmode(GPIO.BCM) #配置一个数组，依次对应8个灯的引脚BCM编码 pins = [5, 6, 13, 19, 0, 1, 7, 8] #GPIO ports #定义一个便捷地设置引脚的方法 def setp(n, status=’off’): if status == ‘on’: GPIO.output(n, GPIO.LOW) else: GPIO.output(n, GPIO.HIGH) #遍历数组，将数组中8个LED引脚初始化 for i in pins: GPIO.setup(i, GPIO.OUT) setp(i, ‘off’) try: #遍历数组，将数组中8个LED引脚置为ON同时点亮LED for i in pins: setp(i, ‘on’) except: print “except” GPIO.cleanup()

是不是发现 LED 是被点亮了，本无需点亮的数码管也有一部分被点亮了？这是因为蓝色 LED 和数码管共用了 GPIO 引脚的关系（因为我们在设计 SAKS 时希望尽可能对 GPIO 实现高利用率）。要关掉数码管，只需要将数码管的位选关掉。至于为什么关掉位选就可以，这是数码管的特性。在后面的例程中，我们介绍到数码管时会详细介绍。

加入关掉数码管位选的逻辑之后，程序代码如下：

#!/usr/bin/env python # -*- coding: utf-8 -*- import RPi.GPIO as GPIO import time #引脚采用BCM编码 GPIO.setmode(GPIO.BCM) #配置一个数组，依次对应8个灯的引脚BCM编码 pins = [5, 6, 13, 19, 0, 1, 7, 8] #GPIO ports #由于SAKS的蓝色LED和数码管共享引脚，此处将数码管位选关闭，只让信号作用于LED GPIO.setup(17, GPIO.OUT, initial=GPIO.HIGH) GPIO.setup(27, GPIO.OUT, initial=GPIO.HIGH) GPIO.setup(22, GPIO.OUT, initial=GPIO.HIGH) GPIO.setup(10, GPIO.OUT, initial=GPIO.HIGH) #定义一个便捷地设置引脚的方法 def setp(n, status=’off’): if status == ‘on’: GPIO.output(n, GPIO.LOW) else: GPIO.output(n, GPIO.HIGH) #遍历数组，将数组中8个LED引脚初始化 for i in pins: GPIO.setup(i, GPIO.OUT) setp(i, ‘off’) try: #遍历数组，将数组中8个LED引脚置为ON同时点亮LED for i in pins: setp(i, ‘on’) except: print “except” GPIO.cleanup()

那么如何让 LED 轮流点亮呢？只需要按照 SAKS 扩展板上 LED 的顺序，依次控制每个 LED 点亮并且同时关闭其它 LED。并通过加入循环，让流水灯周而复始流转。有了上面的基础，稍加思考后开始改进程序代码。

#!/usr/bin/env python # -*- coding: utf-8 -*- import RPi.GPIO as GPIO import time #引脚采用BCM编码 GPIO.setmode(GPIO.BCM) #配置一个数组，依次对应8个灯的引脚BCM编码 pins = [5, 6, 13, 19, 0, 1, 7, 8] #GPIO ports #由于SAKS的蓝色LED和数码管共享引脚，此处将数码管位选关闭，只让信号作用于LED GPIO.setup(17, GPIO.OUT, initial=GPIO.HIGH) GPIO.setup(27, GPIO.OUT, initial=GPIO.HIGH) GPIO.setup(22, GPIO.OUT, initial=GPIO.HIGH) GPIO.setup(10, GPIO.OUT, initial=GPIO.HIGH) #定义一个便捷地设置引脚的方法 def setp(n, status=’off’): if status == ‘on’: GPIO.output(n, GPIO.LOW) else: GPIO.output(n, GPIO.HIGH) #遍历数组，将数组中8个LED引脚初始化 for i in pins: GPIO.setup(i, GPIO.OUT) setp(i, ‘off’) try: #当前即将点亮的LED在数组中的位置 i = 0 while True: #点亮数组中第i个LED setp(pins[i], ‘on’) #延时0.1秒 time.sleep(0.1) #熄灭数组中第i个LED setp(pins[i], ‘off’) #改变i，使之对应到下一个LED，如果已经是最后一个LED，则对应到第1个LED i += 1 if i == len(pins): i = 0 except: print “except” GPIO.cleanup()

到这里，你已经发现只需要简单的几行代码，就能玩转 SAKS 的 LED 了！在黑夜里，流水灯效果是不是很赞？！

我们后面将介绍更多基于 SAKS 扩展板的有趣的内容，欢迎持续关注！

本文属于《树莓派瑞士军刀扩展板（SAKS）DIY 教程》系列文章，查看系列文章目录，请访问：https://shumeipai.nxez.com/swiss-army-knife-shield-for-raspberry-pi-diy-tutorials

本项目说明了如何从树莓派发送推送通知给iOS和Android设备，只需要用到一个免费的推送app即可。这里的主要思想就是利用一个电磁感应门来触发推送信息的事件。当电磁门打开时，树莓派就发送消息。在这个项目中，电磁感应门可以很容易替换成其他类型的告警设备，比如PIR运动传感器，红外引信等。

作者声明：我不是个Python专家，也不是树莓派的专家。虽然我有过很多软件开发的经验，而且也曾是个全职的开发者，但这是我的第一个树莓派项目和Python应用。因此，我写的Python代码很可能不是最简洁的，而且也可能会有其他更好的方式来配置树莓派。我个人很乐意接受建设性的批评和建议。如果有任何改进的建议，请在评论栏中告诉我。

配置树莓派发送推送消息

下面各项就是我们需要完成的：

在Instapush上建立推送服务，并安装移动app 将电磁感应门连接到树莓派上 安装pycurl库 加载python代码 运行python应用 测试，获取推送通知

在Instapush上建立推送服务，并安装移动app

要处理推送通知，我使用了一个名为Instapush的免费推送服务。Instapush在iOS和Android上有免费的app，而且这个平台上也有一个易于使用的REST API供软件开发者使用。

首先，在https://instapush.im/注册并登陆。 下载移动app（iOS版，Android版） 登陆到app上，使用你在网站上注册的账户即可 在app上登陆后，你会发现控制面板中已经显示你的设备已连接到Instapush的账户上了。去这里查看https://instapush.im/dashboard. 然后点击设备标签。我有两台设备都连接到了Instapush的账户上，见下图。

接下来，点击app标签。然后选择添加应用。 为你的应用选择一个名称，然后点击Add。我把应用命名为“Door Push” 添加了你的应用之后，你会进入事件界面。点击添加事件 为你的时间选择一个标题。我建议在事件名中不要加入任何空格。我用的是“DoorAlert” 你需要添加至少一个tracker。这基本上就是一个用在推送通知中的变量。我给它命名为“message” 最后，输入你想要推送的消息内容。我的Python代码将变量{message}传给Instapush服务，因此我建议你只把{message}添加到Message字段即可。

点击添加事件 点击Basic Info标签，记下Application ID和Application Secret fields这两个字段的内容。在编写Python代码时需要用到这些。可以参考下图中的示例。当然，我把我的ID做了些处理。

将电磁感应门连接到树莓派上

我使用了一个面包板套件来让这个过程变得简单些。我使用GPIO的第23号管脚以及接地管脚来连接电磁感应门。哪条线接GPIO，哪条线接地无关紧要。下面是示意图：

安装pycurl库

我们的Python程序需要使用一个称为pycurl的库来发送API请求给InstaPush服务。在树莓派上运行下面的命令来安装这个Python库。

sudo apt-get install python-pycurl

Python代码

下面就是我编写的Python代码了。代码中的注释应该能很好的解释我在做什么。将程序命名为doorSensor.py。你可以在这里下载源代码。

# ————- Begin doorSensor.py —————— # import pycurl, json from StringIO import StringIO import RPi.GPIO as GPIO #setup GPIO using Broadcom SOC channel numbering GPIO.setmode(GPIO.BCM) # set to pull-up (normally closed position) GPIO.setup(23, GPIO.IN, pull_up_down=GPIO.PUD_UP) #setup InstaPush variables # set this to Application ID from Instapush appID = “” # set this to the Application Secret from Instapush appSecret = “” # leave this set to DoorAlert unless you named your event something different in Instapush pushEvent = “DoorAlert” # set this to what you want the push message to say pushMessage = “Door Opened!” # use StringIO to capture the response from our push API call buffer = StringIO() # use Curl to post to the Instapush API c = pycurl.Curl() # set Instapush API URL c.setopt(c.URL, ‘https://api.instapush.im/v1/post’) # setup custom headers for authentication variables and content type c.setopt(c.HTTPHEADER, [‘x-instapush-appid: ‘ + appID, ‘x-instapush-appsecret: ‘ + appSecret, ‘Content-Type: application/json’]) # create a dictionary structure for the JSON data to post to Instapush json_fields = {} # setup JSON values json_fields[‘event’]=pushEvent json_fields[‘trackers’] = {} json_fields[‘trackers’][‘message’]=pushMessage postfields = json.dumps(json_fields) # make sure to send the JSON with post c.setopt(c.POSTFIELDS, postfields) # set this so we can capture the resposne in our buffer c.setopt(c.WRITEFUNCTION, buffer.write) # uncomment to see the post that is sent #c.setopt(c.VERBOSE, True) # setup an indefinite loop that looks for the door to be opened / closed while True: # door open detected GPIO.wait_for_edge(23, GPIO.RISING) print(“Door Opened!

“) # in the door is opened, send the push request c.perform() # capture the response from the server body= buffer.getvalue() # print the response print(body) # reset the buffer buffer.truncate(0) buffer.seek(0) # door closed detected GPIO.wait_for_edge(23, GPIO.FALLING) print(“Door Closed!

“) # cleanup c.close() GPIO.cleanup() # ——————– End doorSensor.py ——————– # Save the Python script on your Raspberry Pi.

将Python脚本保存到你的树莓派上。

运行Python应用

要测试是否能从树莓派上发送推送通知，先运行doorSensor.py应用。程序跑起来之后，将电磁感应门的传感器分开。你会看到树莓派的屏幕上会打印出一些内容。第一行就是运行程序的命令，而第二行就是当我们打开门的时候所打印的。紧跟着会打印出从InstaPush的API服务接收到的响应。

pi@raspberrypi ~ $ sudo python doorSensor.py Door Opened! {“msg”:”Notification Sent Successfully”,”error”:false,”status”:200} Door Closed!

获取推送通知

在你打开电磁门的1到2秒后，你应该在iOS或者Android设备上接收到推送通知。下图就是在我的三星Galaxy上所接收到的推送消息。iPhone上也工作的一样好。

使用虚拟机模拟树莓派，可以用来演练学习树莓派系统，也可以用来DIY自己的树莓派系统IMG文件以便刷入SD卡给树莓派使用。

很多linux学习者都是从虚拟机入门的。下面主要讲述与虚拟机有关的内容：

1.下载地址

根据自己的系统选择不同的虚拟机，我是用Qemu虚拟机，其它的是否也可以我不清楚，以前玩过一段时间的ubuntu和红帽，那个虚拟机是用Vware，虚拟机就是虚拟的计算机，然后在上面跑一个linux系统就可以了。

Qemu虚拟机下载地址：http://sourceforge.net/projects/rpiqemuwindows/files/ [百度网盘]

直接点击就可以下载，so easy！！

2.安装Qemu虚拟机虚拟机

下载好Qemu虚拟机之后，点击解压qemu.zip，运行run.bat批处理文件。先看1说明文档，然后直接运行run.bat。

3.激动人心的时刻

看到最后的一个界面，就找到了以前linux的感觉了。

4.正式看见大树莓

在命令行输入 startx，即可进入界面。好大一颗树莓啊。哈哈，我喜欢！！

好了，树莓派的虚拟机体验，到此结束。

本文转载自 Dreamcolor Said。

RPIO.py 相对于 RPi.GPIO 在各个方面都有所扩展，并且默认使用 BCM GPIO 编号方式。

GPIO 和 TCP 中断

RPIO 可以对两种中断进行监听：GPIO 和 TCP。某特定 GPIO 的输入状态改变时将产生 GPIO 中断。某 TCP socket 客户端发送信息时将产生 TCP 中断。

RPIO.wait_for_interrupts(threaded=False, epoll_timeout=1)

这是阻隔功能的主循环，当启用后，将会对中断进行监听，并且启用您自定义的回调操作。在您脚本的某个地方，您需要使用它来接收中断回调。这种阻隔方式非常适合于“让您的脚本一直循环运行”。

使用 threaded=True 参数，使它在您的脚本运行于主线程时，使其在后台操作（RPIO 在您的脚本退出时，会自动关闭该线程）： RPIO.wait_for_interrupts(threaded=True)

GPIO 中断

中断被用于接收当 GPIO 状态发生改变时来自于内核的通知。其优点是消耗 CPU 资源非常少，通知时间非常短，并且可在特定临界值转换（rising、falling、both）时被触发的能力。您还可以设置软件上拉或下拉电阻。

RPIO.add_interrupt_callback(gpio_id, callback, edge=’both’, pull_up_down=RPIO.PUD_OFF, threaded_callback=False, debounce_timeout_ms=None)

添加一个回调用于接收当 GPIO 状态从 0 到 1（反之亦然）时的通知。 可能用到的临界值为 rising、falling、both（默认）。 可能用到的 pull_up_down 值为：RPIO.PUD_UP、RPIO.PUD_DOWN、RPIO.PUD_OFF（默认）。 如果 threaded_callback 为 True，回调将开始与线程内。否则直到其结束后，回调才会从中断等待状态下阻断 RPIO（在这期间，不会有其它回调操作）。 如果设置了 debounce_timeout_ms，那么从上次中断结束后，需要等到您指定的毫秒数后才会再次执行中断回调操作。可以根据您的需求进行设置（通常为 10ms 到 100ms 之间）。

回调功能有两个参数，分别为：GPIO 编号和值。（值为整数，0（Low）或 1（High））。回调操作通常写法为： def gpio_callback(gpio_id, value): RPIO.del_interrupt_callback(gpio_id)

移除特定 GPIO 上的回调操作。

TCP Socket 中断

仅使用这一种方法就可以方便的为入站 TCP 连接打开端口：

RPIO.add_tcp_callback(port, callback, threaded_callback=False)

添加 socket 服务器回调，它会在某个已连接的 socket 客户端发送数据时开始执行。这被用于 RPIO 在特定端口创建 TCP 服务器 socket。当 RPIO.wait_for_interrupts() 运行时，将接受入站连接。回调必须指定两个参数：socket 和 message（例如：def callback(socket, msg)）。

回调可以使用 socket 参数将值发回到客户端（例如：socket.send(“hi there

”)）。如果要关闭某客户端的连接，可使用 RPIO.close_tcp_client(..)。客户端可以使用相同的方式关闭连接，或者发送到服务器一个空信息也会同样断开连接。

您可以使用 socket.getpeername() 来获得客户端的 IP 地址。详情可参见 Socket 对象文档。

您可以输入命令 $ telnet 对 TCP socket 中断进行测试（例如：$ telnet localhost 8080）。空字符串将通知服务器断开与客户端的连接（比如，您在 telnet 中按下回车键，您得连接将被断开）。

RPIO.close_tcp_client(self, fileno)

关闭客户端 socket 连接并从 epoll 中移除。您可以使用回调中的 RPIO.close_tcp_client(socket.fileno()) 来实现。

示例

以下示例将示范如何监听某些 GPIO 和 TCP 中断：

import RPIO def gpio_callback(gpio_id, val): print(“gpio %s: %s” % (gpio_id, val)) def socket_callback(socket, val): print(“socket %s: ‘%s'” % (socket.fileno(), val)) socket.send(“echo: %s

” % val) # GPIO 中断回调 RPIO.add_interrupt_callback(7, gpio_callback) RPIO.add_interrupt_callback(9, gpio_callback, pull_up_down=RPIO.PUD_UP) # 回调服务器端口 8080 TCP socket RPIO.add_tcp_callback(8080, socket_callback) # 阻断主 epoll 循环 RPIO.wait_for_interrupts()

在进程内接收回调（并且不对 RPIO 返回到等待中断状态进行阻隔），需要在添加时将 threaded_callback 设置为 True：

# 用于 GPIO 中断 RPIO.add_interrupt_callback(7, do_something, threaded_callback=True) # 用户 socket 中断 RPIO.add_tcp_callback(8080, socket_callback, threaded_callback=True)

去除 GPIO 中断抖动，您可以添加 debounce_timeout_ms 参数到 add_interrupt_callback(..) 中。例如：

RPIO.add_interrupt_callback(7, do_something, debounce_timeout_ms=100)

wait_for_interrupts() 对中断和调度进行监听。您可以添加 threaded=True 参数，使其运行于一个线程中，使您的脚本继续运行。从版本 v0.10.0 开始，当您的脚本退出后，RPIO 已经可以很好的关闭所有操作了。

RPIO.wait_for_interrupts(threaded=True)

停止 wait_for_interrupts(..) 可以通过调用 RPIO.stop_waiting_for_interrupts() 来实现。

GPIO 输入和输出

RPIO 对 RPi.GPIO 进行了扩展，所有输入和输出的工作方式都是相同的：

import RPIO # 设置无上拉电阻输入通道 RPIO.setup(7, RPIO.IN) # 设置有上拉电阻输入通道。可以为： # PUD_UP、PUD_DOWN、PUD_OFF（默认） RPIO.setup(7, RPIO.IN, pull_up_down=RPIO.PUD_UP) # 读取 GPIO 7 的输入值 input_value = RPIO.input(7) # 设置 GPIO 输出通道 RPIO.setup(8, RPIO.OUT) # 设置 GPIO 8 的值为 High RPIO.output(8, True) # 设置输出通道及初始值 RPIO.setup(8, RPIO.OUT, initial=RPIO.LOW) # 更改为 BOARD 编号方式 RPIO.setmode(RPIO.BOARD) # 在通道 17 上设置软件上拉电阻 RPIO.set_pullupdn(17, RPIO.PUD_UP) # RPIO 新增功能 # 获得通道 8 的函数 RPIO.gpio_function(8) # 复位所有由该程序设置过的通道， # 并清除 GPIO 中断接口 RPIO.cleanup()

您可以在现有代码中使用 RPIO 直接替换 RPi.GPIO：

import RPIO as GPIO # （如果您之前使用的是“import RPi.GPIO as GPIO”）

如果想获得更多使用方法及常量的讲解，可以运行 $ sudo pydoc RPIO，或者在 Python 中使用帮助功能：

import RPIO help(RPIO)

日志输出

开启 RPIO 日志输出，需在引入 RPIO 之前先引入 logging 函数并设置日志级别为 DEBUG：

import logging log_format = ‘%(levelname)s | %(asctime)-15s | %(message)s’ logging.basicConfig(format=log_format, level=logging.DEBUG) import RPIO

对 RPi.GPIO 的扩展

更多可用常量

RPIO.RPI_REVISION – 当前主板的修订版本（1 或者 2）

RPIO.RPI_REVISION_HEX – CPU 的 16 进制修订码（0002 到 000f）

更多可用功能

RPIO.gpio_function(gpio_id) – 返回 GPIO 当前的设置（IN、OUT、ALT0）

RPIO.set_pullupdn(gpio_id, pud) – 在 GPIO 上设置上拉或下拉电阻

RPIO.forceinput(gpio_id) – 无需调用 setup() 直接读取任何 GPIO 上的值

RPIO.forceoutput(gpio_id, value) – 无需调用 setup() 直接为 GPIO 写入值

（警告：该功能可能会损坏您的 Raspberry Pi）

（警告：该功能可能会损坏您的 Raspberry Pi） RPIO.sysinfo() – 返回 Raspberry Pi 系统信息（hex_rev, model、revision、mb-ram、maker）

RPIO.version() – 返回 RPIO 信息（version_rpio、version_cgpio）

中断处理

RPIO.add_interrupt_callback(gpio_id, callback, edge=’both’, pull_up_down=RPIO.PUD_OFF, threaded_callback=False, debounce_timeout_ms=None)

RPIO.add_tcp_callback(port, callback, threaded_callback=False)

RPIO.del_interrupt_callback(gpio_id)

RPIO.close_tcp_client(fileno)

RPIO.wait_for_interrupts(threaded=False, epoll_timeout=1)

RPIO.stop_waiting_for_interrupts()

操控 epoll

原文地址：RPIO, the Python module

项目地址：RPIO’s documentation!

基础命令

安装软件 apt-get install softname1 softname2 softname3……

卸载软件 apt-get remove softname1 softname2 softname3……

卸载并清除配置 apt-get remove –purge softname1

更新软件信息数据库 apt-get update

进行系统升级 apt-get upgrade

搜索软件包 apt-cache search softname1 softname2 softname3……

如果使用 apt-get 遇到速度慢或者源不存在等错误，可能需要更换源，请参考此处。

安装deb软件包 dpkg -i xxx.deb

删除软件包 dpkg -r xxx.deb

连同配置文件一起删除 dpkg -r –purge xxx.deb

查看软件包信息 dpkg -info xxx.deb

查看文件拷贝详情 dpkg -L xxx.deb

查看系统中已安装软件包信息 dpkg -l

重新配置软件包 dpkg-reconfigure xxx

清除所有已删除包的残馀配置文件

dpkg -l |grep ^rc|awk ‘{print $2}’ |sudo xargs dpkg -P

如果报如下错误，证明你的系统中没有残留配置文件了，无须担心。

dpkg: –purge needs at least one package name argument

dpkg安裝的可以用apt卸載，反之亦可。

aptitude 命令

aptitude 与 apt-get 一样，是 Debian 及其衍生系统中功能极其强大的包管理工具。与 apt-get 不同的是，aptitude 在处理依赖问题上更佳一些。举例来说，aptitude 在删除一个包时，会同时删除本身所依赖的包。这样，系统中不会残留无用的包，整个系统更为干净。以下是笔者总结的一些常用 aptitude 命令，仅供参考。

aptitude update 更新可用的包列表

aptitude upgrade 升级可用的包

aptitude dist-upgrade 将系统升级到新的发行版

aptitude install pkgname 安装包

aptitude remove pkgname 删除包

aptitude purge pkgname 删除包及其配置文件

aptitude search string 搜索包

aptitude show pkgname 显示包的详细信息

aptitude clean 删除下载的包文件

aptitude autoclean 仅删除过期的包文件

当然，你也可以在文本界面模式中使用 aptitude。

常用apt命令列表

apt-cache search # ——(package 搜索包) apt-cache show #——(package 获取包的相关信息，如说明、大小、版本等) sudo apt-get install # ——(package 安装包) sudo apt-get install # —–(package – – reinstall 重新安装包) sudo apt-get -f install # —–(强制安装?#”-f = –fix-missing”当是修复安装吧…) sudo apt-get remove #—–(package 删除包) sudo apt-get remove – – purge # ——(package 删除包，包括删除配置文件等) sudo apt-get autoremove –purge # —-(package 删除包及其依赖的软件包+配置文件等（只对6.10有效，强烈推荐）) sudo apt-get update #——更新源 sudo apt-get upgrade #——更新已安装的包 sudo apt-get dist-upgrade # ———升级系统 sudo apt-get dselect-upgrade #——使用 dselect 升级 apt-cache depends #——-(package 了解使用依赖) apt-cache rdepends # ——(package 了解某个具体的依赖?#当是查看该包被哪些包依赖吧…) sudo apt-get build-dep # ——(package 安装相关的编译环境) apt-get source #——(package 下载该包的源代码) sudo apt-get clean && sudo apt-get autoclean # ——–清理下载文件的存档 && 只清理过时的包 sudo apt-get check #——-检查是否有损坏的依赖

用树莓派播放豆瓣FM电台，只需要3条简单的命令完成安装。

首先确认使用的树莓派OS是 Raspbian 系统，因为接下来要安装的应用是基于Linux的。

#安装 mplayer 播放器，如果之前没有装过的话 sudo apt-get install mplayer #安装 Python-pip sudo apt-get install python-pip #通过 Python-pip 安装 douban.fm sudo pip install douban.fm

这个 douban.fm 程序是来自 github 的一个开源项目，基于 douban 的 API。

安装完成之后，输入以下命令行即可进入播放器界面。

douban.fm

第一次登陆需要输入账号,密码,程序不会保留密码,而是保存返回的token存储在~/.douban_token.txt,下次登陆无需输入密码。

效果如下：

操作快捷键

移动

[j] –> 下

[k] –> 上

[g] –> 移到最顶

[G] –> 移到最底

音乐

[space] –> 播放

[w] –> 打开歌曲主页

[n] –> 下一首

[r] –> 喜欢/取消喜欢

[b] –> 不再播放

[q] –> 退出

[p] –> 暂停

[l] –> 单曲循环

音量(>=V0.2.9)

[=] –> 增

[-] –> 减

[m] –> 静音

歌词(>=v0.2.9)

[o] –> 显示歌词(Bug很多,先别用,没有反应就是没找到歌词)

[q] –> 退出歌词

.doubanfm_config保存在了~/.doubanfm_config,根据需要可以修改按键的映射

[key] UP = k # 上 DOWN = j # 下 TOP = g # 顶 BOTTOM = G # 底 OPENURL = w # 打开歌曲主页 RATE = r # 标记喜欢/取消喜欢 NEXT = n # 下一首 BYE = b # 不再播放 QUIT = q # 退出 PAUSE = p # 暂停 LOOP = l # 单曲循环 MUTE = m # 静音

MCC 172是一个两通道DAQ HAT，用于通过IEPE传感器（如加速度计和麦克风）进行声音和振动测量。它的每个通道具有24位A/D，最大采样率为51.2 kS/s/Ch。

Camkit (Camera toolKit)

Camkit是一个摄像头相关的工具箱，使用C语言写成，包含了从：图像采集–>色彩转换–>H264编码–>RTP打包–>网络发送的全套接口。

可到这里下载已编译好的二进制版本。

编译

Camkit采用cmake构建系统，编译之前请确认已经安装了cmake。

遵循以下步骤完成编译和安装：

cd Camkit_source_dir mkdir build cd build cmake ../ -Dkey=value make make install

其中-Dkey=value是可以配置的选项，支持的选项如下：

1. DEBUG=ON|OFF，是否打开调试选项

2. PLATFORM=FSL|RPI|OFF， 选择所使用的平台（Freescale, RaspberryPi或FFmpeg），具体见下文

3. CC=path_to_c_compiler|OFF， 指定C编译器的路径

4. ROOTSYS=path_to_root_sys|OFF， 指定查找库和头文件的根路径（配合3选项可以用来做交叉编译）

Camkit的视频采集采用标准的V4L接口，通常的USB摄像头均可以支持。

Camkit的色彩转换和H264编码支持三种平台，分别是是：

1. FFmpeg (采用ffmpeg编码，依赖于avcodec.so和swscale.so)

2. Raspberry Pi (采用OpenMax硬编码，依赖于ilclient.a， vcsm.so， bcm_host.so， openmaxil.so等库，由于色彩转换部分使用了ffmpeg，因此还依赖于其中的swscale库)

3. Freescale I.MX6 (采用IPU和VPU硬编码，依赖于ipu.so和vpu.so)

PC平台编译安装

使用ffmpeg编码，Camkit可以在PC上使用，原则上应该是跨平台的，但由于作者的开发主要是在Linux上完成，其他平台未经测试，今后有时间再做移植。下面主要介绍如何在Linux上编译安装。

在Linux上编译安装非常简单，以Ubuntu为例，首先安装编译环境:

sudo apt-get install cmake libavcodec54 libavcodec-dev libswscale2 libswscale-dev

然后遵循上面的构建步骤，使用如下命令构建和编译：

mkdir build cd build cmake ../ make make install

至此， libcamkit.so 就已经安装到你的系统里了，默认应该在 /usr/local/lib 下，头文件在 /usr/local/include 下。 demo 中的程序默认不会安装，可在 build/demo 目录下找到并运行，参照 demo 程序就可开发自己的应用了。

树莓派平台编译安装

要在树莓派上使用可以选择在PC上交叉编译，也可将源代码拷到树莓派上直接编译，这里介绍后一种方式。

首先用 scp 之类的工具将Camkit的源代码拷到树莓派上，进入源码目录。由于树莓派运行的也是Linux系统，原则上可以和PC上一样使用ffmpeg库，但是实际效果非常卡顿，每秒仅有1~2帧，cpu消耗90%左右，因此推荐使用针对树莓派的OpenMax方案，下面是编译说明。

使用OpenMax需要一些头文件和库，这些库一般都在 /opt/vc/ 目录下，不需要另外安装，除了一个库例外： libilclient.a 。这是一个简单的封装库，可以到github下载源代码，两个 .c 文件、一个 .h 文件和一个 Makefile ，将上上层目录下的 Makefile.include 文件也下载下来。将这些文件都拷到树莓派上，用以下命令安装：

mkdir -p build/one/two cp ilclient.h ilclient.c ilcore.c Makefile build/one/two cp Makefile.include build cd build/one/two make cp libilclient.a /opt/vc/lib

最后一步将编译好的库拷贝到 /opt/vc/lib 目录下。

除了OpenMax库之外，Camkit做色彩转换是还是使用了ffmepg中的 libswscale 库，因此需要在树莓派上先安装，方式可PC上的相同，通过 apt-get 安装 libswscale 和 libswscale-dev 即可（如何是 Arch 平台使用 pacman -S ffmpeg ）。

一切都做完之后就可以编译Camkit了，进入Camkit源码目录，使用如下命令编译安装：

mkdir build cd build cmake ../ -DPLATFORM=RPI make make install

这样，Camkit就已经安装到你的树莓派上了，路径和PC上的相同，demo程序在 build/demo 目录下。

使用

Camkit的接口非常简单方便，每个子功能均遵循类似的接口。

xxxHandle = xxx_open(xxParams); // 打开xxx handle，例如： capture_open, convert_open… … // 具体操作 xxx_close(xxxHandle); // 关闭handle，例如capture_close, convert_close…

一般调用步骤如下：

struct cap_handle *caphandle = NULL; // capture操作符 struct cvt_handle *cvthandle = NULL; // convert操作符 struct enc_handle *enchandle = NULL; // encode操作符 struct pac_handle *pachandle = NULL; // pack操作符 struct net_handle *nethandle = NULL; // network操作符 struct cap_param capp; // capture参数 struct cvt_param cvtp; // convert参数 struct enc_param encp; // encode参数 struct pac_param pacp; // pack参数 struct net_param netp; // network参数 // 设置各项参数 capp.xxx = xxx … cvtp.xxx = xxx; … encp.xxx = xxx; … pacp.xxx = xxx; … netp.xxx = xxx; … // 使用设置好的参数打开各项功能 caphandle = capture_open(capp); cvthandle = convert_open(cvtp); enchandle = encode_open(encp); pachandle = pack_open(pacp); nethandle = net_open(netp); capture_start(caphandle); // 开始capture while(1) { capture_get_data(caphandle, …); // 获取一帧图像 convert_do(cvthandle, …); // 转换,YUV422=>YUV420， 如果你的摄像头直接支持采集YUV420数据则不需要这一步 while (encode_get_headers(enchandle, …) == 1) // 获取h264头，PPS/SPS { … } encode_do(enchandle, …); // 编码一帧图像 pack_put(pachandle, …); // 将编码后的图像送给打包器 while(pack_get(pachandle, …) == 1) // 获取一个打包后的RTP包 { net_send(nethandle, …); // 将RTP包发送出去 } } capture_stop(caphandle); // 停止capture // 关闭各项功能 net_close(nethandle); pack_close(pachandle); encode_close(enchandle); convert_close(cvthandle); capture_close(caphandle);

Note:

其中的每一个子功能都可以独立使用，例如只做采集，或者图像编码之后写入文件而不做打包和发送等等。 如果是使用官方的树莓派摄像头，则采集部分不可用，需要另外写代码，但后面的编码打包等功能均可正常使用。

PS: demo目录有两个完整的例子，可以参考之。

实例–在树莓派上运行demo查看实时录像

demo/cktool.c是运用Camkit的一个例子，实现了Camkit支持的全部功能。

使用方法：

$cktool [options]

options：

-? 显示帮助信息

-d 是否显示调试信息

-s 设置步骤 0/1/3/7/15 (0:只做采集,1:采集+转换, 3:采集+转换+编码(默认),7:采集＋转换+编码+打包,15:采集+转换+编码+打包+发送)

-i 设置打开的摄像头设备(默认/dev/video0)

-o 设置写入的文件

-a 设置网络端的ip地址

-p 设置网络端的端口号

-c 设置采集图像格式: 0: YUYV(默认), 1: YUV420

-w 设置视频宽 (640)

-h 设置视频高 (480)

-r 设置编码帧率 kbps (1000)

-f 设置帧率 (15)

-t 设置图像是否交织 (0)

-g 设置编码的gop大小 (12)

假设我们要在树莓派上使用Camkit，将树莓派和PC连在同一个路由器上。

RPI(Camkit) <==> 路由器 <==> PC (VLC)

首先，按照上面的讲解完成编译，在 build/demo 目录下可以看到一个 cktool 的可执行程序。

配置树莓派开启摄像头支持并分配 gpu_mem ， Raspbian 系统通过 sudo raspi-config ， Arch 系统参见Wiki。

然后，在PC上用记事本打开 demo/video.sdp 文件，修改ip地址为PC的ip地址，假设为 192.168.1.2 ，设置端口，假设为 8888 。运行VLC播放器，打开demo/video.sdp文件。

最后，在树莓派上运行：

#cktool -s 15 -a 192.168.1.2 -p 8888

至此，应该就可以在PC端看到树莓派的实时视频了。

via https://git.oschina.net/andyspider/Camkit

2月2日，树莓派基金会宣布了树莓派升级版“树莓派2”已开始销售。在作出下列硬件升级的同时，依然维持了35美元的售价：

搭载900MHz 的四核处理器（900MHz quad-core ARM Cortex-A7 CPU ），预计性能6倍于之前的B+版本。

1GB LPDDR2 SDRAM，2倍于之前的B+版本。

与1代完全兼容。

由于CPU已经升级到 ARM7 系，所以树莓派2将支持运行全系列的 ARM GNU/Linux 发行版。包括 Ubuntu 甚至 微软的 Windows 10。

BCM2836 AND RASPBERRY PI 2（树莓派2）

这里是树莓派基金会和微软合作的一个项目 Windows Developer Program for IoT.

link: http://www.raspberrypi.org/raspberry-pi-2-on-sale/

脉宽调制(PWM)是指用微处理器的数字输出来对模拟电路进行控制，是一种对模拟信号电平进行数字编码的方法。在树莓派上，可以通过对GPIO的编程来实现PWM。

创建一个 PWM 实例：

p = GPIO.PWM(channel, frequency)

启用 PWM：

p.start(dc) # dc 代表占空比（范围：0.0 <= dc >= 100.0）

更改频率：

p.ChangeFrequency(freq) # freq 为设置的新频率，单位为 Hz

更改占空比：

p.ChangeDutyCycle(dc) # 范围：0.0 <= dc >= 100.0

停止 PWM：

p.stop()

注意，如果实例中的变量“p”超出范围，也会导致 PWM 停止。

以下为使 LED 每两秒钟闪烁一次的示例：

import RPi.GPIO as GPIO GPIO.setmode(GPIO.BOARD) GPIO.setup(12, GPIO.OUT) p = GPIO.PWM(12, 0.5) p.start(1) input(‘点击回车停止：’) # 在 Python 2 中需要使用 raw_input p.stop() GPIO.cleanup()

以下为使 LED 在亮/暗之间切换的示例：

import time import RPi.GPIO as GPIO GPIO.setmode(GPIO.BOARD) GPIO.setup(12, GPIO.OUT) p = GPIO.PWM(12, 50) # 通道为 12 频率为 50Hz p.start(0) try: while 1: for dc in range(0, 101, 5): p.ChangeDutyCycle(dc) time.sleep(0.1) for dc in range(100, -1, -5): p.ChangeDutyCycle(dc) time.sleep(0.1) except KeyboardInterrupt: pass p.stop() GPIO.cleanup()

相关链接:

RPi.GPIO module PWM

MCC 172是一个两通道DAQ HAT，用于通过IEPE传感器（如加速度计和麦克风）进行声音和振动测量。它的每个通道具有24位A/D，最大采样率为51.2 kS/s/Ch。

首先树莓派连上网络，并和电脑在同一网段。

树莓派的IP是: 192.168.3.13

电脑的IP是: 192.168.3.6

1.在树莓派上采集 H264裸流,并用UDP发送到电脑.

pi@Neil-PI ~ $ raspivid -t 999999 -hf -o -| socat – udp-datagram:192.168.3.6:8080

如果没有安装 socat ,需要先安装 apt-get install socat

2. 在电脑上用VLC观看 H264裸流

Google了好久，才找到一个最简单的方法。

命令行启动 vlc

C:\Program Files (x86)\VideoLAN\VLC>vlc udp://@:8080 –demux=h264

性能测试

1. 用1M码流来采集720P

raspivid -w 1280 -h 720 -b 1000000 -pf high -v -t 999999 -hf -o -| socat – udp-datagram:192.168.3.6:8080

2. CPU 占用 和 VLC 情况

3. 延时

默认大概5秒，可以改变VLC的参数，大幅降低延时。

–udp-caching=500 延时0.5秒

via