Author: 互联网

虽然在树莓派上用户已经可以安装Windows 10 IoT Core系统，不过得益于近期启动的Windows 10 on ARM平台，荷兰开发者Bas Timmer（推特账号@NTAuthority）近日在树莓派3（Broadcom BCM2837 ARMv8处理器）上成功安装完整版Windows 10系统。

Windows 10 on ARM是微软近期公布、最值得关注的项目，允许在高通骁龙处理器上运行完整版Windows 10系统，并且具备超高续航的优点。

虽然已经成功移植，并且能够运行传统Win32应用程序，但是也存在很多不足。Timmer表示目前系统只能调用1个CPU核心，其他核心会跳出“未支持的处理器”。

树莓派 Zero 之所以成为一款非常棒的单板计算机并不全因为它小巧的尺寸和便宜的价格，还得益于它便捷、易用的特性。在加装了 Zero Quick Plug 或 microUSB/USB 转换头之后，将树莓派 Zero 和电脑连接起来。树莓派 Zero 即可配置成 USB/以太网设备，这时仅需要一个 USB 接口就实现给树莓派供电的同时将它接入因特网。不再需要携带额外的电源适配器、 USB HUB和无线网卡。可以说这是迄今为止连接树莓派最简单、方便的方式！

对于 Raspbian 2016-10-5 之后的系统镜像，你只需要在系统 SD 卡上修改几处配置文件即可将树莓派配置成一个 USB/以太网设备。

配置 CONFIG.TXT 和 CMDLINE.TXT 文件

请确认你刷入的系统镜像是 2016-10-5 之后的版本。将刷好系统的 SD 卡在电脑上打开，进入 SD 卡根目录并打开 config.txt 文件。在文件末尾添加一行 dtoverlay=dwc2。

保存并关闭 config.txt 文件。

再打开 cmdline.txt 文件，请确认你的编辑器已关闭“自动换行”。编辑这个文件的时候不需要插入任何换行符，所有字符都在同一行。找到 rootwait，在后面插入 modules-load=dwc2,g_ether。

保存并关闭 cmdline.txt 文件。

最后在根目录创建一个名为 ssh 的文件或目录。

好了，可以从电脑上弹出 SD 卡了。把 SD 卡插入树莓派 Zero，用 Zero Quick Plug 或 microUSB/USB 转换头将树莓派 Zero 和电脑连接起来。

图中用到的这款连接部件是树莓派 Zero 多功能 USB 插头（Zero Quick Plug），详见下图。

这时系统会自动识别到树莓派。

等待树莓派启动可能需要半分钟，然后就可以在网络列表中看到了设备已分配好 IP 地址。

现在，就可以尝试通过 SSH 连接树莓派的地址 raspberrypi.local 了。

如果你用的是 Raspbian 桌面版，你可以安装一个 RDP（远程桌面协议）客户端然后在电脑上通过远程桌面（ “Remote Desktop Connection for Mac” ）客户端连接到树莓派，连接地址同样是 raspberrypi.local。（具体方法可参考）

这时你的树莓派 Zero 还没有接入因特网，有两种方法接入因特网——其一，通过配置 Zero W 板载的无线网卡连接到无线路由器网络；其二，将电脑的网络通过 USB/以太网设备接口方式共享给树莓派，下面介绍第二种方法。

首先进入 macOS 的“共享”配置界面。

勾选“Internet Sharing”，并在右侧选择要共享的设备。设置好之后，通过 SSH 登录树莓派，Ping 测试一下就可以看到已经连接上因特网了。

另有 Windows 平台下使用这一功能的教程，移步这里阅读。

树莓派 Zero 之所以成为一款非常棒的单板计算机并不全因为它小巧的尺寸和便宜的价格，还得益于它便捷、易用的特性。在加装了 Zero Quick Plug 或 microUSB/USB 转换头之后，将树莓派 Zero 和电脑连接起来。树莓派 Zero 即可配置成 USB/以太网设备，这时仅需要一个 USB 接口就实现给树莓派供电的同时将它接入因特网。不再需要携带额外的电源适配器、 USB HUB和无线网卡。可以说这是迄今为止连接树莓派最简单、方便的方式！

对于 Raspbian 2016-10-5 之后的系统镜像，你只需要在系统 SD 卡上修改几处配置文件即可将树莓派配置成一个 USB/以太网设备。

这个教程基于 Windows 平台，在连接树莓派之前，你可能需要在电脑上安装 Bonjour。它允许你的电脑自动识别 USB/以太网设备，例如打印机、扫描仪以及我们需要的树莓派。Bonjour 被包含在 iTunes 与 Adobe CS 软件中，所以很可能你已经装有这个软件，如果没有，你可以在这里单独下载安装。

一、配置 CONFIG.TXT 和 CMDLINE.TXT 文件

开始刷入系统，请确认你下载的系统镜像是 2016-10-5 之后的版本。在电脑上将系统镜像写入 micro SD 卡，可以使用 Win32 Disk Imager 这个工具（这里下载）。

完成之后，在电脑上打开这个 micro SD 卡的根目录 (例如. boot(E:)) 并打开 config.txt 文件。在文件末尾添加一行 dtoverlay=dwc2。

保存并关闭 config.txt 文件。

再打开 cmdline.txt 文件，请确认你的编辑器已关闭“自动换行”。编辑这个文件的时候不需要插入任何换行符，所有字符都在同一行。找到 rootwait，在后面插入 modules-load=dwc2,g_ether。

保存并关闭 cmdline.txt 文件。

最后在根目录创建一个名为 ssh 的文件或目录。

好了，可以从电脑上弹出 SD 卡了。把 SD 卡插入树莓派 Zero，用 Zero Quick Plug 或 microUSB/USB 转换头将树莓派 Zero 和电脑连接起来。

图中用到的这款连接部件是树莓派 Zero 多功能 USB 插头（Zero Quick Plug），详见下图。

这时 Windows 会自动识别到树莓派，并尝试安装驱动。

注意，有用户发现在 Windows 10 下设备会被识别为 COM 设备，这时请在设备管理器中更新该设备的驱动程序即可。驱动程序可在这里下载。

到这里，打开 PuTTY（这里下载）并尝试通过 SSH 连接树莓派的地址 raspberrypi.local。

如果你发现可以正常连接和登录树莓派，恭喜你！下面“安装 RNDIS 驱动”的步骤可以跳过了！直接从下面“设置共享互联网连接”开始阅读。

如果在这里遇到错误提示 “Unable to open connection to raspberrypi.local. Host does not exist”, 那么你需要在电脑上安装 RNDIS 驱动。

二、安装 RNDIS 驱动（酌情跳过）

保持树莓派与电脑的连接，打开 Windows 的“设备管理”，在“其他设备”中找到“RNDIS/Ethernet Gadget”, 右键选择“更新驱动程序”。

再选择“Browse my computer for driver software”。

选择“Let me pick from a list of device drivers on my computer”。

选择“Network adapters”，下一步。

在 “Manufacturer” 列表中选择 “Microsoft”。在 “Network Adapters” 列表中选择“Remote NDIS Compatible Device”，下一步。

在弹出的对话框中选择“Yes”。

安装完驱动之后，你将看到这个窗口。

现在尝试用 PuTTY 连接地址 raspberrypi.local。

三、设置共享互联网连接

为了将电脑的互联网连接共享给树莓派，我们需要允许共享你电脑上的一个网络连接。打开“Network Connections”。

你的树莓派在里面显示为 “RNDIS/Ethernet Gadget” 的设备类型，在上图示例中，名字是“Ethernet 2”。

现在你要确定用哪一个连接给树莓派访问用 （WiFi 或以太网）。这里我选择让树莓派通过电脑的“Wi-Fi”这个连接去访问互联网，所以我启用这个连接之后在右键“属性”中进行设置。

选择“共享”标签。

勾选“Allow other network users to connect through this computer’s Internet connection”，在下拉菜单中找到树莓派的连接名称（这里选择 Ethernet 2）。

WiFi 网络这时出现“Shared”标注了。

现在可以重启你的树莓派并重新用 PuTTY 登录了。

登录树莓派之后，用 ifconfig 命令查看 usb0 连接可以看到网络上行和下行的流量。

Ping 一下某些网站域名，确认互联网连接是否正常。

如果你用的是 Raspbian 桌面版，你可以安装一个 RDP（远程桌面协议）客户端然后在电脑上通过远程桌面（ “Remote Desktop Connection” ）客户端连接到树莓派，连接地址同样是raspberrypi.local。（具体方法）

将你的树莓派 Zero 配置成 USB/以太网设备，可以仅需要一个 USB 接口就实现给树莓派供电的同时将它接入因特网。不再需要携带额外的电源适配器、 USB HUB和无线网卡。可以说这是迄今为止连接树莓派最简单、方便的方式！

另有 macOS 平台下使用这一功能的教程，移步这里阅读。

前言

前段时间树莓派（Raspberry Pi）发布了一款新的计算模块 Compute Module 3 (CM3) ，是自 2014 年初代 CM1 后首次更新。CM3 计算模块有两个版本，一个是“标准”的 CM3，另一个则是 CM3 Lite，价格分别为 30 美元和 25 美元，CM3配备了 1.2GHz 的 BCM2837 处理器，1GB RAM 和 4G eMMC 闪存。相比之下，CM3 Lite（CM3L）没有内置闪存，反倒是提供了 SD 卡接口，用户可按需选择 eMMC 或是 SD 卡，这个功能更新满足了不少老用户对闪存扩容的需求。CM3和 CM1 相比，CM3 的 CPU 性能是原来的 10 倍，内存比翻了 1 倍。而且也会和 Raspberry Pi 3 一样，支持 Win 10 的物联网系统（Windows10 IoT Core）。

最近越来越多的玩家购买了CM模块和底板，但是苦于一直不能上手，原因是不会给CM模块烧录系统，网上也少有相关的教程，从今天U大就指导你如果玩转树莓派CM系列。

教程

1.首先需要准备好CM模块(CM1/CM3/CM3L)

2.准备好CM模块底板

3.下载解压win系统需要的驱动和并安装boot工具（bcm270x-boot-driver，CM-Boot-Installer）

4.将CM模块插上底板，将左上角的跳线帽跳至EN USB BOOT,然后连接USB SLAVE和PC，最后再连接POWER IN电源给底板供电

5.WIN系统会提示安装驱动，可以取消自动更新驱动，变成手动更新驱动（bcm270x-boot-driver），直到驱动安装正常如下图

6.运行安装好的boot工具RPiBoot.exe, 这时候CM模块的eMMC就会模拟成内存卡，出现在系统目录下

7.按照通常的TF卡烧录系统的方法，就可以给CM模块的eMMC烧录系统了（TF卡烧录系统方法）

注意：目前CM模块的eMMC只有4G，而官方提供的系统大多都超过4G，烧写时可能会中断并提示空间不够，所以玩家在烧录CM系统时请选择适合4G以下的镜像。

原文

你知道吗？树莓派 Zero 也是有集成视频输出接口的。

如果你希望用老式的电视作为树莓派 Zero 的显示器，往下阅读吧……

没错，正如图上这么简单就可以搞定。树莓派 Zero 并没有限制视频只能通过 HDMI 接口输出，同之前的树莓派1代B型一样，只需要自己将 RCA 给 DIY 接上即可。

首先你需要准备：

树莓派 Zero 主板

RCA 端子 1 个

2Pin 排针 1 个

母对母杜邦线2根

按照图上所示，将排针焊接到树莓派 Zero 的这个位置。

这样之后，树莓派会自动检测视频接口并选择从 HDMI 或 RCA 接口输出。如果到这一步并没有效果，请继续阅读按照下面的配置来让它正常工作。

配置软件

先备份 config.txt 文件，以备遇到故障时可以随时恢复。

sudo cp /boot/config.txt /boot/config.txt_backup

然后修改 config.txt。

sudo nano /boot/config.txt

有两行需要修改，去掉这几行前的注释符号“#”。

sdtv_mode=2 hdmi_force_hotplug=1

保存之后关闭树莓派、通过 RCA 接口接上显示器、再启动树莓派，看看显示器是不是正常工作了吧！

树莓派实验室出品的树莓派“瑞士军刀”扩展板新版本 V2.1 已上架。该版本与之前的 V2.0 版本功能一致，原来的程序无需改动即可兼容新版本。硬件方面主要做了一次小调整：

1. 调整了LED的颜色和排布

2. 优化红外接收电路

3. 调整电解电容为钽电容

4. 优化电路板布线

5. 更换了部分元件供应商，品质优化

我们网店销售的即为最新版本，点这里可以订购。相关的介绍和资料已经更新，旧版本的SAKS已停售。

福利在这里：即日起至 2018 年 3 月 15 日期间在我们店铺购买树莓派瑞士军刀扩展板的用户，我们将特别赠送 GPIO 参考卡片黑金版一件。

点击查看更多有关 SAKS 的图片

这是一件用树莓派制作的形似 Switch 的游戏机，作者 cfoote7 写道：

感谢树莓派基金会富有创意的开发人员、RetroPie 同样重要的Kodi。最后，我要感谢 Nintendo 让我做这个逆向工程，我可不太愿意玩它家的 Switch 主机。

这款主机将集复古游戏模拟器、媒体中心、微型电脑等多种用途于一身的，制作过程比较复杂，还是让我们看一组制成品的视频先睹为快吧！

使用预览

运行 Debain 系统变身微型电脑

运行 Kodi 系统变身媒体中心

游戏视频

第1步：采购准备工作

你将需要以下工具：

烙铁+焊料+助焊剂

热熔胶枪

3D打印机或借助3D打印服务商

一套完整的微型螺丝刀套件

精密钻头工具或带3/16钻头的钻头套件

耐心点，下面才是重点！

部件包括：

树莓派官方7寸屏幕

Kingwin 80 件什锦笔记本更换螺丝套件或（各种大小和类型的螺丝）

26 awg 电线

1/8英寸大小立体声插孔带开关

迷你金属音箱

微型电源开关

充满电的6600毫瓦电池

Joy-Con控制器（推荐使用充电器）

树莓派3B（内置蓝牙和WiFi）

PAM8302 2.5W 音频功放

PowerBoost 1000C

3d打印的外壳（所需文件在这里下载）

Pi3SuperAwesomePortable_brackets.stl

SwitchPiScreen_v2.stl

Pi3SuperAwesomePortable_Case_2mm.stl

可选项：

树莓派官方摄像头二代

第2步：将音频接口焊接到树莓派上

首先从树莓派开始，将26 awg 电线与树莓派焊接：

我会在音频接口附近将红色的左声道焊接到pp26(感谢树莓派基金会标记的焊盘）将黑色焊接到pp24。

右声道是黄色导线，并将其焊接到音频接口的左上角引脚。

我建议留下额外的8-10厘米长的电线，你可以将它们剪下来，或者卷起来留用。因为我的项目经常被拆开并重建或重新使用。我非常喜欢这个特殊的1/8插孔。我之所以选择它，是因为能清晰的从顶部看到并彻底的了解它的工作原理。

焊接音频接口（引脚见上图）：

从树莓派上取下红色导线并将其焊接到1/8插孔上的针脚2上。

从树莓派上取下黄色导线，并将其焊接到1/8插孔上的针脚5上。

取下黑色导线，再拧8-10厘米长的黑色导线，然后在1/8插孔上焊接到针脚1上。

将8-10厘米长的红色导线焊接到1/8插孔上的针脚3上。

你现在应该有一个音频接口连接到树莓派，如果你播放声音，然后插入耳，就会很清晰地听见声音。我建议将导线用热熔胶粘合在树莓派的底部，同时底部的接口能固定细线，并保护它们免受损坏和短路。

第3步：焊接电源板和开关

PowerBoost 1000C 满足您所有的锂充电需求。

然而不幸的是，这个小东西虽然非常棒，但并不能输出足够的电力来运行Pi-Switch。但它的确是非常不错的充电电池，这个电池能为树莓派提供足够多的电量，使屏幕和音频供电大约2-3个小时。我会将电源保持开启，以便耗尽电池电量，这就意味着您需要直接插入电源。我仍在努力寻找更好的解决方案。

电源线：

首先看上图，你会注意到3个黑色圆圈和3个红色圆圈。

你猜到了！焊接3个25厘米的黑色导线和3个25厘米的红色导线到PowerBoost上标记的相应位置。

开关（电源开关，不是 Nintendo）：

将一根右边或左边的腿从开关上切下，然后用5厘米的电线焊接到残缺的电源开关的备用引脚上。

焊接其中一条电线，切换至PowerBoost，剩下的电线连接至PowerBoost板。

热熔胶便宜，快捷，简单。我建议将连接到Power Boosted Board的每根电线上涂上热熔胶。

第4步：扬声器和音频板以及耳机插孔（将它们连接在一起）

这一步我们将这些组件组合在一起。

焊接扬声器：

如图所示，将每一根导线焊接到扬声器上的每个垫上。热收缩太方便了，如果你像我一样喜欢使用热熔胶！

焊接音频板：

拿起你的PAM8302，看看它的说明。如图所示，在电路板4-8欧姆的一侧，将扬声器电线焊接到两个中心垫上。

焊接音频的电源：

从PowerBoost板上取下其中一根红色电源线和一块接地板，并将红色电线焊接到PAM8302上的vin上，将黑色电线焊接到PAM8302上的gnd上。

焊接耳机至PAM8302：

从耳机插孔取出红线，并将其焊接到PAM8302的A+上。

从耳机插孔取出黑色线，并将其焊接到PAM8302的A-上。

焊接树莓派：

这有一张树莓派的图片。从PowerBoost上取出一根黑线将其焊接到树莓派图片上的黑点。

从PowerBoost上取出一根红线将其焊接到树莓派图片上的红点。

测试：

请小心确保剩余的黑线来自PowerBoost，和来自PowerBoost的红线不会触及任何东西。然后装上电池并翻转开关。如果所有部件都正确连接，则应在充电板上的指示灯上点亮指示灯，如果扬声器噪音太大，可能会听到扬声器发出轻微的嗡嗡声，以至于可能出现焊接问题。

第5步：组装

除了LCD和可选的PI相机之外，我们现在应该已经安装了所有东西。在之前的图片中，你会看到如何嵌入树莓派本身。这非常简单，现在你可以拿出那个80件什锦笔记本更换螺丝套件，找到一些比树莓派厚一到两毫米的螺丝，然后将它们拧入软印刷塑料中。推荐使用PLA。应该有两个合适的夹子来安置树莓派，并且在相反的角落有可以穿线的孔。电源板也是如此。上面的图片展示了电源板的组装。

现在将开关穿过电源板上方的小孔。用镊子或手指从外面抓住开关。如图所示，轻轻地拉开开关以防止其掉入箱内，在开关背面放置一些热熔胶。一旦胶水冷却，请检查开关是否便于使用。如果粘胶不好，请再试一次。在树莓派和PowerBoost之间钻一个3/16英寸的孔，也可以只是钻出一个孔。它应该在树莓派的usb端口的一侧。将耳机插孔穿入孔中并粘合到位。

最后，将扬声器电池和音频板粘合到位，如上图所示。我将扬声器放在电池下面的塑料下面，我把它直接塞在PowerBoost板后面。然后，我将电池粘在3D打印机箱的两侧。最后，我把扬声器放大器粘在电池的顶部。

所以，如果你已经做好了这一切，那么你现在应该已经将树莓派、PowerBoost、PAM8302、扬声器、电源开关和电池都安装在树莓派盒的背面。另外应该还有一个25厘米的黑线和一个25厘米的红线留下。

第6步：添加屏幕和配件

你几乎已经完成了这个相当复杂的组装。现在拿出一些6毫米长的螺丝和螺纹侧杆， 如上图所示，将它们拧入屏幕上的螺丝孔。如果屏幕不是连成一排的，为了更适合使用，可能会需要颠倒过来。看看图片，你可能会注意到我的成型线连接到了我的屏幕上。实际上，我将pin header放在我的PowerBoost上，而不是直接焊接。如果你没有提前看这些步骤的话，你可能正在焊接电线。如果我不特意提醒的话。我更喜欢pin header，因为它可以迅速、简单的修改，而我的创作始终处于不断变化的状态。

使用剩余的电线：

将剩余的红线从PowerBoost焊接到屏幕上的vin引脚。

将剩余的黑线从PowerBoost焊接到屏幕上的gnd引脚。

连接相机（可选）：

将相机电缆插入相机板。

如图所示将电缆插入树莓派中。

通过以太网插孔翻转相机。

使电缆平整并粘合到位。

附加屏幕宽带线：

如图所示将带状电缆插入树莓派。

如果您看上图，它会显示我在连接带状电缆后如何将背面板向下翻转到位。

最后，将后面板上的四颗螺丝拧入屏幕背面的支架中，然后完全组装。

第7步：制作树莓派软件镜像

步骤 1）

给树莓派接上键盘，通电。

转到此网站并按照安装步骤操作：（仅将您的键盘设置为临时控制器）

https://github.com/RetroPie/RetroPie-Setup/wiki/First-Installation

步骤 2）

您可能会听到恼人的嗡嗡声（现在可以忽略，我们很快就会修复）

按照以下步骤通过ReroPie菜单设置wifi：

RetroPie / settings> raspi-config> interfacing options >SSH > Yes > Ok > Finish > Retropie Setup > Configuration Tools > wifi>（设置你的wifi）> exit>

步骤 3）

安装 Pixel：

raspbiantools > Install Pixel Desktop Environment > yes > (等一会) > ok (to flash player) > (稍等时间久一点) > ok > cancel > back >

步骤 4）

安装 Kodi：

Manage Packages > Manage Optional Packages > Kodi > Install from binary > (wait a while) > back > back > back>

步骤 5）

注册并连接您的 JoyCons 手柄：

Configuration /Tools > bluetooth > Register and Connect (同时按下右侧joy-con上L和R之间的小按钮) > choose Joy-Con (R) > NoInputNoOutput > (wait) > ok > ok

步骤 6）

用Joy-Con（L）重复步骤5。

步骤 7）

cancel > back > exit > (start button) > quit > quit emulation station> yes

步骤 8）

运行以下命令：

sudo apt-get update && sudo apt-get upgrade && sudo rpi-update sudo reboot

步骤 9）

输入以下内容：

wget https://raw.githubusercontent.com/cfoote7/PiSwitch/master/setup.sh sudo chmod 777 setup.sh && sudo chmod a+x setup.sh ./setup.sh

更新：

我已经添加了一个控制器连接菜单，屏幕上会显示是否连接到两个joy-cons。还增加了单人/双人玩家模式选择菜单。在完成第一boot时，你将可以用“+”和“-”按钮连接你的控制器，点击下一步，点击RetroPie，然后选择单人玩家模式。

备注：

pywx.py 是我的触摸屏启动的选择菜单，实际上它并不是启动选项，所有这些选项都储存在raspbian jessie下。我计划添加一个更简单的方式将控制器在启动时与此菜单配对。请您随时查看更新信息。如果您进行了任何改进，请特别注意是否可以构建此功能并告知我。我非常乐意为此提供合作服务。请检查我的存储库，我会更新在 https://github.com/cfoote7/PiSwitch

via Cherry 译。

本文介绍了如何在树莓派上，使用 OpenCV 和 Python 完成人脸检测项目。该项目不仅描述了识别人脸所需要的具体步骤，同时还提供了很多扩展知识。此外，该项目并不需要读者了解详细的人脸识别理论知识，因此初学者也能轻松跟着步骤实现。

项目所需设备

硬件：

树莓派3

树莓派摄像头模块（PiCam）

语言和库：

OpenCV

Python 3

本文主要讲述如何使用 PiCam 实现实时人脸识别，如下图所示：

本教程使用 OpenCV 完成，一个神奇的「开源计算机视觉库」，并主要关注树莓派（因此，操作系统是树莓派系统）和 Python，但是我也在 Mac 电脑上测试了代码，同样运行很好。OpenCV 具备很强的计算效率，且专门用于实时应用。因此，它非常适合使用摄像头的实时人脸识别。要创建完整的人脸识别项目，我们必须完成3个阶段：

1）人脸检测和数据收集；

2）训练识别器；

3）人脸识别。

如下图所示：

第1步：材料清单

主件：

树莓派3

500 万像素 1080p 传感器 OV5647 迷你摄像头模块

第2步：安装OpenCV 3包

我使用的是更新了最新版树莓派系统（Stretch）的树莓派 V3，因此安装 OpenCV 的最佳方式是按照 Adrian Rosebrock 写的教程来进行：《Raspbian Stretch: Install OpenCV 3 + Python on your Raspberry Pi》。经过几次尝试后，我觉得Adrian的教程最好，建议按照该教程一步步来安装。

完成上述教程之后，你应该安装好了 OpenCV 虚拟环境，可用于在树莓派设备上运行本次实验。

我们来到虚拟环境，确认 OpenCV 3 已经正确安装。

Adrian 推荐在每次打开新的终端时都运行命令行「source」，以确保系统变量都得到正确设置。

source ~/.profile

然后，我们进入虚拟环境：

workon cv

如果你看到 (cv) 出现在提示符之前，那么你就进入了 cv 虚拟环境：

(cv) pi@raspberry:~$

Adrian 希望大家注意 cv Python 虚拟环境是完全独立的，且与 Raspbian Stretch 中包含的默认 Python 版本彼此隔绝。因此，全局站点包目录中的任意 Python 包对于 cv 虚拟环境而言都是不可用的。类似地，cv 站点包中的任意 Python 包对于全局 Python 包安装也都是不可用的。

现在，进入 Python 解释器：

python

确认你正在运行3.5（或以上）版本。

在解释器内部（将出现>>>），导入 OpenCV 库：

import cv2

如果没有错误信息，则 OpenCV 已在你的 Python 虚拟环境中正确安装。

你还可以检查已安装的 OpenCV 版本：

cv2.__version__

将会出现3.3.0（或未来有可能发布更高版本）。

上面的终端截图显示了以上步骤。

第3步：测试摄像头

在树莓派上安装 OpenCV 之后，我们测试一下，以确认摄像头正常运转。假设你已经在树莓派上安装了 PiCam。

在 IDE 中输入下列 Python 代码：

import numpy as np import cv2 cap = cv2.VideoCapture(0) cap.set(3,640) # set Width cap.set(4,480) # set Height while(True): ret, frame = cap.read() frame = cv2.flip(frame, -1) # Flip camera vertically gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) cv2.imshow(‘frame’, frame) cv2.imshow(‘gray’, gray) k = cv2.waitKey(30) & 0xff if k == 27: # press ‘ESC’ to quit break cap.release() cv2.destroyAllWindows()

上面的代码可捕捉PiCam生成的视频流，用BGR颜色和灰色模式展示。

注意：我按照组装方式垂直旋转了摄像头。如果你的情况并非如此，那么注释或删除「flip」命令行。

你还可以从我的 GitHub 下载代码：https://github.com/Mjrovai/OpenCV-Object-Face-Tracking/blob/master/simpleCamTest.py

输入下面的命令行，开始执行：

python simpleCamTest.py

要完成该程序，你必须在键盘上按 [ESC] 键。在按 [ESC] 键之前，先鼠标点击视频窗口。

上图展示了结果。

想更多地了解 OpenCV，请查看该教程：https://pythonprogramming.net/loading-video-python-opencv-tutorial/

第4步：人脸检测

人脸识别的最基础任务是「人脸检测」。你必须首先「捕捉」人脸（第 1 阶段）才能在未来与捕捉到的新人脸对比时（第 3 阶段）识别它。

最常见的人脸检测方式是使用「Haar 级联分类器」。使用基于 Haar 特征的级联分类器的目标检测是 Paul Viola 和 Michael Jones 2001 年在论文《Rapid Object Detection using a Boosted Cascade of Simple Features》中提出的一种高效目标检测方法。这种机器学习方法基于大量正面、负面图像训练级联函数，然后用于检测其他图像中的对象。这里，我们将用它进行人脸识别。最初，该算法需要大量正类图像（人脸图像）和负类图像（不带人脸的图像）来训练分类器。然后我们需要从中提取特征。好消息是 OpenCV 具备训练器和检测器。如果你想要训练自己的对象分类器，如汽车、飞机等，你可以使用 OpenCV 创建一个。

详情参见：Cascade Classifier Training

如果不想创建自己的分类器，OpenCV 也包含很多预训练分类器，可用于人脸、眼睛、笑容等的检测。相关的 XML 文件可从该目录下载：haarcascades

下面，我们就开始用 OpenCV 创建人脸检测器吧！

从我的 GitHub 下载文件 faceDetection.py：faceDetection.py

import numpy as np import cv2 faceCascade = cv2.CascadeClassifier(‘Cascades/haarcascade_frontalface_default.xml’) cap = cv2.VideoCapture(0) cap.set(3,640) # set Width cap.set(4,480) # set Height while True: ret, img = cap.read() img = cv2.flip(img, -1) gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) faces = faceCascade.detectMultiScale( gray, scaleFactor=1.2, minNeighbors=5, minSize=(20, 20) ) for (x,y,w,h) in faces: cv2.rectangle(img,(x,y),(x+w,y+h),(255,0,0),2) roi_gray = gray[y:y+h, x:x+w] roi_color = img[y:y+h, x:x+w] cv2.imshow(‘video’,img) k = cv2.waitKey(30) & 0xff if k == 27: # press ‘ESC’ to quit break cap.release() cv2.destroyAllWindows()

使用 Python 和 OpenCV 执行人脸检测，上面的几行代码就足够了。注意下面的代码：

faceCascade = cv2.CascadeClassifier(‘Cascades/haarcascade_frontalface_default.xml’)

这行代码可以加载「分类器」（必须在项目文件夹下面的 Cascades/目录中）。然后，我们在在循环内部调用摄像头，并以 grayscale 模式加载我们的输入视频。现在，我们必须调用分类器函数，向其输入一些非常重要的参数，如比例因子、邻近数和人脸检测的最小尺寸。

faces = faceCascade.detectMultiScale( gray, scaleFactor=1.2, minNeighbors=5, minSize=(20, 20) )

其中：

gray 表示输入 grayscale 图像。

scaleFactor 表示每个图像缩减的比例大小。

minNeighbors 表示每个备选矩形框具备的邻近数量。数字越大，假正类越少。

minSize 表示人脸识别的最小矩形大小。

该函数将检测图像中的人脸。接下来，我们必须「标记」图像中的人脸，比如，用蓝色矩形。使用下列代码完成这一步：

for (x,y,w,h) in faces: cv2.rectangle(img,(x,y),(x+w,y+h),(255,0,0),2) roi_gray = gray[y:y+h, x:x+w] roi_color = img[y:y+h, x:x+w]

如果已经标记好人脸，则函数将检测到的人脸的位置返回为一个矩形，左上角 (x,y)，w 表示宽度，h 表示高度 ==> (x,y,w,h)。详见下图。

得到这些位置信息后，我们可以为人脸创建一个「感兴趣区域」（绘制矩形），用 imshow() 函数呈现结果。使用树莓派终端，在你的 Python 环境中运行上面的 Python 脚本：

python faceDetection.py

你也可以加入诸如「眼睛检测」甚至「微笑检测」这样的检测器。在那些用例中，你需要把分类器函数和矩形框内加入原有的面部识别区域中，因为在区域外进行识别没有意义。

注意，在树莓派上，分类方法（HaarCascades）会消耗大量算力，所以在同一代码中使用多个分类器将会显著减慢处理速度。在台式机上运行这些算法则非常容易。

在我的 GitHub上你可以看到其他的例子：

faceEyeDetection.py

faceSmileDetection.py

faceSmileEyeDetection.py

在下图中，你可以看到我们的结果：

要想深入理解面部识别，可以参考这一教程：Haar Cascade Object Detection Face & Eye OpenCV Python Tutorial

第5步：收集数据

我推荐各位读者可以查看以下两个关于人脸识别的教程：

使用 OpenCV 和 Python 从头实现人脸识别：superdatascience.com

理解人脸识别：thecodacus.com

现在，我们项目的第一步是创建一个简单的数据集，该数据集将储存每张人脸的 ID 和一组用于人脸检测的灰度图。

因此，以下命令行将为我们的项目创建一个目录，目录名可以如以下为 FacialRecognitionProject 或其它：

mkdir FacialRecognitionProject

在该目录中，除了我们为项目创建的 3 个 Python 脚本外，我们还需要储存人脸分类器。我们可以从 GitHub 中下载：haarcascade_frontalface_default.xml

下一步需要创建一个子目录「dtatset」，并用它来储存人脸样本：

mkdir dataset

然后从我的 GitHub 中下载代码 01_face_dataset.py。

import cv2 import os cam = cv2.VideoCapture(0) cam.set(3, 640) # set video width cam.set(4, 480) # set video height face_detector = cv2.CascadeClassifier(‘haarcascade_frontalface_default.xml’) # For each person, enter one numeric face id face_id = input(‘

enter user id end press ==> ‘) print(”

[INFO] Initializing face capture. Look the camera and wait …”) # Initialize individual sampling face count count = 0 while(True): ret, img = cam.read() img = cv2.flip(img, -1) # flip video image vertically gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) faces = face_detector.detectMultiScale(gray, 1.3, 5) for (x,y,w,h) in faces: cv2.rectangle(img, (x,y), (x+w,y+h), (255,0,0), 2) count += 1 # Save the captured image into the datasets folder cv2.imwrite(“dataset/User.” + str(face_id) + ‘.’ + str(count) + “.jpg”, gray[y:y+h,x:x+w]) cv2.imshow(‘image’, img) k = cv2.waitKey(100) & 0xff # Press ‘ESC’ for exiting video if k == 27: break elif count >= 30: # Take 30 face sample and stop video break # Do a bit of cleanup print(”

[INFO] Exiting Program and cleanup stuff”) cam.release() cv2.destroyAllWindows()

上述的代码和人脸识别的代码非常像，我们只是添加了一个「input command」来捕捉用户 ID（整数）。

face_id = input(‘

enter user id end press ==> ‘)

对于每一个捕捉的帧，我们应该在「dataset」目录中保存为文档：

cv2.imwrite(“dataset/User.” + str(face_id) + ‘.’ + str(count) + “.jpg”, gray[y:y+h,x:x+w])

对于保存上述文件，我们需要导入「os」库，每一个文件的名字都服从以下结构：

User.face_id.count.jpg

例如，对于 face_id = 1 的用户，dataset/ 目录下的第四个样本文件名可能为：

User.1.4.jpg

在我的树莓派中，该图像可以打开为：

在我的代码中，我从每一个 ID 捕捉 30 个样本，我们能在最后一个条件语句中修改抽取的样本数。如果我们希望识别新的用户或修改已存在用户的相片，我们就必须以上脚本。

第六步：训练

在第二阶段中，我们需要从数据集中抽取所有的用户数据，并训练 OpenCV 识别器，这一过程可由特定的 OpenCV 函数直接完成。这一步将在「trainer/」目录中保存为.yml 文件。

所以，下面开始创建子目录以储存训练数据：

mkdir trainer

从我的 GitHub 中下载第二个 Python 脚本：02_face_training.py。

import numpy as np from PIL import Image import os # Path for face image database path = ‘dataset’ recognizer = cv2.face.LBPHFaceRecognizer_create() detector = cv2.CascadeClassifier(“haarcascade_frontalface_default.xml”); # function to get the images and label data def getImagesAndLabels(path): imagePaths = [os.path.join(path,f) for f in os.listdir(path)] faceSamples=[] ids = [] for imagePath in imagePaths: PIL_img = Image.open(imagePath).convert(‘L’) # convert it to grayscale img_numpy = np.array(PIL_img,’uint8′) id = int(os.path.split(imagePath)[-1].split(“.”)[1]) faces = detector.detectMultiScale(img_numpy) for (x,y,w,h) in faces: faceSamples.append(img_numpy[y:y+h,x:x+w]) ids.append(id) return faceSamples,ids print (”

[INFO] Training faces. It will take a few seconds. Wait …”) faces,ids = getImagesAndLabels(path) recognizer.train(faces, np.array(ids)) # Save the model into trainer/trainer.yml recognizer.write(‘trainer/trainer.yml’) # recognizer.save() worked on Mac, but not on Pi # Print the numer of faces trained and end program print(”

[INFO] {0} faces trained. Exiting Program”.format(len(np.unique(ids))))

确定在 Rpi 中已经安装了 PIL 库，如果没有的话，在终端运行以下命令：

pip install pillow

我们将使用 LBPH（LOCAL BINARY PATTERNS HISTOGRAMS）人脸识别器，它由 OpenCV 提供：

recognizer = cv2.face.LBPHFaceRecognizer_create()

函数「getImagesAndLabels (path)」将抽取所有在目录「dataset/」中的照片，并返回 2 个数组：「Ids」和「faces」。通过将这些数组作为输入，我们就可以训练识别器。

recognizer.train(faces, ids)

在训练过后，文件「trainer.yml」将保存在我们前面定义的 trainer 目录下。此外，我们还在最后使用了 print 函数以确认已经训练的用户面部数量。

第7步：识别器

这是该项目的最后阶段。这里，我们将通过摄像头捕捉一个新人脸，如果这个人的面孔之前被捕捉和训练过，我们的识别器将会返回其预测的 id 和索引，并展示识别器对于该判断有多大的信心。

让我们从 GitHub 03_face_recognition.py 上下载第三阶段的 python 脚本。

import cv2 import numpy as np import os recognizer = cv2.face.LBPHFaceRecognizer_create() recognizer.read(‘trainer/trainer.yml’) cascadePath = “haarcascade_frontalface_default.xml” faceCascade = cv2.CascadeClassifier(cascadePath); font = cv2.FONT_HERSHEY_SIMPLEX #iniciate id counter id = 0 # names related to ids: example ==> Marcelo: id=1, etc names = [‘None’, ‘Marcelo’, ‘Paula’, ‘Ilza’, ‘Z’, ‘W’] # Initialize and start realtime video capture cam = cv2.VideoCapture(0) cam.set(3, 640) # set video widht cam.set(4, 480) # set video height # Define min window size to be recognized as a face minW = 0.1*cam.get(3) minH = 0.1*cam.get(4) while True: ret, img =cam.read() img = cv2.flip(img, -1) # Flip vertically gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY) faces = faceCascade.detectMultiScale( gray, scaleFactor = 1.2, minNeighbors = 5, minSize = (int(minW), int(minH)), ) for(x,y,w,h) in faces: cv2.rectangle(img, (x,y), (x+w,y+h), (0,255,0), 2) id, confidence = recognizer.predict(gray[y:y+h,x:x+w]) # Check if confidence is less them 100 ==> “0” is perfect match if (confidence < 100): id = names[id] confidence = " {0}%".format(round(100 - confidence)) else: id = "unknown" confidence = " {0}%".format(round(100 - confidence)) cv2.putText(img, str(id), (x+5,y-5), font, 1, (255,255,255), 2) cv2.putText(img, str(confidence), (x+5,y+h-5), font, 1, (255,255,0), 1) cv2.imshow('camera',img) k = cv2.waitKey(10) & 0xff # Press 'ESC' for exiting video if k == 27: break # Do a bit of cleanup print(" [INFO] Exiting Program and cleanup stuff") cam.release() cv2.destroyAllWindows() 这里我们包含了一个新数组，因此我们将会展示「名称」，而不是编号的 id： names = ['None', 'Marcelo', 'Paula', 'Ilza', 'Z', 'W'] 所以，如上所示的列表，Marcelo 的 ID 或索引为 1，Paula 的 ID 等于 2。 下一步，我们将检测一张人脸，正如我们在之前的 haasCascade 分类器中所做的那样。 id, confidence = recognizer.predict(gray portion of the face) recognizer.predict () 将把待分析人脸的已捕捉部分作为一个参数，并返回其可能的所有者，指示其 id 以及识别器与这一匹配相关的置信度。 注意，如果匹配是完美的，置信度指数将返回「零」。 最后，如果识别器可以预测人脸，我们将在图像上放置一个文本，带有可能的 id，以及匹配是否正确的概率（概率=100 – 置信度指数）。如果没有，则把「未知」的标签放在人脸上。 下面是这一结果的图片： 在这张图像上，我展示了一些由该项目完成的测试，其中我也使用图像验证识别器是否有效。 第 8 步：结语 我希望该项目能帮助其他人发现更好玩的项目，也希望有助于各位读者实现自己的人脸识别应用。 更多详细的代码请查看 GitHub 地址：https://github.com/Mjrovai/OpenCV-Face-Recognition （原文来自hackster，由机器之心编译）

不久之前，亚马逊刚刚推出了DeepLens。这是一款专门面向开发人员的全球首个支持深度学习的摄像机，它所使用的机器学习算法不仅可以检测物体活动和面部表情，而且还可以检测类似弹吉他等复杂的活动。虽然DeepLens还未正式上市，但智能摄像机的概念已经诞生了。

今天，我们将自己动手打造出一款基于深度学习的照相机，当小鸟出现在摄像头画面中时，它将能检测到小鸟并自动进行拍照。最终成品所拍摄的画面如下所示：

相机不傻，它可以很机智

我们不打算将一个深度学习模块整合到相机中，相反，我们准备将树莓派“挂钩”到摄像头上，然后通过WiFi来发送照片。本着“一切从简”（穷）为核心出发，我们今天只打算搞一个跟DeepLens类似的概念原型，感兴趣的同学可以自己动手尝试一下。

接下来，我们将使用Python编写一个Web服务器，树莓派将使用这个Web服务器来向计算机发送照片，或进行行为推断和图像检测。

我们这里所使用的计算机其处理能力会更强，它会使用一种名叫YOLO的神经网络架构来检测输入的图像画面，并判断小鸟是否出现在了摄像头画面内。

我们得先从YOLO架构开始，因为它是目前速度最快的检测模型之一。该模型专门给Tensorflow（谷歌基于DistBelief进行研发的第二代人工智能学习系统）留了一个接口，所以我们可以轻松地在不同的平台上安装和运行这个模型。友情提示，如果你使用的是我们本文所使用的迷你模型，你还可以用CPU来进行检测，而不只是依赖于价格昂贵的GPU。

接下来回到我们的概念原型上… 如果像框内检测到了小鸟，那我们就保存图片并进行下一步分析。

检测与拍照

正如我们所说的，DeepLens的拍照功能是整合在计算机里的，所以它可以直接使用板载计算能力来进行基准检测，并确定图像是否符合我们的标准。

但是像树莓派这样的东西，我们其实并不需要使用它的计算能力来进行实时计算。因此，我们准备使用另一台计算机来推断出现在图像中的内容。

我使用的是一台简单的Linux计算机，它带有一个摄像头以及WiFi无线网卡（树莓派3+摄像头），而这个简单的设备将作为我的深度学习机器并进行图像推断。对我来说，这是目前最理想的解决方案了，这不仅大大缩减了我的成本，而且还可以让我在台式机上完成所有的计算。

当然了，如果你不想使用树莓派视频照相机的话，你也可以选择在树莓派上安装OpenCV 3来作为方案B，具体的安装方法请参考【这份文档】。友情提示，安装过程可谓是非常的麻烦！

接下来，我们需要使用Flask来搭建Web服务器，这样我们就可以从摄像头那里获取图像了。这里我使用了MiguelGrinberg所开发的网络摄像头服务器代码（Flask视频流框架），并创建了一个简单的jpg终端：

#!/usr/bin/envpython from import lib import import_module import os from flask import Flask, render_template, Response #uncomment below to use Raspberry Pi camera instead #from camera_pi import Camera #comment this out if you’re not using USB webcam from camera_opencv import Camera app =Flask(__name__) @app.route(‘/’) def index(): return “hello world!” def gen2(camera): “””Returns a single imageframe””” frame = camera.get_frame() yield frame @app.route(‘/image.jpg’) def image(): “””Returns a single currentimage for the webcam””” return Response(gen2(Camera()),mimetype=’image/jpeg’) if __name__ == ‘__main__’: app.run(host=’0.0.0.0′, threaded=True)

如果你使用的是树莓派视频照相机，请确保没有注释掉上述代码中from camera_pi那一行，然后注释掉from camera_opencv那一行。

你可以直接使用命令python3 app.py或gunicorn来运行服务器，这跟Miguel在文档中写的方法是一样的。如果我们使用了多台计算机来进行图像推断的话，我们还可以利用Miguel所开发的摄像头管理方案来管理摄像头以及计算线程。

当我们启动了树莓派之后，首先需要根据IP地址来判断服务器是否正常工作，然后尝试通过Web浏览器来访问服务器。

URL地址格式类似如下：

http://192.168.1.4:5000/image.jpg

在树莓派中加载Web页面及图像来确定服务器是否正常工作：

图像导入及推断

既然我们已经设置好了终端来加载摄像头当前的图像内容，我们就可以构建一个脚本来捕捉图像并推断图像中的内容了。

这里我们需要用到request库（一个优秀的Python库，用于从URL地址获取文件资源）以及Darkflow（YOLO模型基于Tensorflow的实现）。

不幸的是，我们没办法使用pip之类的方法来安装Darkflow，所以我们需要克隆整个代码库，然后自己动手完成项目的构建和安装。安装好Darkflow项目之后，我们还需要下载一个YOLO模型。

因为我使用的是速度比较慢的计算机和板载CPU（而不是速度较快的GPU），所以我选择使用YOLO v2迷你网络。当然了，它的功能肯定没有完整的YOLO v2模型的推断准确性高啦！

配置完成之后，我们还需要在计算机中安装Pillow、numpy和OpenCV。最后，我们就可以彻底完成我们的代码，并进行图像检测了。

最终的代码如下所示：

from darkflow.net.build import TFNet import cv2 from io import BytesIO import time import requests from PIL import Image import numpy as np options= {“model”: “cfg/tiny-yolo-voc.cfg”, “load”:”bin/tiny-yolo-voc.weights”, “threshold”: 0.1} tfnet= TFNet(options) birdsSeen= 0 def handleBird(): pass whileTrue: r =requests.get(‘http://192.168.1.11:5000/image.jpg’) # a bird yo curr_img = Image.open(BytesIO(r.content)) curr_img_cv2 =cv2.cvtColor(np.array(curr_img), cv2.COLOR_RGB2BGR) result = tfnet.return_predict(curr_img_cv2) print(result) for detection in result: if detection[‘label’] == ‘bird’: print(“bird detected”) birdsSeen += 1 curr_img.save(‘birds/%i.jpg’ %birdsSeen) print(‘running again’) time.sleep(4)

此时，我们不仅可以在命令控制台中查看到树莓派所检测到的内容，而且我们还可以直接在硬盘中查看保存下来的小鸟照片。接下来，我们就可以使用YOLO来标记图片中的小鸟了。

假阳性跟假阴性之间的平衡

我们在代码的options字典中设置了一个threshold键，这个阈值代表的是我们用于检测图像的某种成功率。在测试过程中，我们将其设为了0.1，但是如此低的阈值会给我们带来是更高的假阳性以及误报率。更糟的是，我们所使用的迷你YOLO模型准确率跟完整的YOLO模型相比，差得太多了，但这也是需要考虑的一个平衡因素。

降低阈值意味着我们可以得到更多的模型输出（照片），在我的测试环境中，我阈值设置的比较低，因为我想得到更多的小鸟照片，不过大家可以根据自己的需要来调整阈值参数。

代码开源

跟之前一样，我已经将所有的代码上传到GitHub上了，感兴趣的同学可以自行下载安装【GitHub传送门】。

* 参考来源：makeartwithpython，FB 小编 Alpha_h4ck 编译，转自 FreeBuf.COM

原文作者：Eben Upton。参与：路雪、黄小天、李泽南

过去几天，对 Meltdown 和 Spectre 安全漏洞的讨论甚嚣尘上。该漏洞影响了所有的现代英特尔处理器，Spectre 还影响了 AMD 处理器和 ARM 内核。Spectre 漏洞使得攻击者可以绕过软件检查读取当前地址空间中的任意位置数据；Meltdown 漏洞使得攻击者可以读取操作系统核地址空间的任意位置数据（用户程序通常不可访问该数据）。这两种漏洞皆通过边信道攻击（side-channel attack）利用很多现代处理器都有的性能特征（缓存和推测执行）泄漏数据。近日，树莓派创始人 Eben Upton 称树莓派不受这些漏洞的影响，并撰文详解其原因。

谷歌 Project Zero 团队发现的漏洞分别被称为「Meltdown」和「Specter」。这些漏洞允许恶意程序从其它程序的内存中窃取信息，这意味着恶意程序可以监听密码、账户信息、密钥及理论上存储在进程中的任何内容。

其中，「Meltdown」影响英特尔处理器，它打破了用户应用程序和操作系统之间最基本的隔离。这种攻击允许程序访问其它程序和操作系统的内存，这可能导致数据泄露。而「Spectre」除了能影响英特尔处理器外，还能影响 AMD 与 ARM 架构的大量处理器，这意味着除服务器与个人电脑以外，智能手机等终端设备也会受到影响，几乎所有现代计算机处理器均无法幸免。它打破了不同应用程序之间的隔离，这意味着，攻击者可以使用恶意程序来获取被隔离的私有数据。

英特尔近日表示，在未来数周内将有软件补丁发布。尽管大多数 PC 用户不会受到影响，但安全补丁会导致处理器 0-30% 的运算速度下降。

根据Eben Upton所述，大量类似树莓派的廉价计算设备可能同样也不会受到两种安全漏洞的影响，包括很多低端安卓手机。

本文介绍现代处理器设计的一些概念，使用简单的 Python 程序解释这些概念，比如：

t = a+b u = c+d v = e+f w = v+g x = h+i y = j+k

尽管你的计算机处理器不会直接执行 Python，但这里的语句足够简单，大致相当于简单的机器指令。本文不详述过多处理器设计中的重要细节（主要是 pipelining 和寄存器重命名），它们对理解 Spectre 和 Meltdown 的工作原理不太重要。

想全面了解处理器设计和现代计算机架构，可参阅 Hennessy 和 Patterson 的经典著作《Computer Architecture: A Quantitative Approach》。

什么是标量处理器？

最简单的现代处理器每次循环执行一个指令，我们称之为标量处理器。上述示例在标量处理器上需要执行六次循环。

树莓派 1 和树莓派 Zero 中使用的 Intel 486 和 ARM1176 都是标量处理器。

什么是超标量处理器？

很明显，加速标量处理器的方式就是提高其时钟频率（clock speed）。但是，我们很快就到达处理器内部逻辑门运行的极限；因此处理器设计人员开始寻找一次性处理多件事情的方式。

有序超标量处理器检查收到的大批指令，尝试在一个 pipeline 中一次性执行多个指令，这取决于指令之间的依赖关系。依赖关系很重要：你或许认为双向超标量处理器可以将 6 个指令配对执行，如下所示：

t, u = a+b, c+d v, w = e+f, v+g x, y = h+i, j+k

但是这没有作用：我们必须先计算 v 再计算 w，即第三个和第四个指令无法同时执行。双向超标量处理器实际上无法找到与第三个指令配对的指令，因此，该示例将执行四个循环：

t, u = a+b, c+d v = e+f # second pipe does nothing here w, x = v+g, h+i y = j+k

超标量处理器包括 Intel Pentium 以及树莓派 2 和树莓派 3 分别使用的 ARM Cortex-A7 和 Cortex-A53。树莓派 3 的时钟频率只比树莓派 2 高 33%，但性能大约是后者的 2 倍：部分原因在于 Cortex-A53 超出 Cortex-A7 的对大量指令的配对执行能力。

什么是无序处理器（out-of-order processor）？

回到我们的示例，我们可以看到即使 v 和 w 之间存在依赖关系，我们也可以找到其他独立的指令填补第二次循环中空的 pipe。无序超标量处理器能够打乱指令的顺序（同样受限于指令之间的依赖关系）以保持每个 pipeline 都处于忙碌状态。

无序处理器可以有效交换 w 和 x 的顺序：

t = a+b u = c+d v = e+f x = h+i w = v+g y = j+k

允许执行三次循环：

t, u = a+b, c+d v, x = e+f, h+i w, y = v+g, j+k

无序处理器包括 Intel Pentium 2（以及大部分后续 Intel 和 AMD x86 处理器，除了一些 Atom 和 Quark 设备）和很多近期的 ARM 处理器，如 Cortex-A9、-A15、-A17、-A57。

什么是分支预测器（branch predictor）？

上述示例是直线式代码块。真正的程序不是这样的：他们还包括正向分支（用于实现条件运算，如 if 语句）、反向分支（用于实现 loop）。分支可能是无条件的（通常被采用），也可能是有条件的（是否采用取决于计算值）。

获取指令时，处理器可能遇到依赖于计算值的条件分支（而该值目前尚未计算出）。为了避免停顿，处理器必须猜测下一个要获取的指令：内存顺序（对应未采用分支）或分支目标（对应采用分支）上的下一个指令。分支预测器通过收集某一个分支之前被采用频率的相关统计数据，帮助处理器猜测该分支是否被采用。

现在分支预测器非常复杂，可以生成非常准确的预测。树莓派 3 的额外性能部分是由于 Cortex-A7 和 Cortex-A53 之间分支预测的改进。但是，攻击者也可以通过执行精心设计的一系列分支，误训练分支预测器作出较差的预测。

什么是推测？

重排序顺序指令（reordering sequential instruction）是一种恢复指令级别并行化的强大方法，但是由于处理器变得更宽（能够一次执行三个或四个指令），保证所有 pipeline 处于忙碌状态变得更难了。因此，现代处理器提高了推测能力。推测执行可以处理并不需要的指令：这样就可以保证 pipeline 处于忙碌状态，如果最后该指令没有被执行，我们只需要放弃结果就可以了。

推测执行不必要的指令（以及支持推测和重排序的基础架构）需要耗费大量能源，但是在很多情况下为了获取单线程性能的提升，这种方法是值得的。分支预测器用于选择通过程序最可能的路径，最大化推测获得收益的可能性。

为了展示推测的好处，我们可以看一下另一个示例：

t = a+b u = t+c v = u+d if v: w = e+f x = w+g y = x+h

现在，我们具备从 t 到 u 到 v、从 w 到 x 到 y 的依赖关系，那么没有推测的双向无序处理器无法填充第二个 pipeline。它用三次循环来计算 t、u 和 v，之后处理器知道 if 语句的主体是否被执行，然后用三次循环来计算 w、x 和 y。假设 if（由一个分支指令实现）使用了一次循环，那么该示例可以执行四次（v 是零）或七次循环（v 不是零）。如果分支预测器表明 if 语句的主体很可能被执行，那么推测可以有效打乱程序，如下：

t = a+b u = t+c v = u+d w_ = e+f x_ = w_+g y_ = x_+h if v: w, x, y = w_, x_, y_

因此现在我们有了额外的指令级别的并行来保持 pipeline 繁忙：

t, w_ = a+b, e+f u, x_ = t+c, w_+g v, y_ = u+d, x_+h if v: w, x, y = w_, x_, y_

循环计数在推测性无序处理器中变得不太明确，但是 w、x 和 y 的分支和条件更新（几乎）是空闲的，因此上述示例几近于执行三个循环。

什么是缓存？

在过去，处理器速度与内存访问速度成正比。我的 BBC Micro（2MHz 6502），可以每 2μs（微秒）执行一次指令，存储周期为 0.25μs。在接下来的 35 年中，处理器已经变的非常快，但是内存几乎没变化：树莓派 3 中的一个 Cortex-A53 可以每 0.5ns（纳秒）执行一次指令，但是可能需要 100ns 才能访问主存。

a = mem[0] b = mem[1]

需要 200ns。

但在实践中，程序倾向于以相对可预测的方式访问内存，同时展示时间局部性（如果我访问一个定位，我很可能很快再次访问它）和空间局部性（如果我访问一个定位，我很可能很快访问附近的位置）。缓存利用这些属性来降低访问内存的平均成本。

缓存是一个小的片上内存，接近于处理器，存储最近使用的位置（及其近邻）内容的副本，以便在随后的访问中可以快速获取。借助缓存，上述示例的执行将稍微超过 100ns：

a = mem[0] # 100ns delay, copies mem[0:15] into cache b = mem[1] # mem[1] is in the cache

从 Spectre 和 Meltdown 的角度来看，最重要的一点是你可以对内存访问的时间进行计时，你可以知道访问的地址是在缓存之中（短时）或者不在（长时）。

什么是边信道？

来自维基百科：

「边信道攻击是基于从密码系统的物理实现获得的信息的任何攻击，而不是算法中的蛮力或理论弱点（相较于密码分析学）。例如，定时信息、功耗、电磁泄漏甚至声音都可以提供额外的信息源，这些信息可被用来破解系统。」

Spectre 和 Meltdown 属于边信道攻击，通过定时来观察缓存中是否有另一个可访问的位置，以推断内存位置的内容，这些内容通常不应该被访问。

把它放在一起

现在让我们看看如何结合推测和缓存以允许类似 Meltdown 的攻击。考虑下面这个示例，它是一个有时读取所有非法（内核）地址的用户程序，并导致错误（崩溃）：

t = a+b u = t+c v = u+d if v: w = kern_mem[address] # if we get here, fault x = w&0x100 y = user_mem[x]

现在，假设我们可以训练分支预测器，使其相信 v 很可能是非零的，那么我们的无序双向超标量处理器就会混洗程序，像这样：

t, w_ = a+b, kern_mem[address] u, x_ = t+c, w_&0x100 v, y_ = u+d, user_mem[x_] if v: # fault w, x, y = w_, x_, y_ # we never get here

即使处理器总是推测性地读取内核地址，它必须推迟产生的错误，直到知道 v 是非零。从表面上看，这是安全的，因为：

v 是零，所以非法读取的结果不会被提交给 w

v 是非零，但在读取结果被提交给 w 之前发生了错误

然而，假设我们在执行代码之前刷新缓存，并排列 a、b、c、d 以使 v 实际上为零。现在第三个循环中的推测性读取为：

v, y_ = u+d, user_mem[x_]

其将依赖非法读取结果的第八位获取用户地址 0x000 或 0x100，并把地址及其近邻加载进缓存。由于 v 是零，推测性指令的结果将被摈弃，执行将继续。如果我们随后访问其中一个地址，就可以决定哪个地址在缓存之中。恭喜：你刚刚从内核地址空间读取了一个位！

真正的 Meltdown 实际上要比这更复杂（特别是，为了避免错误训练分支预测器，作者无条件地优先执行非法读取，并处理产生的异常），但原理是相同的。Spectre 使用相似方法来颠覆软件阵列边界检查。

结论

现代处理器竭尽全力保持抽象，从而成为直接访问内存的有序标量机器，而事实上，使用包括缓存、指令重排序和推测在内的大量技术来提供比简单处理器更高的性能有望成为现实。Meltdown 和 Spectre 就是当我们在抽象的语境中推理安全性，然后在抽象与现实之间遇到细微差别时会发生的事情的实例。

树莓派使用的 ARM1176、Cortex-A7 和 Cortex-A53 内核中推测的缺失使我们免于此类攻击。

译文出处。

Raspberry Pi（树莓派）是为学习计算机编程教育而设计，只有信用卡大小的微型电脑。自问世以来，受众多计算机发烧友和创客的追捧。从第一枚树莓派发布至今，已经有过10种不同的版本，其尺寸从存储棒大小的 Zero 系列、到 A+、再到信用卡大小的 Model B，可用于各类智能产品、可穿戴设备的 DIY。下面发一张树莓派至今（2019年）最完整的全家福，包括了不同的小版本，看看你拥有多少？

(点击查看大图)

再来看看不同版本的配置对比，内存从1代的256MB到最新的4代4GB。

(点击查看大图)

现行的版本代号：

代号 型号 版本 内存 生产工厂 900021 A+ 1.1 512MB Sony UK 900032 B+ 1.2 512MB Sony UK 900092 Zero 1.2 512MB Sony UK 900093 Zero 1.3 512MB Sony UK 9000c1 Zero W 1.1 512MB Sony UK 9020e0 3A+ 1.0 512MB Sony UK 920092 Zero 1.2 512MB Embest 920093 Zero 1.3 512MB Embest 900061 CM 1.1 512MB Sony UK a01040 2B 1.0 1GB Sony UK a01041 2B 1.1 1GB Sony UK a02082 3B 1.2 1GB Sony UK a020a0 CM3 1.0 1GB Sony UK a020d3 3B+ 1.3 1GB Sony UK a21041 2B 1.1 1GB Embest a22042 2B (with BCM2837) 1.2 1GB Embest a22082 3B 1.2 1GB Embest a220a0 CM3 1.0 1GB Embest a32082 3B 1.2 1GB Sony Japan a52082 3B 1.2 1GB Stadium a22083 3B 1.3 1GB Embest a02100 CM3+ 1.0 1GB Sony UK a03111 4B 1.1 1GB Sony UK b03111 4B 1.1 2GB Sony UK c03111 4B 1.1 4GB Sony UK

本文于 2019.6.30 更新。

OpenMediaVault，是一个开源的基于 Debian Linux 的下一代网络附加存储(NAS)解决方案。它包含众多服务，如 SSH、(S)FTP、SMB / CIFS、DAAP 媒体服务器、RSync、BitTorrent 客户机等。并具有通过插件可增强的模块化设计框架特性。其核心如下：

Debian Linux(Squeeze)系统(i386 or x64)

基于Web方式的系统管理

通过Debian软件包简单的系统升级

用户管理

计划任务

多语言支持（0.4.18版支持繁体中文）

基于DNS-SD(Apple’s protocol)的服务公告

插件系统

下面介绍如何在树莓派上安装配置 OpenMediaVault，方便快捷地搭建 NAS。

一.准备工作

1.树莓派1/2/3型 开发板（我用的是3B），适配的5V2A电源；

2.TF卡（不小于4G）,TF 读卡器，/boot (vfat)占55.95MB，OWN (ext4) 占3.18GB

3.一台PC，Windows系统。

4.一台显示器或都电视机，HDMI接口，HDMI线。（其实不用显示设备也是可以的，可以SSH在电脑端操作。

5.一块移动硬盘，最好再配个有源USB-Hub

6.TF镜像。找到对应Pi的型号的镜像，omv_2.2.5_rpi2_rpi3.img.gz 或 omv_2.0.15_rpi_rpi2.img.gz 。

下载地址：https://sourceforge.net/projects/openmediavault/files/Raspberry%20Pi%20images/

更新了下载地址（2020-05-17）：https://sourceforge.net/projects/openmediavault/files/OMV%205.x%20for%20Single%20Board%20Computers/

或者百度网盘（密码: t8gm）。

7.镜像读写工具 win32diskimager

8.磁盘分区工具 DiskGenius

9.远程SSH PuTTY

二.刷系统

1.解压 omv_2.2.5_rpi2_rpi3.img.gz 得到omv_2.2.5_rpi2_rpi3.img

2.用Win32DiskImager 把omv_2.2.5_rpi2_rpi3.img 镜像写入（Write）TF卡

三.开机测试

1.把刷好的TF插入树莓派，接好HDMI线到显示器，通电开机。第一次开机系统会自动运行脚本把TF卡未分配空间划分给第三分区。当出现”OMV login:” 说明OMV已经完全启动了。对应找到“My IP address is 192.168.xxx.xxx”记下。

2.登录WebUI：在PC端用浏览器（非IE内核，否则页面加载不正常。我用的360极速）打开刚才的IP地址192.168.xxx.xxx，会进WebUI，

选择语言：简体中文

用户名：admin

密 码：openmediavault

点击登录 按钮

3.修改端口，运行后会莫名的80端口无法访问，所以最好改成其它端口（我用82），改完点保存。应用完成生效。

4.修改时间。如果已经改完端口，这时刷新的面是不能正常访问的，要在IP后面加端口号（192.168.xxx.xxx:82)

时区-Asia/Shanghai （亚洲/上海，东八区和中国同时区就好），其他默认，保存->应用

5.登录SSH，打开 PuTTY ，输入IP，端口，点Open，在打开的命令行窗口提示下输入

用户：root

密码：openmediavault (输入时不会显示任何字符）

当出现root@OMV:~# 时说明登录成功，可以做任何你想得到的操作，前提是你会。不然就去打相关教程好了。

四.插件安装（略）

五.备份

做一个备份是好习惯，如果已经用漫长的时间做好基本设置，装好了各种所要用的插件后，在你做各种尝试性操作时，让系统崩溃，而又无从修复时，从备份还原，可以减少很多时间。

1.软关机。点完关机后10s左右，树莓派网卡的灯会熄掉，就说时已经关机了。软关机后，正常的树莓派是不能再次软开机的，只能重新通电的方式开机。

2.从树莓派上取下TF卡，用读卡器连接电脑，打开Win32DiskImager，在Image File 里选择一个位置，并输入文件名.img（xxx.img），在Device选择TF卡的盘符，点 Read，等待Successful（成功）。将备份好的IMG保存好，在需要还原时，参考 “二.刷系统” 操作。

六.挂载移动硬盘

OMV不支持EXT2，3，extFat，所以最好用ext4或NTFS，如果用Fat32可能会在设置权限时出错。

1.格式化移动硬盘。如果用NTFS或Fat，并且硬盘已经是这种分区格式，直接USB连到树莓派上即可。

NTFS/Fat： WinXP/Win7、8、10系统，我的电脑–管理–磁盘管理–建立分区–格式化 ext4：Win系统不能直接格式化，DiskGenius也只能格成ext2。有谁会用DG格ext4请授教。

PuTTY 远程： 对硬盘分区 fdisk /dev/sda

要把分区格式化成Linux Ext4格式，用： mkfs.ext4 /dev/sda? 要把分区格式化成FAT32格式，用： mkfs.vfat -F 32 /dev/sda?

要把分区格式化成NTFS 格式，用： mkfs.ntfs /dev/sda? —————–sda? 里的“？”是对应分区编号。

如果要用一块硬盘挂载几种不同格的分区，建议先在PC端分成可识别的几种分区，再到SSH，对所需要的分区 格成ext4格式。

如果在WebUI–磁盘管理–擦除，会抹去整张硬盘数据，重新分成并格式化为ext4的一个分区。谨慎操作！！

2.挂载分区

如果硬盘已经正常连接，会在WebUI–磁盘管理–看到对应的硬盘。

点开WebUI–文件系统，分区会自动挂载，如果没有，就选定分区，手动点挂载。

最后，开始使用你的 OpenMediaVault 吧。

本文来自 噪音爵士 的推荐，原文。

本文和测试数据来自 chainsx 的推荐。为了避免标题党嫌疑，把原文标题中的倍数略去了，但从数据上看确实有很大幅度提升，最高指标超官方系统60倍。

为了证明树莓派3与ubuntu-17.04的arm64系统更搭配，我用ubuntu64-rpi里的基于f2fs文件系统的ubuntu-17.04-arm64进行了系统评测。

在树莓派实验室里有一篇《树莓派64位系统Debian 9先行测评：性能最高提升30倍！》，可是，他是使用的预览版debian9进行评测，我这里使用的是ubuntu-17.04-arm64，可以说，这次评测是一次相当成功的评测，评测数据可以在ubuntu64-rpi项目主页内找到，这里，也会附出。

关于F2FS文件系统我也不再介绍，在《树莓派64位系统Debian 9先行测评：性能最高提升30倍！》里也已介绍，

硬件测试环境：

RaspberryPi 3 Model B

16GB Class 10 TF卡

5v 2.5A电源

以太网网线及能连外网路由设备

软件测试环境：

ubuntu64-rpi（使用ubuntu-17.04-arm64 非移植版，由源码构建）

sysbench 压力测试软件

这里，为了确保可比较性，我使用的评测工具和《树莓派64位系统Debian 9先行测评：性能最高提升30倍！》里一样

sudo apt-get update && sudo apt-get –y install sysbench htop iperf3

测评结果点击这里查看（直接保存的ssh记录，如有疑问请自测，系统已放出）

总结一下：

cpu单线程:12.4798

cpu4线程:31.1217

cpu8线程 31.0916

八线程测试共享线程锁 14.9217

连续读写 0.3604

随机文件读写 0.5636

互斥锁测试 0.0184

内存连续测试 1.2890

内存随机测试 0.9564

这里，使用《树莓派64位系统Debian 9先行测评：性能最高提升30倍！》里提供的raspbian的数据进行比较（由于我目前没有过多时间来进行对最新版raspbian的评测，这里直接引用该文章提供的数据，这里，感谢该文章作者提供的数据。）

测试项目 Raspbian2017-03-03 ubuntu-17.04-arm64(ubuntu64-rpi) 提升倍数 系统信息 Arm 32bit/ext4文件系统 Arm64bit/f2fs文件系统 见文件系统测试 CPU单线程 367.2971 12.4798 29倍 四线程 1017.6742 31.1217 31倍 八线程 1920.0601 31.0916 62倍 内存随机 5.7678 0.9564 6倍 内存连续 6.3309 1.2890 5倍 文件连续读写 5.7655 0.3604 15倍 随机读写 不支持 0.5636 无 互斥锁性能 0.0231s 0.0184s 1.2倍

这里我们看到，测试结果让我们大吃一惊，我们的ubuntu-17.04-arm64超官方60倍，我相信，树莓派官方系统仍在不停的改进，测试结果可能与现在的最新版raspbian有出入，但是，我们这里强调的是64位系统的优越性，由此可见，64位系统的却发挥了其应有的优势。

以上测试并非使用64位官方系统，但能够让大家看到软硬件匹配64位之后，树莓派性能上的提升潜力。作为树莓派爱好者，一起期待官方发布64位系统吧！

附上系统项目地址 https://github.com/chainsx/ubuntu64-rpi

Arduino 与 树莓派是 Maker 们创作的两大利器。在接触树莓派之前，我们通常是在 PC 上安装 Arduino 的 IDE 进行 Arduino 开发，而今有了树莓派，PC 的在 Arduino 开发中所起的作用将被树莓派替代了，现在可以直接在树莓派上安装 Arduino IDE 进行 Arduino 开发。下面来介绍具体方法。

由于 Arduino IDE 是图形界面的，所以不用说你的树莓派需要是图形界面版本而非 Lite、Core 版。

一、安装 Arduino IDE

直接命令行安装最简单：

sudo apt-get install arduino

之后主菜单中会出现 Arduino IDE 的菜单。

二、连接 Arduino 开发板

1、通过 USB 将 Arduino 开发板和树莓派连接起来，同 Arduino 连接 PC 一样。

因树莓派 USB 口限流，将 Arduino 板的供电接口同时外接 9-12V 的电源适配器供电更好。

2、配置通信端口

菜单：Tools -> Port:”/dev/ttyxxx” -> 选择”/dev/ttyACM0″

3、编译测试

菜单：File -> Examples -> 01.Basics -> Blink

点击工具栏 Upload 按钮，将自动完成编译后并下载到板子上，看到界面下方出现 “Done uploading” 即可。

DietPi 是一个基于 Debian 的 Linux 发行版。它主要为 Raspberry Pi 树莓派等单板设备开发，但也可运行于包含 x86 及 Odroid 机器在内的其它架构中。其 1 月 28 日发布的最新版本 DietPi 基于 Debian Stretch （除了 Odroid 的之外）。

在这一版本中：所有镜像已被重新创建；已有的安装（ v159 及以下）无法被升级且不再被支持；用户需安装最新的 v6.0 镜像以继续获得支持； 基于 ARMbian 的镜像目前包含主线内核 4.13+ 。 Native PC (EFI) 现在是一个 ISO ，配备了 clonezilla ；通过 Rufus write 简化了安装。

详细内容或其它变化见于其发布通告。

DietPI 拥有如下特性：

轻量：镜像文件大小最低为 400 MB 左右，比 Raspbian Lite 轻 3 倍；

优化了 CPU 及内存资源的使用，确保用户的单板设备的稳定运行；

简单的界面：使用轻量级的 Whiptail 菜单，让用户花费更少的时间于命令行；

DietPi-Software 快速简便得安装经过优化的常见软件；

DietPi-Config: 个性化配置设备的软硬件；

DietPi-Backup: 快速简便地备份及恢复 DietPi 系统；

用户可以选择日志程度，使用 DietPi-Ramlog 或 rsyslog 及 rotate 以记录重要事件并获得性能提升；

DietPi-Process 工具：控制软件的优先级（ nice 、 affinity 及策略调度）；

DietPi-Update 系统： DietPi 自动检查、提示可用更新并可以快速应用更新；

DietPi-Automation ：允许用户在启动之前简单地配置好 dietpi.txt 以完全自动化 DietPi 的安装而无需用户输入。

DietPi 支持 RaspberryPi 、 NanoPi 、 OrangePi 等常见单板设备并提供了详细的教程文档。

封面图片原由 mrneilypops 载于 deviantart.com 。

文内转自 cnBeta，部分文字转录或衍生自 DistroWatch.com 的对应页面与 DietPi 官网。