Circuit Playground Express的介绍

网络整理 发表于 2019-11-27 08:49:54 收藏 已收藏
赞(0) •  评论(0

Circuit Playground Express的介绍

网络整理 发表于 2019-11-27 08:49:54

概述

Circuit Playground Express 是迈向完美介绍电子学和编程的下一步。我们采用了原始的Circuit Playground Classic,并将其做得更好!我们不仅安装了更多的传感器,而且使编程变得更加容易。

Circuit Playground Express的介绍

使用 Microsoft MakeCode 基于块或Javascript编程开始您的旅程。或者,您可以跟随code.org CS Discoveries。然后,您可以使用同一块板来尝试CircuitPython,而Python解释器将在Express上运行。随着您的前进,您可以继续使用 Arduino IDE ,它可以全面支持所有底层硬件,因此您可以创建功能强大的项目。

因为您可以以3种不同方式对同一块板进行编程-Express具有很高的价值和可重复使用性。从初学者到专家,Circuit Playground Express都能满足所有人的需求。

以下是每台Circuit Playground Express带来的一些很棒的东西:

10 x mini NeoPixels,每一个可以显示任何颜色

1个运动传感器(带有敲击检测,自由落体检测的LIS3DH三轴加速度计)

1个温度传感器(热敏电阻)

1个光传感器(光电晶体管)。还可充当颜色传感器和脉冲传感器。

1个声音传感器(MEMS麦克风)

1个带D类放大器的迷你扬声器(7.5mm磁性扬声器/蜂鸣器)

2 x标记为A和B的按钮

1 x滑动开关

红外接收器和发送器-可以接收和发送任何远程控制代码,以及在Circuit Playground Express之间发送消息。还可以充当接近传感器。

8个鳄鱼夹友好的输入/输出引脚

包括I2C,UART,8个可以进行模拟输入的引脚,多个PWM输出

7个打击垫可以用作电容式触摸输入,剩下的1个是真正的模拟输出

绿色的“ ON” LED指示灯,所以您知道其通电了

红色的“#13 “用于基本闪烁的LED指示灯

重置按钮

ATSAMD21 ARM Cortex M0处理器,运行在3.3V和48MHz频率下

2 MB的SPI闪存,主要用于用于存储代码和库的CircuitPython。

用于编程和调试的MicroUSB端口

USB端口的作用类似于串行端口,键盘,鼠标,操纵杆或MIDI!

经典与快速

Circuit Playground的起步阶段是一个具有简单要求的电路板-只需与Arduino IDE和Code.org一起使用即可。但是自2015年首次发布以来,我们已经学到了很多东西,并且极大地改进了开发板!

有两个两个电路游乐场-一个 Classic 和一个 Express 。

经典版本可以运行Arduino和Code.org

Express版本可以运行MakeCode,CircuitPython,Arduino和 Code。 org CS Discoveries。

如何判断您是否有经典

当前电路游乐场Classic板的下半部写有 Classic

旧赛道经典赛中没有 Classic 在背面,但确实有文字说明芯片类型 ATmega32U4

如何判断您是否拥有Express

Express板具有 CIRCUIT PLAYGROUND EXPRESS 在后下半部分。他们还会注意到该芯片是 ATSAMD21

导游

让我带您参观Circuit Playground Express(我们将其简称为 CPX )。每个CPX都在Adafruit组装在这里,并充满了出色的设计,使其使用起来很有趣。

电源和数据

Micro B USB连接器

这是板子的顶部。我们使用了久经考验的,真正的micro-B USB连接器来进行电源和/或USB通信(引导程序,串行,HID等)。与具有标准数据/同步电缆的任何计算机一起使用。

JST电池输入

这在面板的底部。您可以将CPX带到任何地方,并通过外部电池为其供电。该引脚可容纳6V DC输入,并具有反极性,过流和热保护功能。内部电路将使用电池输入电源或USB电源,从一个安全地切换到另一个。如果两者都连接,它将使用电压较高的那个。与锂聚合物电池或末端带有JST连接器的3xAAA电池组配合使用时效果很好。没有内置的电池充电功能(因此您可以安全地使用碱性或锂电池)

鳄鱼皮/鳄鱼夹

连接起来非常容易对于微控制器,我们有14个连接垫。您可以焊接到它们,使用鳄鱼夹/鳄鱼夹,用导电线缝制,甚至使用小的金属螺丝!

在14个焊盘中,您可以获得各种电源引脚,I2C,UART,模拟输入,数字输入/输出,PWM,

其中一些甚至可以感觉到手指的触摸!

有关详细信息,请参见下一个引脚排列页面!

微芯片

大脑ATSAMD21G18 。该芯片比原始的Circuit Playground强大得多。它位于顶部中心,是您用来运行MakeCode,CircuitPython或Arduino的地方!

Circuit Playground Express中的新增功能,我们添加了一个新的存储芯片,称为SPI Flash。这是一个非常非常小的磁盘驱动器,只有2 MB大。您可以在Arduino或CircuitPython中使用它来存储文件。在CircuitPython中,这是您所有代码所在的位置,以及在计算机上使用 CIRCUITPY 驱动器

时看到的内容

LED

绿色LED亮起

USB左侧连接器。该指示灯使您知道CPX已通电。如果点亮,则电源良好!如果光线昏暗,闪烁或熄灭,则表示电源出现问题,您将遇到问题。您不能禁用此灯,但是如果您想将其变成黑色,则可以用电工胶带将其覆盖。

红色#13 LED

USB连接器右侧。该LED灯有双重作用。其通过串联电阻连接至数字#13 GPIO引脚。当CPX处于引导加载程序模式时,它会很好地发出脉冲,并且在需要指示灯LED时也很方便。许多第一个项目使此LED闪烁以证明编程有效。

10 x彩色NeoPixel LED

围绕板外边缘的十个LED均为全彩RGB LED,每个可以设置为彩虹中的任何颜色。伟大的美丽的灯光效果! NeoPixels还可以帮助您了解引导加载程序何时运行(它们将变为绿色),或者在连接到计算机时初始化USB失败(它们将变为红色)。

扬声器

我们已将原来的Circuit Playground的蜂鸣器升级为真正的扬声器,不会与您的HiFi立体声竞争,但它可以播放简单的歌曲和音调

扬声器是板左下方的方形灰色块。扬声器上连接了一个小型D类放大器,因此声音可能很大!注意:如果声音太大,声音会不好,因此可能需要进行一些实验

放大器已连接到真正的模拟输出 A0 引脚-此引脚也可用在右下角的连接垫之一上。

如果您不希望内部扬声器产生噪声,则可以使用引脚#11 《上的关闭控件将其关闭。/strong》

传感器

Circuit Playground Express具有大量的传感器输入,可让您向项目添加各种交互功能。

上具有可选的中断输出

光传感器

板的左上方有一个模拟光传感器,部件号为ALS-PT19。

此传感器可以连接到模拟引脚 A8 ,并且可以读取0到1023之间的较高值,从而可以检测到具有与人眼相似的光谱响应的环境光。对应更高的光线水平。多数室内光线水平的读数通常约为300。

有了一些巧妙的代码,您可以将其用作颜色传感器甚至脉冲传感器!

温度传感器

有一个NTC热敏电阻(Murata NCP15XH103F03RC)我们用于温度感测。虽然它不是一个具有线性输出的多合一温度传感器,但很容易根据模拟引脚#A9 上的模拟电压来计算温度。

麦克风音频传感器

MEMS麦克风可用于检测音频电平,甚至执行基本的FFT功能。我们已经决定使用PDM麦克风,而不是需要外部运算放大器和电平管理的模拟麦克风。这是一款数字麦克风,体积更小,价格更便宜!您将不得不使用MakeCode/CircuitPython/Arduino支持库来读取音频音量,您无法像模拟电压一样读取它。

运动传感器

我们可以使用加速度计来感应运动。该传感器检测到加速度,这意味着它可以用于检测其何时移动以及重力,以检测方向。

LIS3DH 3轴XYZ加速度计位于板上的死点,您可以使用它来检测板上的倾斜,重力,运动以及“敲击”和“双击”敲击。 LIS3DH连接到内部I2C引脚组(与焊盘上的引脚组不同),并在数字引脚#36

电容式触摸

CPX中的芯片具有具有执行电容式触摸读数的内置功能。这是无需其他组件即可感觉到人的触摸的好方法。即使动物直接接触皮肤也可以正常工作!

在Express上,您可以获得七个电容式触摸板。除了 A0 以外的所有打击垫都可以做到。 ( A0 用于音频输出板,因此不能进行电容触摸)。由于我们使用了芯片的内置硬件支持,因此您将使用提供的MakeCode/Arduino/CircuitPython库代码执行读数

开关和按钮

有两个大的 A 和 B 按钮,分别连接到数字#4 (左)和#5 (右)。未按下时未连接,按下时已连接到3.3V ,所以他们读HIGH。将引脚#4 和#5 设置为在读取这些引脚时使用内部下拉电阻,以便在不按下它们时将读取为LOW。

板中心的这个小按钮是重置面板。您可以使用此按钮来重新启动或重置CPX。

如果使用Arduino或CircuitPython,请按一次此按钮进行重置,双击以手动进入引导程序。

如果使用MakeCode,按此按钮两次重置,一次手动进入引导程序。

Circuit Playground Express中央底部附近有一个滑动开关。它已连接到数字#7 。向左滑动时,该开关未连接;向右滑动时,该开关接地。将引脚#7设置为使用内部上拉电阻,以便该开关向左滑动时显示为高,向右滑动时显示为低。

这不是通断开关,但是您可以使用使该开关控制您的项目行为的代码

请注意,您需要为滑动开关使用内部上拉,但需要使用内部上拉(用于按钮)。

红外接收/发送和接近

Circuit Playground Express中的新增功能,我们添加了IR接收和发送功能。这意味着您可以与电视和其他家用设备进行通信以控制它们。您也可以使用遥控器将命令发送到CPX。最后,您可以在之间的多个电路游乐场之间发送简单的消息!

通过将红外光弹起并读取反射光,您还可以执行非常简单的接近感应!

红外线的两个元素。 发射器在左侧,是一个大的透明LED,通过晶体管连接到#29

引脚,在右侧是较暗的接收器 LED,它也具有解码器芯片。该芯片将接收38KHz信号并为您解调。解调后的输出位于引脚#39

上,还具有 secret 功能,您可以从接收器LED二极管读取“原始”模拟值做基本的红外接近感应。直接模拟值可从 A10

引脚获得插脚

上面的图不是确定的!例如,A1线路中缺少一个PWM〜。

尽管只有14个焊盘和8个通用I/O引脚可用,但

除了A0以外,内部传感器/设备均不共享外部I/O焊盘,因此您无需担心“冲突”的图钉或交互作用!

Power Pads

有6个电源垫可用,在周边等距分布。

GND -3 x Ground 护垫。它们都连接在一起,并且都是信号/电源接地连接

3.3V -有两个 3.3 V输出焊盘。它们连接到板载稳压器的输出。该稳压器最大可提供约500mA的电流,但其中也包括所有内置部件!因此,您应该大致预算约300mA的可用电流(如果不使用板载NeoPixels,则为450mA)

Vout -有一个电压输出垫。这是一个特殊的电源板,它将被连接到USB电源或电池输入中的任何一个,具有较高的电压。此输出未连接到稳压器,因此您可以吸收USB端口/电池可提供的最大电流。此引脚上有一个可复位的保险丝,因此您可以连续汲取约500mA的电流,并在其跳闸之前产生1 A的峰值。如果保险丝跳闸,请稍等片刻,它将自动重置

如果要连接需要3.3V清洁电源的芯片,传感器和低功率电子设备,请使用 3.3V 垫。

如果要连接最高5V的伺服器,NeoPixels,DotStars或其他大功率电子设备,请使用 Vout 垫。/p》

输入/输出面板

接下来,我们将介绍8个GPIO(通用输入输出)引脚!作为参考,您可能还想查看下载部分的数据手册参考,以获取ATSAMD21G18核心引脚的信息。我们选择了具有很多功能的引脚。

所有打击垫共有

所有GPIO垫都可用作LED,按钮和开关的数字输入,数字输出。 此外,所有这些都可用作模拟输入(12位ADC)。除A0外,其他所有都可以用于硬件电容式触摸。所有的焊盘也可以用作硬件中断输入。

每个焊盘可以提供高达20mA的电流。不要将电机或其他大功率组件直接连接到引脚!取而代之的是,使用晶体管为DC电动机开/关。所有GPIO焊盘均为3.3V输出电平,不应与5V输入一起使用。通常,大多数5V设备都可以使用3.3V输出。

除了A0(与扬声器共享)之外,所有打击垫都是完全“空闲”的引脚,USB不使用它们连接,LED,传感器等,因此您在编程时不必担心会干扰它们。

每个图钉!

让我们从右下角的 A0 开始,然后继续逆时针方向

A0 (又名 D12 )-这是一个特殊的引脚,可以实现真正的模拟输出,因此非常适合播放音频剪辑。输入可以是数字I/O或模拟I/O,但如果这样做,则会干扰内置扬声器。这是一个不能用于电容式触摸的引脚。

A1 /D6 -此引脚可以是数字I/O或模拟输入。此引脚具有PWM输出,可以是电容式触摸传感器

A2 /D9 -此引脚可以是数字I/O或模拟输入。此引脚具有PWM输出,可以是电容式触摸传感器

A3 /D10 -此引脚可以是数字I/O或模拟输入。此引脚具有PWM输出,可以是电容式触摸传感器

A4 /D3 -此引脚可以是数字I/O或模拟输入。此引脚也是 I2C SCL 引脚,可以是电容式触摸传感器

A5 /D2 -此引脚可以是数字I/O或模拟输入。此引脚也是 I2C SDA 引脚,可以是电容式触摸传感器

A6 /D0 -此引脚可以是数字I/O或模拟输入。该引脚具有PWM输出,串行接收,并且可以是电容式触摸传感器

A7 /D1 -此引脚可以是数字I/O或模拟输入。该引脚具有PWM输出,串行传输,并且可以是电容式触摸传感器

内部使用的引脚!

这些是用于内置传感器等的引脚名称!

D4 -左按钮A

D5 -右按钮B

D7 -滑动开关

D8 -内置10个NeoPixels

D13 -红色LED

D27 -加速度计中断

D25 -红外发射器

D26 -红外接收器

A0 -扬声器模拟输出

A8 -光传感器

A9 -温度传感器

A10 -红外接近传感器

D28 -内部I2C SDA(通过 Wire1 访问)

D29 -内部I2C SCL(通过 Wire1 访问)

D30( PIN_SPI_MISO )-SPI FLASH MISO

D31( PIN_SPI_SCK )-SPI FLASH SCK

D32( PIN_SPI_MOSI )-SPI FLASH MOSI

D33 -SPI FLASH片选

更新Bootloader(尤其是Mac用户!)

如果您使用的是Mac,并且正在使用MakeCode进行编程,您可能需要更新引导加载程序!

如果使用的是MakeCode(https://makecode.adafruit.com或https在Mac上(://maker.makecode.com),您需要更新主板的引导程序以避免严重的问题。

从MacOS 10.14.4开始,苹果改变了方式在某些Mac上可以识别USB设备。这会导致加载了MakeCode程序的电路板出现时序问题,从而阻止显示CPLAYBOOT驱动器(或其他。..BOOT驱动器)。

更新您的Circuit Playground Express Bootloader

(其他板见下文)

查看是否需要更新您的引导程序,获取CPLAYBOOT出现在您的板上。如果您正在运行MakeCode,请单击一次“重置”按钮。如果您正在运行CircuitPython或Arduino程序,请双击“重置”按钮。所有NeoPixels都应变为绿色。

在Finder中单击CPLAYBOOT驱动器,然后双击INFO_UF2.TXT文件以查看其中的内容。

引导加载程序版本在INFO_UF2.TXT。在此示例中,版本为“ V2.0.0-adafruit.5”。

如果看到的引导加载程序版本早于“ v3.3.0-adafruit.10 ”,则需要进行更新。例如,上面的引导程序需要升级。

在此处下载Circuit Playground Express引导程序更新程序的最新版本:

Circuit Playground Express v3.3.0-adafruit .10 update-bootloader.uf2

引导加载程序更新程序将被命名为update-bootloader-circuitplay_m0-v3.3.0-adafruit.10.uf2或更高版本。将该文件从您的Downloads文件夹拖动到CPLAYBOOT驱动器上。

将更新程序拖到CPLAYBOOT后,随着引导加载程序的更新,板上的红色LED将闪烁。 NeoPixels将闪烁并再次变为绿色。几秒钟后,CPLAYBOOT将重新出现在Finder中。之后,您可以单击CPLAYBOOT并再次双击INFO_UF2.TXT以确认您已更新引导加载程序。

哦,不,我已经更新了MacOS,看不到CPLAYBOOT!

如果您的Mac已经更新到MacOS 10.14.4,现在您不能请参阅Finder中的CPLAYBOOT,您需要找到另一台可以使用的计算机。并非所有升级的Mac都不会显示CPLAYBOOT:较旧的Mac可以工作。或者找到尚未升级的Mac。任何Windows 10或Linux计算机都可以用于升级Bootloader。 Windows 7计算机将需要安装驱动程序,但可以运行。

升级其他板卡

如果您没有Circuit Playground Express,但使用的是带有UF2引导加载程序的其他Adafruit板,则该过程与您在上面看到的类似。单击(如果使用MakeCode)或双击重置按钮。您会看到一个名称以。..BOOT结尾的驱动器。检查上述版本。如果需要更新,请为您的主板下载一个引导加载程序更新程序。 UF2 Bootloader详细信息页面上的“更新引导程序”部分中提供了指向最新更新程序的链接。然后将更新程序.uf2文件拖动或复制到您的BOOT驱动器上。

Windows驱动程序安装

Mac和Linux不需要驱动程序,只有Windows用户需要执行此步骤

在插入板子之前,您可能需要安装驱动程序!

单击下面的按钮下载我们的驱动程序安装程序

下载最新的Adafruit Windows驱动程序安装程序

下载并运行安装程序。

运行安装程序!由于我们也捆绑了SiLabs和FTDI驱动程序,因此您需要单击许可证

选择要安装的驱动程序,我们建议选择所有驱动程序,这样就不必再次执行此操作!

在Windows 7上,默认情况下,我们为Adafruit的大多数主板安装了单个驱动程序,包括 Feather 32u4,Feather M0,Feather M0,Express,Circuit Playground,Circuit Playground Express,Gemma M0,Trinket M0,Metro M0 Express 。在Windows 10上,该驱动程序不是必需的(它是Windows内置的),并且不会列出。

默认情况下,还安装了 Trinket/Pro Trinket/Gemma/USBtinyISP 驱动程序。

您还可以选择安装 Arduino Gemma (不同于Adafruit Gemma!), Huzzah和Metro 328 驱动程序。

单击安装进行安装。

请注意,在Windows 10上,内置了对许多板的支持。如果最终不选中任何框,则根本不需要运行安装程序!

手动安装驱动程序

如果Windows由于某些原因需要驱动程序文件(inf/cat),则可以获取所有驱动程序,方法是从以下链接下载源zip文件:

最新的Adafruit窗口s驱动程序发布

,并在询问驱动程序位置时将窗口指向 Drivers 文件夹

Code.org CSD

您是否知道可以将Circuit Playground Express(CPX)与Code.org CS Discoveries课程一起使用?好了,您现在可以!

所有您需要做的就是将“ Firmata”固件加载到CPX上。幸运的是,它非常简单,您只需为每个设备执行一次

步骤1。连接到USB

使用已知良好的USB电缆将Circuit Playground Express插入计算机

很多人最终只使用可充电的USB电缆,这非常令人沮丧!因此,请确保您有一条知道可以进行数据同步的USB电缆

步骤2。按RESET进入引导加载程序模式

板子中间有一个小按钮。尝试单击一次,使其进入引导加载程序模式。

您会知道当所有指示灯都变为绿色时,您将成功进入引导加载程序模式

如果一次不单击RESET,请尝试双击(MakeCode需要单击,而Arduino需要双击)

如果颜色LED指示灯全部变为红色,检查您的USB电缆,尝试使用另一根电缆或另一个USB端口

第3步。通过Firmata固件复制

您的计算机现在将显示 CPLAYBOOT 磁盘驱动器。

点击此链接下载 FIRMATA yyyy-mm-dd.UF2 (年,月,日可能有所不同)并将其拖动到驱动器上

FIRMATA_2018-2-19.UF2

CPX将在几秒钟后自动重启。 CPLAYBOOT磁盘驱动器将消失(您可能会从计算机收到警告,它不希望弹出该磁盘,请忽略它!)

您的CPX现在可以运行 Code.org CS发现!

MakeCode

Circuit Playground Express的美丽之处之一是您可以通过以下方式进行三种方式:

MakeCode

CircuitPython

Arduino IDE(或直接进行ARM GCC编程)

如果这是您第一次编程或编码,我们建议从 MakeCode开始-不仅可以使用Circuit Playground Express快速入门,而且还可以进行一般编码! (一旦掌握了MakeCode,就可以看看CircuitPython或Arduino。)

MakeCode不需要安装任何软件,它可以在装有一个网络浏览器。您可以在Mac,Windows,Linux,Chromebooks上使用它。

MakeCode像Scratch一样使用拖放块,没有语法或分号。这些块紧密结合在一起,可以创建更大,更复杂的项目

MakeCode可让您在5分钟或更短的时间内开始使用,其中内置了指南和项目,但这样做也很有趣

MakeCode具有令人惊讶的高级运行时,尽管看起来很简单,但它可以执行通常需要高级编程的非常复杂的任务。您可以非常迅速地获得创造力。

继续学习如何使用MakeCode并构建您的第一个项目!

什么是CircuitPython?

CircuitPython是一种编程语言,旨在简化在低成本微控制器板上进行编程的实验和学习。它使入门变得比以往任何时候都更加轻松,无需预先下载桌面。设置好电路板后,打开任何文本编辑器,然后开始编辑代码。就是这么简单。

CircuitPython基于Python

Python是增长最快的编程语言。它在学校和大学中教授。这是一种高级编程语言,这意味着它的设计易于阅读,编写和维护。它支持模块和包,这意味着可以轻松地将代码重用于其他项目。它具有内置的解释器,这意味着无需其他步骤即可使代码正常工作,例如 compiling 。当然,Python是开源软件,这意味着任何人都可以免费使用,修改或改进它。

CircuitPython为所有这些令人惊奇的功能添加了硬件支持。如果您已经具备Python知识,则可以轻松地将其应用于CircuitPython。如果您以前没有经验,那么开始就非常简单!

为什么要使用CircuitPython?

CircuitPython设计为在微控制器板上运行。微控制器板是带有微控制器芯片的板,本质上是一台很小的多合一计算机。您拿着的板是微控制器板! CircuitPython易于使用,因为您所需要的只是那块小板,一条USB电缆和一台具有USB连接的计算机。但这仅仅是开始。

使用CircuitPython的其他原因包括:

您要快速启动并运行。编辑您的代码,保存文件,它会立即运行。无需编译,无需下载,也不需要上传。

您是编程的新手。 CircuitPython在设计时就考虑了教育。开始学习编程的过程很容易,您会立即从董事会获得反馈。

轻松更新代码。由于代码位于磁盘驱动器上,因此您可以随时对其进行编辑您还可以保留多个文件,以方便进行实验。

串行控制台和REPL。这些功能可让您从代码和交互式编程中获得实时反馈。

文件存储。 CircuitPython的内部存储使其非常适合数据记录,播放音频剪辑以及与文件交互。

强大的硬件支持。 有许多用于传感器,分支板和其他外部组件的库和驱动程序。

它是Python! Python是增长最快的编程语言。它在学校和大学中教授。 CircuitPython与Python几乎完全兼容。它只是增加了硬件支持。

这仅仅是开始。 CircuitPython不断发展,并不断更新。我们欢迎并鼓励社区提供反馈,并将其纳入开发CircuitPython的方式中。这是开源概念的核心。这使CircuitPython更适合您和使用它的每个人!

CircuitPython

在我们继续开发CircuitPython和创建新版本时,我们将停止支持较旧的版本。如果您正在运行旧版本的CircuitPython,则需要进行更新。单击下面的按钮下载最新的!

安装或更新CircuitPython!

按照以下逐步说明进行操作,以实现超快速的Python功能:)

下载最新版本的CircuitPython通过CircuitPython.org

单击上面的链接并下载最新的UF2文件

下载并将其保存到桌面(或任何方便的地方)

使用已知良好的USB电缆将Circuit Playground Express插入计算机中

很多人最终都使用仅可充电的USB电缆,这非常麻烦吹牛!因此,请确保您有一条知道可以进行数据同步的USB电缆

双击CPX中间的小 Reset 按钮,您会看到所有的LED变为绿色。如果它们全部变成红色,请检查USB电缆,尝试另一个USB端口,等等。

(如果双击不起作用,请单击一次!)

您将看到一个名为 CPLAYBOOT

的新磁盘驱动器拖动 adafruit-circuitpython-etc 。.. uf2 文件

CPLAYBOOT 驱动器将消失,并且将出现一个名为 CIRCUITPY

的新磁盘驱动器。您已经完成了:)

其他信息

有关安装CircuitPython的更多详细信息,请查看“安装CircuitPython”。

CircuitPython游乐场

这里有一些演示,展示了如何将电路游乐场与python结合使用!

Arduino

Arduino是一个基于易于使用的硬件和软件的开源电子平台。 Arduino开发板能够读取输入-传感器上的灯,按钮上的手指或Twitter消息-并将其转换为输出-启动电动机,打开LED并在线发布内容。您可以通过向板上的微控制器发送一组指令来告诉您该怎么做。为此,您使用基于编程的Arduino编程语言和基于处理的Arduino软件(IDE)。

-https://www.arduino.cc/zh/Guide/简介

Arduino是Circuit Playground Express支持的第三种也是最古老的编程语言。 Arduino具有十多年的项目和历史,因此您会发现许多可与CPX一起使用的现有代码。

Arduino本质上是具有内置硬件接口库的C/C ++。它是这三种语言中最底层的-您可以嵌入汇编,编写超快速代码,并充分利用整个内存和文件系统。但是。..对于初学者来说更难使用!如果您是Arduino专家,则可能只想将CPX与Arduino IDE一起使用。

如果您是编码之旅的开始,请先查看MakeCode。

如果如果您想要快速开发而不需要上载/编译或内存管理,请查看CircuitPython。它不如Arduino的时钟周期快,但编码速度更快,更简单,更有趣。

附件

Circuit Playground Express是一个很棒的教学工具。它内置了一吨,但您可以做很多事情。请查看下面的列表,了解一些兼容的产品,这些产品会在您的项目中添加更多内容!

这些包将帮助您开始使用已包含的一些附件。

Circuit Playground Express基础套件

产品编号:3517

这是Circuit Playground Express基础套件!它为您提供了一些东西将需要开始使用新的

$ 29.95

入库存

Circuit Playground Express Advanced Pack

产品ID:2769

Circuit Playground Express是迈向完美介绍电子学和编程的下一步。我们已经采用了原始的Circuit Playground Classic 。..

缺货

缺货

连接

这些产品可用于将各种有趣的东西连接到Circuit Playground Express,例如传感器,伺服器和香蕉。

小型鳄鱼夹测试线(18套)

产品ID:3447

使用这些mini无需焊接即可将其连接到该端子鳄鱼夹测试线。 15“电缆,两端带有鳄鱼夹,有六种颜色。坚固而结实,这些总是来。..

$ 5.95

现货

添加到购物车

小鳄鱼夹至公跳线束-12件

产品ID:3255

对于具有非标头友好型表面的面包板,这些电缆将成为您最好的朋友!您将不再有长长的短吻鳄皮夹了……

$ 7.95

入股

添加到购物车

小型鳄鱼夹至公跳线束-6件

产品编号:3448

在处理非标头友好型非常规表面时,这些方便的电缆将是您的最佳选择朋友们!您将不再有长而繁琐的鳄鱼夹了。这些。..

缺货

缺货

导电钩环胶带-3英寸长

产品ID:1324

导电钩环环形胶带就像您在夹克,衣服,鞋子和袋子上看到的东西一样,但涂有银色以使其完全导电。最初是。..

$ 5.95

进货

添加到购物车

电容式触摸

这些产品可以与电容式触摸板一起使用,以创建对人的触摸有反应的交互式艺术品。

裸导电漆-50mL

产品编号:1305

裸导电漆是一种多功能导电材料,非常适合您所有的DIY项目! Bare Paint是水性的,无毒,并且在室温下干燥。

$ 34.95

有货

添加到购物车

裸导电漆笔- 10mL

产品编号:1306

裸导电漆是一种多功能导电材料,非常适合您所有的DIY项目! Bare Paint是水性的,无毒,并且在室温下干燥。

$ 12.50

入库

添加到购物车

导电银笔-标准提示

产品ID:514

有两个“提示”可用-标准提示和微型提示。 microtip可以实现更好的控制,但使用起来有点困难(因为它不会以。..

缺货

div》

缺货

导电银色墨水笔-微型笔头

产品编号:515

使用这种银色导电墨水笔进行纸质电子产品的实验,可以让您绘制痕迹!有一种很好的液态银墨水,容易流动,。..

$ 49.95

进货

添加到购物车

铜箔胶带胶粘剂-25毫米x 15米卷

产品ID:1127

铜带可以是工具箱中的一个有趣的附加材料,该带本身是由纯铜制成的,因此非常柔软,几乎可以采用任何形状。您可以轻松。..

$ 19.95

入库存

添加到购物车

铜箔带有导电胶粘带的胶带-6毫米x 15米卷

产品ID:1128

铜带可以是您工具箱中的一个有趣的补充。胶带本身由纯铜制成,因此非常柔软,几乎可以呈现任何形状。您可以轻松地。..

$ 5.95

入库存

添加到购物车

原面食-1.75毫米500克导电PLA纤维丝

产品编号:2703

不买这根灯丝真是大错特错! Pici今天把这根细丝拉起来!我们做了。..

$ 58.00

进货

添加到购物车

原粉-直径2.85毫米-导电石墨丝

产品编号:3752

今天就买这根灯丝!不要买了……

缺货

缺货

机器人

这些产品可以为您的项目添加一些机器人朋友的味道。

微型伺服器

产品ID:169

小小的伺服器可以旋转大约180度(每个方向旋转90度) ),其工作方式与您习惯的标准类型相同,但较小。您可以使用任何伺服代码,。..

$ 5.95

入库存

添加到购物车

连续旋转微型伺服器

产品ID:2442

需要制造一个微型机器人吗?这个微型微伺服器可以完全向前或向后旋转360度,而不是移动到单个位置。您可以使用任何伺服代码,硬件。..

$ 7.50

入库存

添加放入购物车

微型连续旋转FS90R伺服轮

产品ID:2744

我们正在与这台机器保持同步!需要为您的小机器人朋友提供出色的驱动解决方案吗?这款黑色塑料微型Continuos 。..

$ 2.50

进货

添加到购物车

div》

可缝制

您可以使用以下产品将缝制添加到项目中。

Flora RGB Smart NeoPixel版本2-包4

产品ID:1260

什么是没有LED的可穿戴项目?这些Flora平台最喜欢的部分是这些微小的智能像素。这些经过更新的Flora NeoPixels专为可穿戴设备设计,具有。..

$ 7.95

入库价

添加到购物车

不锈钢细导电线- 2层-23米/76英尺

产品编号:640

经过几个月的搜索,我们终于有了我们认为是最终的导电线。它薄,结实,光滑,完全由316L不锈钢制成。一旦您。..

$ 6.95

入库存

添加到购物车

可缝制按扣-直径5mm-卡片24张

产品ID:1126

这些镀锡黄铜按扣的5毫米小尺寸意味着它们非常适合Flora的垫子!按扣是可穿戴设备的绝佳连接器-将一侧焊接到板上并缝制。..

$ 3.95

入库存div》

添加到购物车

针组-3/9尺寸-20针

产品ID:615

强大的针,缝得像风!这种针组是您进行任何形式的手工缝制所需的唯一针组,特别是使用我们的导电线和可穿戴电子设备。..

$ 1.95

有货

添加到购物车

span》

电源

这些产品可用于为项目供电,而无需使用USB电缆。

JST-PH电池延长线-500mm

产品ID:1131

由于需求旺盛,我们现在为所有JST端接的电池组(例如LiIon/LiPoly和3xAAA电池座)提供了一条方便的延长线。一端有一个JST-PH插座,而。..

$ 1.95

IN STOCK

添加到购物车

JST 2针带开/关开关的延长电缆-JST PH2

产品ID:3064

根据普遍要求-我们现在提供一种无需断开电源即可打开和关闭锂聚合物电池的方法此PH2女性/男性JST 2针扩展名。..

$ 2.95

入库存

添加到购物车

3 x AAA电池带有开/关开关,JST和皮带夹的支架

产品ID:3286

此电池支架可将3节AAA电池串联在一起,为各种项目供电。我们之所以选择这些是因为盒子很纤细,加上3个AAA的总和。..

$ 2.95

IN STOCK

添加到购物车

3个AA电池座,带有开/关开关,JST和皮带夹

产品编号:3287

此电池座将3节AA电池串联在一起,可以供电各种项目。我们之所以选择这些是因为包装盒非常紧凑,加上3个AA的总和。..

$ 2.95

IN STOCK

添加到购物车

3个AAA电池盒,带开/关开关和2针JST

产品ID:727

此电池盒将3节AAA电池串联在一起,为所有电池供电各种项目。我们之所以选择这些是因为盒子很小,而且3个AAA的总和约为。..

缺货

缺货

锂离子聚合物电池-3.7v 500mAh

产品编号:1578

锂离子聚合物电池(又称“ lipo”或“ lipoly”)电池纤巧,轻巧且功能强大。完全充电后的输出范围为4.2V至3.7V。该电池。..

$ 7.95

有货

添加到购物车

锂离子聚合物电池-3.7v 1200mAh

产品编号:258

锂离子聚合物电池(又称“脂质”或“ lipoly”)电池薄,轻便且功能强大。完全充电后的输出范围为4.2V至3.7V。该电池。..

$ 9.95

入库价

添加到购物车

锂离子聚合物电池-3.7v 350mAh

产品编号:2750

锂离子聚合物电池(又称“ lipo”或“ lipoly”)电池纤薄,轻巧且功能强大。完全充电后的输出范围为4.2V至3.7V。该电池。..

$ 6.95

有货

添加到购物车

2 x 2032纽扣电池座-6V输出,带开/关闭开关

产品ID:783

这款小型币形电池座非常适合便携式或可穿戴小型项目。它串联容纳两个20mm纽扣电池(最受欢迎的尺寸为2032),以产生6V标称电压。 (如果。..

$ 1.95

存货

添加到购物车

这些产品可用于为上面列出的锂离子聚合物电池充电。

Adafruit微型Lipo充电器,适用于带MicroUSB插孔的LiPo/LiIon电池

产品ID:1904

哦方便,这款小型脂质充电器小巧易用,您可以将其放在桌上或轻松安装到任何项目中!只需通过MicroUSB电缆将其插入USB 。..

$ 6.95

进货

添加到购物车

PowerBoost 500充电器-可充电5V Lipo USB Boost @ 500mA +

产品ID:1944

PowerBoost 500C是便携式项目的理想电源!借助内置的电池充电器电路,即使在充电时,您也可以保持项目运行。..

缺货

缺货

UF2 Bootloader详细信息

这是一个好奇的高级用户的信息页我们如何将代码从您的计算机获取到Express板中!

Adafruit SAMD21(M0)和SAMD51(M4)板具有改进的引导加载程序,使其比将不同的代码刷新到微控制器上。该引导程序使您可以轻松地在Microsoft MakeCode,CircuitPython和Arduino之间进行切换。

无需使用驱动程序或单独的程序进行刷新(例如,bossac,jlink或avrdude),只需将 文件拖到可移动驱动器上 。

文件格式有点特殊。由于“操作系统故障”,您不能只拖动二进制或十六进制文件(相信我们,我们尝试过了,它与跨平台不兼容)。而是,文件格式具有其他信息,可以帮助引导加载程序了解数据的去向。该格式称为UF2(USB闪存格式)。 Microsoft MakeCode生成用于闪烁的UF2,CircuitPython版本也可以作为UF2获得。您也可以使用uf2tool从二进制文件创建自己的UF2,可在此处使用。

引导加载程序 也是BOSSA兼容 ,因此它可以与Arduino IDE一起使用希望在基于ATSAMD的板上使用BOSSA引导加载程序。

有关UF2的更多信息,可以在MakeCode博客上阅读更多内容,然后查看UF2文件格式规范。

访问Adafruit的Microsoft UF2-samd引导程序GitHub存储库的分支,用于CircuitPython.org上的源代码和预构建的引导程序的发布。

更改CircuitPython代码时不需要引导加载程序。仅在升级CircuitPython核心或在CircuitPython,Arduino和Microsoft MakeCode之间进行切换时才需要它。

进入Bootloader模式

将新代码加载到板上的第一步是触发Bootloader。双击重置按钮即可轻松完成此操作。引导加载程序启动后,您将看到红色的小LED淡入和淡出,并且新驱动器将出现在计算机上,其名称以 BOOT 结尾。例如,羽毛显示为 FEATHERBOOT ,而新的CircuitPlayground显示为 CPLAYBOOT ,小饰品M0将显示为 TRINKETBOOT ,而Gemma M0此外,它将显示为 GEMMABOOT

,当启动引导程序处于活动状态时,它将更改一个或多个板载新像素的颜色以指示连接状态,红色表示断开连接,绿色表示连接的。如果主板已插入但仍显示已断开连接,请尝试使用其他USB电缆。某些电缆仅提供电力而没有通信。

例如,这是一根Feather M0 Express,运行着五颜六色的Neopixel漩涡。双击重置按钮时(每次单击之间约半秒钟),NeoPixel将保持绿色,以使您知道引导加载程序处于活动状态。单击重置按钮一次,“用户程序”(NeoPixel彩色旋涡)将重新启动。

如果引导加载程序无法启动,则会显示红色的NeoPixel LED。

这可能意味着您的USB电缆是不好,它没有连接到计算机,或者驱动程序无法枚举。首先尝试使用新的USB电缆。然后在计算机上尝试另一个端口!

引导加载程序一旦运行,请检查您的计算机。您应该会看到USB磁盘驱动器。..

引导加载程序成功连接后,您可以打开驱动器并浏览虚拟文件系统。这与您在CircuitPython或Arduino上使用的文件系统不同。它应该包含三个文件:

CURRENT.UF2 -微控制器的当前内容。

INDEX.HTM -链接到Microsoft MakeCode。

INFO_UF2.TXT -包括引导加载程序版本信息。请把它包括在错误报告中。

使用Mass Storage Bootloader

要刷新新内容,只需将任何UF2拖到驱动器上即可。文件复制完成后,引导程序将自动重启。这通常会引起有关驱动器弹出不安全的警告。但是,这不是问题。引导加载程序知道何时成功复制了所有内容。

您可能会从操作系统中收到一条警告,提示正在复制没有属性的文件。您只需单击是

您还可能会抱怨驱动器没有警告就被弹出。不用担心只有在引导加载程序验证并完成写入新代码的过程后,驱动器才会弹出

使用BOSSA引导程序

如前所述,引导程序也与BOSSA兼容,BOSSA是在Arduino IDE中更新板的标准方法。它是可以在任何操作系统中使用的命令行工具。我们不会介绍 bossac 工具的全部使用方法,只说它可以起到很多作用!有关更多信息,请访问ShumaTech。

Windows 7驱动程序

如果您正在运行Windows 7(或者,是的,还早一些?),您将需要串行端口驱动程序文件。 Windows 10用户不需要此,因此跳过此步骤。

您可以在此处下载完整的驱动程序包:

下载最新的Adafruit驱动程序安装程序

下载并运行安装程序。我们建议您只选择所有可用的串行端口驱动程序(这样做无害)并安装它们。

在设备管理器中验证串行端口

如果您使用的是Windows,则最好验证设备出现了。从控制面板打开设备管理器,然后在端口(COM和LPT)下查找名为羽毛M0 或电路游乐场的设备!

如果您看到类似这样的信息,则表明您没有安装驱动程序。返回并重试,然后拔下并重新插入板子的USB电缆

正在运行的bossac命令行

如果您使用的是Arduino IDE,则无需执行此步骤。但是有时您想要读/写自定义二进制文件,例如加载CircuitPython或自己的代码。我们建议使用经过测试的bossac v 1.7.0(或更高版本)。推荐使用Arduino分支。

您可以在此处下载最新版本。 mingw32版本适用于Windows,apple-darwin适用于Mac OSX,而各种linux选项适用于Linux。下载后,从zip中解压缩文件,并使用bossac打开命令行到目录。

对于1.9或更高版本的bossac,您必须在命令行上使用--offset参数,并且该参数必须与您的电路板具有正确的值。

对于bossac 1.9或更高版本,必须在命令行上提供一个--offset参数,以指定从何处开始将固件写入闪存中。在bossac 1.8.0中添加的,默认值为0x2000,但是从1.9开始,默认偏移量已更改为0x0000,这在大多数情况下不是您想要的。如果您省略了bossac 1.9或更高版本的参数,则可能会看到来自bossac的“ 验证失败”错误。请记住更改-p或--port的选项以匹配Mac上的端口。

将下面的文件名替换为下载的名称 .bin :这将根据您的主板而有所不同!

使用bossac版本1.7.0、1.8

有没有可用的--offset参数。使用这样的命令行:

bossac -p=/dev/cu.usbmodem14301 -e -w -v -R adafruit-circuitpython-boardname-version.bin

例如,

bossac -p=/dev/cu.usbmodem14301 -e -w -v -R adafruit-circuitpython-feather_m0_express-3.0.0.bin

使用bossac 1.9或更高版本

对于具有8kB引导加载程序的M0板,必须指定-offset=0x2000,例如:

bossac -p=/dev/cu.usbmodem14301 -e -w -v -R --offset=0x2000 adafruit-circuitpython-feather_m0_express-3.0.0.bin

对于具有16kB引导程序的M4板,必须指定-offset=0x4000,例如:

bossac -p=/dev/cu.usbmodem14301 -e -w -v -R --offset=0x4000 adafruit-circuitpython-feather_m4_express-3.0.0.bin

这将e擦除芯片,w写入给定的文件,v验证写入并R设置板。在Linux或MacOS上,您可能需要使用sudo 。/bossac 。..运行此命令,或首先将自己添加到拨号组。

更新引导加载程序

UF2引导加载程序相对较新,尽管我们进行了大量测试,但其中可能包含错误。通常,这些错误会影响可靠性,而不是完全阻止引导加载程序工作。如果引导加载程序不稳定,则可以尝试更新引导加载程序本身以潜在地提高可靠性。

如果在Mac上使用MakeCode,则需要确保上传引导加载程序,以避免较新版本的MacOS出现严重问题。在此处查看说明和更多详细信息。

通常,您不必更新引导加载程序! 如果您确实遇到引导加载程序相关的问题,请在论坛中发布或与之不合。

更新引导加载程序就像刷新CircuitPython,Arduino或MakeCode一样容易。只需如上所述输入bootloader,然后将下面的 update bootloader uf2 文件拖入即可。此uf2包含一个程序,该程序将解锁引导加载程序部分,更新引导加载程序,然后将其重新锁定。它将覆盖现有的代码,例如CircuitPython或Arduino,因此请确保所有内容都已备份!

文件复制完成后,引导加载程序将更新并再次出现。 INFO_UF2.TXT 文件应在其中显示较新的版本号。

例如:

UF2 Bootloader v2.0.0-adafruit.5 SFHWRO

Model: Metro M0

Board-ID: SAMD21G18A-Metro-v0

最后,从Arduino或MakeCode重新加载代码或刷新最新版本CircuitPython核心。

下面是各种板的最新更新程序。始终可以在此处找到最新版本。查找update-bootloader.。.文件,而不是bootloader.。.文件。

Circuit Playground Express V3.3.0-adafruit.10 update-bootloader.uf2

羽毛M0 Express v3.3.0-adafruit.10 update-bootloader.uf2

地铁M0 Express v3.3.0-adafruit.10 update-bootloader.uf2

Gemma M0 v3。 3.0-adafruit.10 update-bootloader.uf2

饰品M0 v3.3.0-adafruit.10 update-bootloader.uf2

Itsy Bitsy M0 v3.3.0-adafruit.10 update- bootloader.uf2

Grand Central M4 v3.3.0-adafruit.10 update-bootloader.uf2

其他板子的最新版update-bootloader.uf2。确保选择正确的一个。

摆脱Windows弹出窗口

如果您使用UF2引导加载程序在Windows上进行 lot 开发,则常量“嘿,您要插入驱动器,您想做什么?

转到控制面板。单击硬件和声音标头

点击自动播放标题

取消选中顶部标记为对所有设备使用自动播放

的框td》

制作自己的UF2

制作自己的UF2很容易!您只需要一个要刷新的程序的.bin文件和Python转换脚本即可。对于M0板,请确保您的程序已编译为从0x2000(8k)开始,对于M4板,请确保程序从0x4000(16kB)开始。引导加载程序占用前8kB(M0)或16kB(M4)。 CircuitPython的链接程序脚本是有关此操作的示例。

一旦有了.bin文件,您只需在其上运行Python转换脚本即可。这是带有 uf2conv.py 的目录中的示例。此命令将在与源 firmware.bin 相同的目录中生成一个 firmware.uf2 文件。然后可以按照与上面相同的方式刷新uf2。

下载:文件

复制代码

# For programs with 0x2000 offset (default)

uf2conv.py -c -o build-circuitplayground_express/firmware.uf2 build-circuitplayground_express/firmware.bin

# For programs needing 0x4000 offset (M4 boards)

uf2conv.py -c -b 0x4000 -o build-metro_m4_express/firmware.uf2 build-metro_M4_express/firmware.bin

# For programs with 0x2000 offset (default)

uf2conv.py -c -o build-circuitplayground_express/firmware.uf2 build-circuitplayground_express/firmware.bin

# For programs needing 0x4000 offset (M4 boards)

uf2conv.py -c -b 0x4000 -o build-metro_m4_express/firmware.uf2 build-metro_M4_express/firmware.bin

将引导加载程序安装在新的/砖状板上

如果您以某种方式损坏了引导加载程序,或者您有一块新板,则可以使用JLink重新安装它。这是turbinnreiter的简短文章,内容涉及如何为Feather M4(但适用于其他主板)

下载

文件:

用于Circuit Playground Express的EagleCAD PCB文件

在Adafruit Fritzing库中整理文件

PigHixxx Circuit Playground Express引脚分布图(PDF)

Circuit Playground Express MakeCode演示.uf2(将其复制到CPLAYBOOT)

Circuit Playground Express CircuitPython Demo zip(已更新,以与CircuitPython 3.x库兼容;解压缩并将其内容复制到CIRCUITPY)

GitHub上的3D模型

Circuit Playground Express原理图

单击以进行签名

随附的原始Arduino演示赛道游乐场

什么是MakeCode?

Adafruit的Microsoft MakeCode 是用于物理计算的基于Web的代码编辑器。它提供了类似于Scratch或Code.org的块编辑器,还为更高级的用户提供了JavaScript编辑器。 立即在https://makecode.adafruit.com/上尝试!!

MakeCode的一些关键功能包括:

基于网络的编辑器:无需安装

跨平台:可在大多数现代浏览器中使用,从微型手机到大型触摸屏

在浏览器中进行编译:编译器在您的浏览器中运行,运行速度快且可离线运行

块+ JavaScript:拖放块或键入JavaScript,MakeCode让您

可脱机工作::一旦加载了编辑器,它就会保留在浏览器中。

基于事件的运行时:轻松响应按钮单击,摇动手势等操作

MakeCode当前支持 Adafruit Circuit Playground Express 。 对于其他板,例如Adafruit Metro M0,请尝试https://maker.makecode.com。

Circuit Playground Express

产品ID:3333

Circuit Playground Express是向电子学和编程学完美介绍的下一步。我们已经采用了原始的Circuit Playground Classic和。..

$ 24.95

入库存

添加到购物车

Circuit Playground Express-Base套件

产品ID:3517

这是Circuit Playground Express基础套件!它提供了开始使用新

$ 29.95

进货

添加到购物车

MakeCode适用于Circuit Playground的Express版本,而不是Classic。

编辑块

块编辑器是开始使用MakeCode的最简单方法。您可以从类别列表中拖放块。每次更改块时,模拟器都会自动重新启动并运行代码。您可以在浏览器中测试您的程序!

尝试我们的入门教程,该教程可以帮助您构建警笛程序

尝试我们的项目之一,以了解有关以下功能的更多信息:

深入研究文档

眨眼!

让我们通过构建一个简单的程序来闪烁MakeCode的工作原理,该程序使10个很棒的NeoPixels闪烁。/p》

通过将所有环形LED都设置为红色,暂停,然后将其关闭,暂停一会,然后重复永远。

让我们收集我们需要的块,将上面的描述转换为电路游乐场可以理解和运行的块:

永远 》在一个循环中运行块,中间有20ms的暂停(类似于Arduino 循环)。

显示环将颜色设置为10新像素

暂停立即阻止当前线程100毫秒。如果正在运行其他事件或永久循环,则它们此时有机会运行。

您要选择还是更改颜色? 显示环块具有内置的颜色选择器。从色轮中选择颜色以选择颜色,然后单击十个Neopixel环之一以修改其颜色。

如何禁用Neopixel?色轮的中间表示像素不正确。从色轮中选择灰色,然后单击Neopixel环。

您可以在下面的MakeCode编辑器中看到运行中的Blinky块程序。被“放在一起”。单击框中的问号将弹出注释以解释该块的作用。

单击此处以打开此项目的MakeCode编辑器!

在下一部分中,我们将加载将闪烁的代码粘贴到Circuit Playground Express上!

下载和刷新

使用MakeCode将代码轻松导入设备中。您无需在计算机上安装任何软件,该过程分为两个步骤:

步骤1:通过USB连接电路板并进入 bootloader模式

第2步:将.uf2文件编译并下载到您的木板驱动器中

我们将详细介绍这两个步骤。

步骤1:引导加载程序模式

通过USB电缆将电路板连接到计算机。按下重置按钮一次,将板置于引导加载程序模式。

如果这是您第一次运行MakeCode或以前安装了Arduino或CircuitPython的计算机,您可能需要双击重置按钮以使开发板进入引导加载程序模式。

按下重置按钮

当Circuit Playground Express处于Bootloader模式时,所有LED都将变为短暂红色,然后绿色。确认您的状态LED也在红色闪烁 。 您的计算机应显示一个名为“ CPLAYBOOT”的新可移动驱动器

如果所有LED均亮起:计算机仍在安装驱动程序(请稍等,Windows需要一些时间来安装更新。)或USB连接不良。如果您的LED指示灯持续显示红色,请尝试使用新的USB电缆(您可能希望确保USB电缆不仅仅在充电,还需要传输数据)或其他USB端口。

一旦LED都变为绿色,您应该会在文件浏览器的驱动器列表中看到一个CPLAYBOOT驱动器。

我们现在可以编译我们的闪烁代码并将其下载到

div》第2步:编译并下载

让我们首先验证我们的代码是否可以在MakeCode中正确编译。

MakeCode具有内置的模拟器,该模拟器可以在重新启动时重新加载和重新运行代码。这是在将代码移至开发板上之前确保我们的代码进行编译和仿真的一种简便方法。刷新按钮会使用最新版本的块代码重新加载模拟器。

如果收到“我们无法运行此项目”错误,请检查您的代码是否有错误。

如果您的开发板正在模拟器中运行,那么该将其下载到实际开发板上了!点击“下载”按钮。它将生成一个.uf2文件并将其下载到您的计算机(UF2是一种旨在通过USB闪存微控制器的文件格式。)

在程序上复制的常规步骤(并非特定于任何操作系统)

确保您的电路板处于引导加载程序模式。

在您的文件资源管理器中查找由MakeCode生成的.uf2文件。将其复制到“ CPLAYBOOT”卷。

文件传输过程中,板上的状态LED指示灯将闪烁。传输完文件后,开发板将自动重置并开始运行您的代码(就像在模拟器中一样!)

在Mac上,您可以放心地忽略复制.uf2文件后可能出现的“磁盘未正确弹出”通知。

Windows:打开Windows资源管理器(Windows键+ E键),然后找到您生成的“ blinky.uf2”文件。它可能在您的下载文件夹中!

您可以将文件复制/粘贴到您的 CPLAYBOOT 卷中,也可以像在GIF中一样将其拖放到

macOS :打开Finder并找到“ blinky.uf2”文件。您可以将该文件复制/粘贴到“ cplayboot”卷,或从同一查找程序窗口拖放该文件。

如果要避免复制过程,:您可以将程序直接下载到开发板上。为此,请执行以下操作:将Chrome,Firefox,Safari或Opera中的下载位置更改为“ CPLAYBOOT”卷的主目录。

正在运行已加载的MakeCode

如果您拔下主板,然后再次将其重新插入计算机,则可能不会自动再次运行该程序。如果它显示所有绿色NeoPixels,只需按一下重置按钮,程序就会启动。

保存和共享

是否要更改Blinky程序以显示不同的颜色,或使其播放声音?在Circuit Playground上编辑程序非常简单!

从Circuit Playground提取代码

通过单击MakeCode中的“编译”按钮创建的.uf2文件(CURRENT.UF2)也包含程序的源代码!

您可以打开将该文件拖放到浏览器中以在MakeCode中进行编辑。

分享

您可以通过单击共享按钮来共享代码。确认后,MakeCode将为您的代码创建一个简短的唯一URL。具有该URL的任何人都可以重新加载代码。

这些URL也可以用于将编辑器嵌入您的博客或网页!只需将URL复制粘贴到您的文本编辑器中(如果它支持oEmbed),它将自动将其加载到您的页面中。

编辑JavaScript

如果您已有一定的编码经验,或者准备下一步,MakeCode在浏览器中提供了功能全面的JavaScript编辑器!

阅读JavaScript文档

尝试一下!

您可以也可以通过单击顶部的按钮在块和JavaScript之间切换。

单击此处在MakeCode编辑器中查看此示例!

应用

MakeCode还提供了各种应用,以提供浏览器无法提供的其他功能。

Windows Store

Adafruit Windows Store应用程序的MakeCode。

超级基于HID的快速闪烁:不再需要拖放。

读取调试消息并将其显示在编辑器中(调试消息通过HID发送,而不是CDC Uart/Serial)

Node.JS

(开源)GitHub repo包含有关使用HID闪烁和串行监视运行本地node.js Web服务器的说明。

其他好东西

本指南是入门指南,但值得一提的是关于MakeCode的其他功能。..

GitHub软件包

其他块或驱动程序可以打包在github repo中并加载到通过添加软件包对话框进行编辑。软件包可以包含JavaScript,C ++,是的! ASM! https://makecode.adafruit.com/packages

我们是开源的在GitHub上

检出https://makecode.com/about,以获取有关各种存储库的更多信息。

我们提供了众包翻译

无论您要使用克林贡语还是您的非英语语言进行编码,MakeCode都可以在https://上支持众包翻译makecode.adafruit.com/translate。

MakeCode和Windows 10

几乎所有Adafruit学习系统上的教程都编写成使用户可以使用Web版本的MakeCode。该Web版本可在多种计算机类型上运行,从而具有广泛的兼容性。

Microsoft还提供了另一个版本的MakeCode,该版本的运行在Windows 10计算机上的应用程序形式。

Windows 10 Microsoft Store版本的MakeCode的最大优势是能够读回数据并轻松绘制数据,这是网络版本目前缺少。

Windows 10的MakeCode应用

Microsoft MakeCode应用位于Microsoft App Store中。

安装

在Windows 10搜索栏中(通常在“开始”按钮旁边),键入“ Microsoft Store”。在商店应用的搜索栏中,键入MakeCode。选择Adafruit的MakeCode。

单击“安装”按钮以获取Adafruit的MakeCode。该应用程序将安装,然后您可以按启动按钮。

介绍性屏幕与Web应用程序相同。

界面看上去几乎与网络版本相同,但是在下一页上有一些区别。

安装Mu编辑器

Mu是一个简单的代码编辑器,可与Adafruit CircuitPython板一起使用。它是用Python编写的,可在Windows,MacOS,Linux和Raspberry Pi上运行。内置了串行控制台,因此您可以立即从开发板的串行输出中获得反馈!

Mu是我们推荐的编辑器-请使用它(除非您已经是一位经验丰富的编码人员,并且拥有喜欢的编辑器!)

下载并安装Mu

从https://codewith.mu下载Mu。单击下载或从这里开始链接以获取下载和安装说明。该网站还有很多其他信息,包括广泛的教程和操作方法。

使用Mu

首次启动Mu时,系统会提示您选择“模式”-您可以以后总是要改变主意。现在,请选择 Adafruit !

当前模式显示在窗口的右下角,在“齿轮”图标旁边。如果模式显示“ Microbit”或其他名称,请单击该名称,然后在出现的对话框中选择“ Adafruit”。

Mu会尝试自动检测您的电路板,因此请插入CircuitPython设备并确保其显示为 CIRCUITPY 驱动器,然后再启动Mu

,现在就可以编写代码了!让我们继续吧。。..

创建和编辑代码

CircuitPython最好的事情之一就是使代码的启动和运行变得如此简单。在本节中,我们将介绍如何创建和编辑第一个CircuitPython程序。

要创建和编辑代码,只需要一个编辑器即可。有很多选择。 我们强烈建议您使用Mu!它是为CircuitPython设计的,并且非常简单易用,带有内置的串行控制台!

如果您不使用Mu,则可以使用基本的文本编辑器进入每个操作系统,例如Windows上的记事本,Mac上的TextEdit和Linux上的gedit。但是,许多这些编辑器不会立即将更改写回到您编辑的文件中。使用CircuitPython时可能会导致问题。请参阅下面的“编辑代码”部分。如果您现在想跳过该部分,请确保在不使用Mu的情况下在写入文件后在Windows上执行“弹出”或“安全删除”,或者在Linux上执行“同步”。 (在MacOS上这不是问题。)

创建代码

打开编辑器,然后创建一个新文件。如果您使用的是Mu,请单击左上角的 New 按钮

复制并粘贴将以下代码添加到编辑器中:

下载:文件

复制代码

import board

import digitalio

import time

led = digitalio.DigitalInOut(board.D13)

led.direction = digitalio.Direction.OUTPUT

while True:

led.value = True

time.sleep(0.5)

led.value = False

time.sleep(0.5) import board

import digitalio

import time

led = digitalio.DigitalInOut(board.D13)

led.direction = digitalio.Direction.OUTPUT

while True:

led.value = True

time.sleep(0.5)

led.value = False

time.sleep(0.5)

看起来像这样-请注意,在while True:行下,接下来的四行有空格以使其缩进,但是它们的缩进量完全相同。其他所有行在文本之前都没有空格。

将此文件另存为CIRCUITPY上的 code.py

。在每个板上,您都会发现一个红色的小LED。现在它应该闪烁。每秒一次

恭喜,您已经运行了第一个CircuitPython程序!

编辑代码

要编辑代码,请打开CIRCUITPY驱动器上的 code.py 文件进入编辑器。

对代码进行所需的更改。保存文件。就是这样!

文件保存完成后,您的代码更改将立即运行。

在继续之前,我们只有一个警告……

Don单击重置或拔出!

板上的CircuitPython代码将检测何时更改或写入文件,并会自动重新启动代码。

但是,这样做可以使编码变得非常快。

但是,您必须 等到文件保存完成后才能拔出或重置主板! 在使用某些编辑器的Windows上,有时可能会花费 90秒,在Linux上,则可能需要30秒来完成,因为文本编辑器不会保存完全归档。 Mac OS似乎没有此延迟,这很好!

要意识到这一点非常重要。如果在计算机完成将文件写入板之前拔出板或重置板,则可能损坏驱动器。如果发生这种情况,您可能会丢失编写的代码,因此定期将代码备份到计算机上很重要。

有几种方法可以避免这种情况:

1。保存时,请使用可以完全写出文件的编辑器。

推荐的编辑器:

mu 是可以安全地写入所有更改的编辑器(它也是我们推荐的编辑器!)

emacs 还是一个可以在保存时完全写入文件的编辑器

Sublime Text 安全地写入所有更改

Visual Studio代码似乎可以安全地写入所有更改

gedit 在Linux上似乎可以安全地写入所有更改

推荐仅具有特定设置或附加组件:

vim / vi 安全地写入所有更改。但是将 vim 设置为不将交换文件(.swp文件:您的编辑的临时记录)写入CIRCUITPY。使用vim -n运行vim,设置no swapfile选项,或设置directory选项以在其他位置写入交换文件。否则,交换文件writestrigger会重新启动程序。

如果在“设置”-》“系统设置”-》“同步”中启用了“安全写入”,则 PyCharm IDE 是安全的(默认情况下为true) 。

如果您使用的是 Atom ,请安装保存时fsync软件包,以便它始终将对CIRCUITPY上文件的所有更改写出。

SlickEdit 仅在您添加了宏来刷新磁盘时有效。

我们不推荐这些编辑器:

记事本(默认的Windows编辑器)和N otepad ++ 可能写起来很慢,因此我们建议使用上面的编辑器!如果您使用的是记事本,请确保弹出驱动器(见下文)

IDLE 不会立即强制更改

nano (在Linux上)不会强制更改

geany (在Linux上)不会强制更改

其他任何操作-我们尚未测试其他编辑器,因此请使用推荐的编辑器!

2。写入后弹出或同步驱动器

如果您使用的是我们不推荐的编辑器之一,则不会丢失所有信息!您仍然可以使其工作。

在Windows上,您可以弹出或安全删除 CIRCUITPY驱动器。它实际上不会弹出,但是会强制操作系统将文件保存到磁盘。在Linux上,在终端中使用 sync 命令来强制写入磁盘。

哦,我没有做错什么,现在CIRCUITPY驱动器没有显示!!!

别担心!损坏驱动器并不是世界末日(或您的董事会!)。如果发生这种情况,请按照每块主板指南的“故障排除”页面上的步骤操作,以重新启动您的主板。

返回编辑代码。..

现在!让我们尝试编辑添加到板上的程序。在编辑器中打开 code.py 文件。我们将进行简单的更改。将第一个0.5更改为0.1。代码应如下所示:

下载:文件

复制代码

import board

import digitalio

import time

led = digitalio.DigitalInOut(board.D13)

led.direction = digitalio.Direction.OUTPUT

while True:

led.value = True

time.sleep(0.1)

led.value = False

time.sleep(0.5) import board

import digitalio

import time

led = digitalio.DigitalInOut(board.D13)

led.direction = digitalio.Direction.OUTPUT

while True:

led.value = True

time.sleep(0.1)

led.value = False

time.sleep(0.5)

其余代码保持原样。保存文件。看看板上的LED会怎样?事情变了!你知道为什么吗?让我们找出答案吧!

探索您的第一个CircuitPython程序

首先,我们来看一下正在编辑的代码。

这又是原始代码:

下载:文件

复制代码

import board

import digitalio

import time

led = digitalio.DigitalInOut(board.D13)

led.direction = digitalio.Direction.OUTPUT

while True:

led.value = True

time.sleep(0.5)

led.value = False

time.sleep(0.5) import board

import digitalio

import time

led = digitalio.DigitalInOut(board.D13)

led.direction = digitalio.Direction.OUTPUT

while True:

led.value = True

time.sleep(0.5)

led.value = False

time.sleep(0.5)

导入和库

您运行的每个CircuitPython程序都需要掌握很多信息。 CircuitPython使用起来如此简单的原因是,大多数信息都存储在其他文件中并在后台运行。这些文件称为库。其中一些内置在CircuitPython中。其他文件则存储在您的CIRCUITPY驱动器上的 lib 文件夹中。

下载:文件

复制代码

import board

import digitalio

import time import board

import digitalio

import time

import语句告诉董事会您重新使用代码中的特定库。在此示例中,我们导入了三个库:board,digitalio和time。所有这三个库都内置在CircuitPython中,因此不需要单独的文件。这就是使它成为出色的第一个例子的原因之一。您不需要任何额外的东西即可使其正常工作! board使您可以访问板上的硬件,digitalio可以使您访问该硬件作为输入/输出,而time您通过“睡眠”来打发时间

向上发光二极管

接下来的两行代码设置使用发光二极管的代码。

下载:文件

复制代码

led = digitalio.DigitalInOut(board.D13)

led.direction = digitalio.Direction.OUTPUT led = digitalio.DigitalInOut(board.D13)

led.direction = digitalio.Direction.OUTPUT

您的主板将红色LED表示为D13。因此,我们初始化该引脚,并将其设置为输出。我们将led设置为等于该信息的其余部分,因此我们以后不必在代码中再次输入所有信息。

循环去循环

第三部分以while语句开头。 while True:本质上表示“永远执行以下操作:”。 while True:创建一个循环。代码将在条件为“ true”(相对于false)时“ while”循环,并且由于True永远都不为False,因此代码将永远循环。在while True:下缩进的所有代码都在循环“内部”。

在循环内部,我们有四个项目:

下载:文件

复制代码

while True:

led.value = True

time.sleep(0.5)

led.value = False

time.sleep(0.5) while True:

led.value = True

time.sleep(0.5)

led.value = False

time.sleep(0.5)

首先,我们有led.value = True。这条线告诉LED点亮。在下一行,我们有time.sleep(0.5)。此行告诉CircuitPython将运行代码暂停0.5秒。由于这是在打开和关闭LED之间进行的操作,因此LED将持续0.5秒。

接下来的两行类似。 led.value = False告诉LED熄灭,time.sleep(0.5)告诉CircuitPython再暂停0.5秒。

然后在再次关闭LED并重新打开LED的同时发生这种情况。

然后,循环将再次开始,只要代码正在运行,循环就会继续!

p》

因此,当您将第一个0.5更改为0.1时,可以减少代码使LED点亮的时间。因此,它会在关闭之前快速闪烁!

辛苦了!您已经在CircuitPython程序中编辑了代码!

如果我没有循环怎么办?

如果没有循环,代码将运行到最后并退出。在这样的简单程序中,这可能导致某些意想不到的行为,因为“退出”还会重置硬件状态。这与通过REPL运行命令不同。因此,如果您正在编写似乎无法正常运行的简单程序,则可能需要在最后添加一个循环,以使该程序不会退出。

最简单的循环是:

while True:

pass

记住,您可以按 退出循环。

另请参阅文档中的“行为”部分。

更多更改

我们不必在此止步!我们继续吧。将第二个0.5更改为0.1,使其如下所示:

下载:文件

复制代码

while True:

led.value = True

time.sleep(0.1)

led.value = False

time.sleep(0.1) while True:

led.value = True

time.sleep(0.1)

led.value = False

time.sleep(0.1)

现在,它闪烁的很快!您减少了代码打开和关闭LED的时间!

现在尝试将两个0.1都增加到1。您的LED指示灯闪烁的速度会慢得多,因为您增加了打开和关闭LED指示灯的时间。

做得好!你做得很好!您已经准备好开始新的示例并对其进行编辑以查看会发生什么!这些是简单的更改,但是主要更改是使用相同的过程完成的。进行所需的更改,保存并获取结果。

命名程序文件

CircuitPython在板上寻找要运行的代码文件。有四个选项: code.txt , code.py , main.txt 和 main.py 。 CircuitPython按该顺序查找那些文件,然后运行找到的第一个文件。虽然我们建议使用 code.py 作为代码文件,但重要的是要知道其他选项的存在。如果您的程序在工作时似乎没有更新,请确保没有创建另一个正在读取的代码文件,而不是正在处理的代码文件。

连接到串行控制台

CircuitPython的主要功能之一(通常是编程!)被称为“打印语句”。这是您包含在代码中的一行,使您的代码输出文本。 CircuitPython中的打印语句如下:

print(“Hello, world!”)

此行将导致:

Hello, world!

但是,这些打印语句需要在某个地方显示。串行控制台就在这里!

串行控制台接收从CircuitPython板通过USB发送的输出并显示它,以便您查看。当您在代码中包含了一条打印语句并且想要查看打印的内容时,这是必需的。这对于解决错误也很有用,因为您的电路板会发送错误,而串行控制台也会打印错误。

串行控制台需要终端程序。终端是一个程序,为您提供一个基于文本的界面来执行各种任务。

如果您使用的是Linux,并且在连接到串行控制台时遇到数秒的延迟,或者在连接时看到“ AT”和其他乱码,则说明Modemmanager服务可能会干扰。只需将其删除;除非您仍在使用拨号调制解调器,否则它用处不大。要删除,请在外壳上键入以下命令:

下载:file

复制代码

sudo apt purge modemmanager sudo apt purge modemmanager

您在使用Mu吗?

如果是,这是个好消息!串行控制台内置在Mu 中,并且会自动检测您的电路板,使用REPL 真的非常简单。

请注意Mu尚未与基于nRF52或ESP8266的CircuitPython板一起使用时,请跳至下一部分,以了解有关使用终端程序的详细信息。

首先,确保已插入CircuitPython电路板。如果使用Windows 7,请确保已安装

在Mu中,在菜单中查找 Serial 按钮,然后单击

在Linux上

设置权限

在Linux上,如果看到错误当您按下 Serial (串行)按钮,您需要将自己添加到用户组中才能具有连接到串行控制台的权限。

在Ubuntu和Debian上,通过执行以下操作将自己添加到 dialout 组中:

sudo adduser $USER dialout

运行上述命令后,重新启动计算机即可访问该组。在其他Linux发行版上,您需要的组可能不同。有关如何将您自己添加到正确的组的详细信息,请参见Mac和Linux上的高级串行控制台。

使用其他功能吗?

如果您不使用Mu进行编辑,则使用ESP8266或nRF52 CircuitPython,或者由于某些原因您不喜欢该功能内置的串行控制台,您可以将串行控制台作为单独的程序运行。

Windows要求您下载终端程序,请查看此页面以获取更多详细信息

Mac和Linux都内置了一个,尽管可以下载其他选项,请查看此页面以获取更多详细信息

与串行控制台交互

成功连接到串行控制台后,就该开始使用它了。

您编写的代码较早版本没有输出到串行控制台。因此,我们将对其进行编辑以创建一些输出。

在编辑器中打开您的code.py文件,并包含一个print语句。您可以打印任何喜欢的东西!只需将您的词组放在括号内的引号之间即可。例如:

下载:文件

复制代码

import board

import digitalio

import time

led = digitalio.DigitalInOut(board.D13)

led.direction = digitalio.Direction.OUTPUT

while True:

print(“Hello, CircuitPython!”)

led.value = True

time.sleep(1)

led.value = False

time.sleep(1) import board

import digitalio

import time

led = digitalio.DigitalInOut(board.D13)

led.direction = digitalio.Direction.OUTPUT

while True:

print(“Hello, CircuitPython!”)

led.value = True

time.sleep(1)

led.value = False

time.sleep(1)

保存文件。

现在,让我们看一下与串行控制台连接的窗口。

优秀!我们的控制台上会显示我们的打印声明!尝试将打印的文本更改为其他内容。

将串行控制台窗口保留在可以看到的位置。保存文件。您将看到板重启时串行控制台显示的内容。然后,您将看到新的更改!

Traceback (most recent call last):告诉您董事会在保存文件之前所做的最后一件事。这是正常现象,每次主板复位时都会发生。这对于故障排除非常方便。让我们介绍一个错误,以便我们可以看到它的用法。

从e行的True末尾删除led.value = True,使其显示为led.value = Tru

保存文件。您会注意到您的红色LED指示灯将停止闪烁,并且可能有彩色的状态LED指示灯向您闪烁。这是因为代码不再正确,也无法正常运行。我们需要修复它!

通常,当您遇到错误时,这并不是因为您故意引入它们。您可能有200行代码,并且不知道错误可能隐藏在哪里。这是串行控制台可以提供帮助的地方。让我们看一下!

Traceback (most recent call last):告诉您它能够运行的最后一件事是代码中的第10行。下一行是您的错误:NameError: name ‘Tru’ is not defined。该错误可能对您没有多大影响,但是结合知道问题出在第10行之后,它为您提供了一个绝佳的起点!

返回您的代码,然后看一下第10行显然,您已经知道问题所在了。但是,如果您没有这样做,则希望查看第10行,看看是否可以解决。如果仍然不确定,请尝试使用该错误来获取帮助。在这种情况下,您知道要查找什么。您拼写错了。修正错字并保存文件。

解决错误的好工作!您的串行控制台正在流式传输,并且红色LED再次闪烁。

串行控制台将显示您的代码生成的所有输出。某些传感器(例如湿度传感器或热敏电阻)会接收数据,您可以使用打印语句来显示该信息。您也可以使用打印语句进行故障排除。如果您的代码无法正常工作,并且想知道失败的地方,则可以将打印语句放在各个位置,以查看停止打印的地方。

串行控制台有很多用途,这是一个了不起的成就用于学习和编程的整体工具!

REPL

串行连接的另一个功能是 R ead- E valuate - P rint- L oop或REPL。 REPL允许您输入单独的代码行并使它们立即运行。如果您遇到某个特定程序的麻烦而又不知道原因,那将非常方便。它是交互式的,因此非常适合测试新想法。

要使用REPL,您首先需要连接到串行控制台。建立连接后,您需要按 Ctrl + C 。

如果正在运行代码,它将停止并且您会看到Press any key to enter the REPL. Use CTRL-D to reload.请按照这些说明操作,然后按键盘上的任意键。

Traceback (most recent call last):告诉您在按Ctrl + C并中断之前,董事会正在做的最后一件事。 KeyboardInterrupt是按Ctrl + C组合键。此信息在进行故障排除时会很方便,但是现在不用担心。只需注意这是预期的行为。

如果没有代码在运行,则按Ctrl + C后将立即输入REPL。由于没有代码在运行,因此在中断之前您的电路板没有任何信息。

不管哪种方式,一旦您按下一个键,您都会看到一个》》》提示符,欢迎您使用REPL!

如果无法进入》》》提示符,请尝试再按Ctrl + C几次。

从REPL获得的第一件事就是有关您的木板的信息。

此行告诉您正在使用的CircuitPython的版本以及发布的时间。接下来,它为您提供了所使用的板的类型以及该板使用的微控制器的类型。视您使用的版本而定,每个部分对于您的电路板可能会有所不同。

其后是CircuitPython提示符。

在此提示符下,您可以运行各种命令和代码。我们要做的第一件事是运行help()。这将告诉我们从哪里开始探索REPL。要在REPL中运行代码,请在REPL提示符旁边键入它。

在REPL中的提示符旁边键入help()。

然后按Enter。然后,您应该会看到一条消息。

消息的第一部分是对您正在使用的CircuitPython版本的另一个引用。其次,是CircuitPython相关项目指南的URL。那。..等等这是什么? To list built-in modules, please do `help(“modules”)`。还记得您在创建代码时学到的库吗?这就是这里所说的!这是一个理想的起点。让我们看一下!

在提示旁边的REPL中键入help(“modules”),然后按Enter。

这是CircuitPython内置的所有核心库的列表。我们讨论了电路板如何包含您可以在代码中使用的电路板上的所有引脚。在REPL中,您可以看到该列表!

在REPL中键入import board,然后按Enter。它将转到新的提示。看起来好像什么都没发生,但事实并非如此!如果您还记得的话,import语句只是告诉代码期望对该模块执行某些操作。在这种情况下,它告诉REPL您打算对该模块进行操作。

下一步,在REPL中键入dir(board)并按Enter。

这是主板上所有可用引脚的列表供您在代码中使用。每个板的列表将根据可用的引脚数而略有不同。您看到D13吗?这就是您用来使红色LED闪烁的引脚!

REPL也可以用于运行代码。请注意,您输入到REPL中的任何代码都不会保存。如果要测试要保留的新内容,请确保也将其保存在计算机上!

每种编程语言中的每个程序员都以一段代码开头, “你好,世界。”我们要和别的东西打招呼。键入REPL:

print(“Hello, CircuitPython!”)

然后按Enter。

这就是在REPL中运行代码的全部!干得好!

您可以编写单行运行的代码。您也可以将整个程序写入REPL以对其进行测试。正如我们所说,请记住,键入REPL不会保存任何内容。

REPL可以为您做很多事情。如果您想看看是否有几行新的代码行得通,这对于测试新想法非常有用。通过一次输入一行代码并找出失败的地方来对代码进行故障排除,这非常了不起。它可以让您查看可用的库并浏览这些库。

尝试在REPL中输入更多内容以查看会发生什么!

返回串行控制台

当您准备离开REPL并返回串行控制台时,只需按 Ctrl + D 。这将重新加载您的电路板并重新进入串行控制台。在输入REPL之前,您将重新启动已运行的程序。在控制台窗口中,您将看到正在运行的程序的任何输出。而且,如果您的程序影响了板上的任何视觉效果,您也会看到它再次启动。

您可以随时返回REPL!

CircuitPython库

在我们继续开发CircuitPython并创建新版本时,我们将停止支持较旧的版本。访问https://circuitpython.org/downloads为您的电路板下载最新版本的CircuitPython。您必须下载与您的CircuitPython版本匹配的CircuitPython库捆绑包。请更新CircuitPython,然后访问https://circuitpython.org/libraries下载最新的库包。

您运行的每个CircuitPython程序都需要很多工作的信息。 CircuitPython使用起来如此简单的原因是,大多数信息都存储在其他文件中并在后台运行。这些文件称为库。其中一些内置在CircuitPython中。其他的则存储在您的 CIRCUITPY 驱动器上的一个名为 lib 的文件夹中。使CircuitPython如此出色的部分原因在于它能够独立于固件本身存储代码。将代码与固件分开存储,可以更轻松地更新您编写的代码和所依赖的库。

您的开发板可能已经附带了一个 lib 文件夹,该文件夹位于基础中驱动器的目录。如果没有,只需自己创建文件夹。首次安装CircuitPython时,将为您创建一个空的 lib 目录。

CircuitPython库的工作方式与常规Python模块相同,因此Python文档为它们的工作方式提供了很好的参考。用Python术语,我们可以将库文件放置在 lib 目录中,因为默认情况下它是Python路径的一部分。

这种单独的库方法的缺点是它们是而不是内置的。要使用它们,必须先将它们复制到 CIRCUITPY 驱动器,然后才能使用它们。幸运的是,我们提供了一个完整的库捆绑包。

我们的捆绑包和发行版还具有库扩展名,带有 .mpy 。这些文件在驱动器上占用的空间更少,并且在加载时具有较小的内存占用。

安装CircuitPython库捆绑包

我们正在不断更新和改进我们的库,因此(目前)我们不这样做随我们的CircuitPython板一起提供完整的库包。相反,您可以在电路板指南中找到依赖外部库的示例代码。这些库中的某些库可以从Adafruit处获得,有些库库由社区成员编写!

无论哪种方式,当您开始探索CircuitPython时,您都想知道如何在库中使用库。

您可以通过单击下面的按钮来获取最新版本的Adafruit CircuitPython捆绑包。

注意:将捆绑包版本与您所使用的CircuitPython版本进行匹配正在运行-用于运行任何版本的CircuitPython 3的3.x库,用于运行任何版本的CircuitPython 4的4.x库,等等。如果将库与主要CircuitPython版本混合使用,则由于在运行期间库接口可能发生变化,很可能会出错主要版本更改。

单击以获取最新的Adafruit CircuitPython库捆绑软件版本

如果需要其他版本,还可以访问捆绑软件发行页面,该页面将可以让您确切选择要查找的版本以及有关更改的信息。

无论哪种方式,下载与CircuitPython固件版本匹配的版本。如果您不知道该版本,请查看CircuitPython REPL中的初始提示,其中会报告该版本。例如,如果您正在运行v4.0.1,请下载4.x库捆绑包。还有一个 py 软件包,其中包含未压缩的python文件,除非您在库上进行高级工作,否则您可能不想要。

下载zip后,解压缩其内容。这通常是通过双击拉链来完成的。在Mac OSX上,它将文件放在与zip相同的目录中。

打开包文件夹。在内部,您将找到两个信息文件和两个文件夹。一个文件夹是lib捆绑包,另一个文件夹是示例捆绑包。

现在打开lib文件夹。当您打开文件夹时,您会看到大量的 mpy 文件和文件夹

示例文件

每个库中的所有示例文件现在都包含在捆绑软件以及仅示例捆绑软件中。包含这些内容主要有两个原因:

允许快速测试设备。

提供示例代码库,可以轻松地将其用于个性化目的。

将库复制到板上

首先,您要创建 CIRCUITPY 驱动器上的 lib 文件夹。打开驱动器,右键单击,选择创建新文件夹的选项,并将其命名为 lib 。然后,打开从下载的zip提取的 lib 文件夹。在内部,您会找到许多文件夹和 .mpy 文件。找到您要使用的库,然后将其复制到 CIRCUITPY 上的lib文件夹中。

这也适用于示例文件。它们仅作为原始的 .py 文件提供,因此如果遇到以下问题,可能需要使用 mpy-cross 实用程序将它们转换为 .mpy 。 MemoryErrors。 《 CircuitPython Essentials指南》中对此进行了讨论。用法与上文“快速公告板”部分中所述的用法相同。注意:如果不将示例放在单独的文件夹中,则应从import语句中删除示例。

示例:ImportError由于缺少库

如果选择加载库根据需要,您可以编写代码尝试使用尚未加载的库。我们将演示当您尝试利用板上未加载的库时发生的情况,并介绍解决此问题所需的步骤。

此演示只会返回错误如果您没有将所需的库加载到 CIRCUITPY 驱动器上的 lib 文件夹中。

让我们使用修改后的版本示例。

下载:文件

复制代码

import board

import time

import simpleio

led = simpleio.DigitalOut(board.D13)

while True:

led.value = True

time.sleep(0.5)

led.value = False

time.sleep(0.5) import board

import time

import simpleio

led = simpleio.DigitalOut(board.D13)

while True:

led.value = True

time.sleep(0.5)

led.value = False

time.sleep(0.5)

保存此文件。董事会没有任何反应。让我们检查串行控制台以查看发生了什么。

我们有一个ImportError。它说有no module named ‘simpleio’。那就是我们刚刚包含在我们代码中的代码!

单击上面的链接下载正确的捆绑包。从下载的捆绑文件中提取lib文件夹。向下滚动以找到 simpleio.mpy 。这是我们要查找的库文件!请按照上述步骤加载单个库文件。

LED再次开始闪烁!让我们检查串行控制台。

没有错误!优秀。您已经成功解决了ImportError!

如果以后再遇到此错误,请按照上述步骤操作,然后选择与您所缺少的库匹配的库。

非Express板上的库安装

如果您有Trinket M0或Gemma M0,则需要按照上面示例中的相同步骤安装所需的库。您不必总是等待ImportError,因为您可能知道您在代码中添加了哪个库。只需打开下载的 lib 文件夹,找到所需的库,然后将其拖到 CIRCUITPY 驱动器上的 lib 文件夹中即可。

即使仅根据需要加载库,也可能最终在Trinket M0或Gemma M0上空间不足。您可以使用许多步骤来尝试解决此问题。您可以在学习板指南的“疑难解答”页面中找到它们。

更新CircuitPython库/示例

库和示例会不时更新,因此,重要的是更新 CIRCUITPY 驱动器。

要更新单个库或示例,请遵循上述相同步骤。将库文件拖到lib文件夹时,它将询问您是否要替换它。说是就是这样!

每次对库进行更新时,都会发布一个新的库捆绑包。更新内容包括错误修复和新功能。经常检查一次很重要,以查看您使用的库是否已更新。

常见问题

这些是有关CircuitPython和CircuitPython微控制器的一些常见问题。

随着我们继续开发CircuitPython和创建新版本,我们将停止支持较早的版本。访问https://circuitpython.org/downloads为您的电路板下载最新版本的CircuitPython。您必须下载与您的CircuitPython版本匹配的CircuitPython库捆绑包。请更新CircuitPython,然后访问https://circuitpython.org/libraries下载最新的库捆绑包。

我必须继续使用CircuitPython 3.x或2.x,在哪里可以找到兼容的库?

我们不再构建或支持CircuitPython 2.x和3.x库包。我们强烈建议您将CircuitPython更新到最新版本并使用当前版本的库。。但是,如果由于某种原因而无法更新,则可以在此处找到最后一个可用的2.x版本和最后一个可用的3版本。 .x在此处构建。

CircuitPython是否支持ESP8266或ESP32?为什么不呢?

我们从4.x版本开始不再支持ESP8266-对于更多信息,请在这里阅读!

https://learn.adafruit.com/welcome-to-circuitpython/circuitpython-for-esp8266

div》

如何使用CircuitPython连接到Internet?

如果您想添加WiFi支持,请参阅我们的ESP32/ESP8266作为协处理器的指南。

CircuitPython中是否有异步支持 》

我们目前在CircuitPython中没有异步支持

我的RGB NeoPixel/点星形LED闪烁有趣的颜色-这是什么意思?

状态LED可以告诉您CircuitPython开发板的最新动态。

什么是MemoryError?

当您尝试在板上存储过多存储空间时会发生内存分配错误。 CircuitPython微控制器板的可用内存量有限。 M0 Express板上可以包含约250行代码。如果您尝试import太多的库,大型库的组合,或者运行的程序包含太多的代码行,则您的代码将无法运行,并且您会在串行控制台中收到MemoryError (REPL)。

当我遇到MemoryError吗?

尝试重置主板。每次重置板卡时,它都会重新分配内存。虽然这不太可能解决您的问题,但这是一个简单的步骤,值得尝试。

请确保您使用的是库的 .mpy 版本。捆绑包中的所有CircuitPython库均以 .mpy 格式提供,与.py格式相比占用的内存更少。确保您使用的是最新版本的CircuitPython库包。

如果这不能解决问题,请尝试缩短代码。缩短注释,删除多余或不需要的代码,或执行其他任何清理操作以缩短代码。如果您使用了很多函数,则可以尝试将它们移至单独的库中,创建该库的.mpy并将其导入代码中。

您可以将整个函数文件放入.mpy,将import放入code.py。这意味着您将无法在板上实时编辑代码,但可以节省空间。

我的import语句的顺序会影响内存吗?

这可能是因为内存根据分配顺序和大小的不同而碎片化了对象。加载.mpy文件会占用较少的内存,因此建议您对未编辑的文件执行此操作。

如何创建自己的.mpy文件?

您可以使用以下方法制作自己的.mpy版本的文件: mpy-cross。

您可以从CircuitPython版本页面(最新的2.x版本)为您的操作系统下载mpy-cross的CircuitPython 2.x版本。

您可以通过克隆CircuitPython GitHub存储库并在mpy-cross目录中运行make来为CircuitPython 3.x构建circuitpython/mpy-cross/。然后运行。/mpy-cross path/to/foo.py在与原始文件相同的目录中创建foo.mpy。

如何查看我有多少可用内存?

import gc

gc.mem_free()

将为您提供可用的字节数。

CircuitPython是否支持中断?

否。 CircuitPython当前不支持中断。我们尚无确定何时将其包含在内。

Feather M0是否支持WINC1500?

否,WINC1500将不适合M0闪存空间。

诸如ATmega328或ATmega2560的AVR可以运行CircuitPython吗?

否。

常用的首字母缩写

CP或CPy = CircuitPython

CPC =游乐场经典版

CPX =游乐场特快版

故障排除

有时,在使用CircuitPython时会遇到问题。这是您可能会遇到的一些问题以及如何解决它们。

继续开发CircuitPython并创建新版本,我们将停止支持旧版本。访问https://circuitpython.org/downloads为您的电路板下载最新版本的CircuitPython。您必须下载与您的CircuitPython版本匹配的CircuitPython库捆绑包。请更新CircuitPython,然后访问https://circuitpython.org/libraries下载最新的库捆绑包。

始终运行最新版本的CircuitPython和库

在继续开发CircuitPython和创建新版本时,我们将不再支持较旧版本发布。 您需要更新到最新的CircuitPython。

您需要下载与您的CircuitPython版本匹配的CircuitPython库捆绑包。 请更新CircuitPython,然后下载最新的软件包。

当我们发布CircuitPython的新版本时,我们将停止提供以前的软件包作为Adafruit CircuitPython库软件包仓库中自动创建的下载文件。 。如果必须继续使用早期版本,则仍可以从CircuitPython存储库上特定版本的CircuitPython中下载mpy-cross的相应版本,并创建自己的兼容.mpy库文件。 但是,最好将CircuitPython和库捆绑包都更新为最新版本。

我必须继续使用CircuitPython 3.x或2.x,在哪里可以找到兼容的库?

我们是不再构建或支持CircuitPython 2.x和3.x库包。我们强烈建议您将CircuitPython更新到最新版本并使用当前版本的库。。但是,如果由于某种原因而无法更新,则可以在此处找到最后一个可用的2.x版本和最后一个可用的3版本。 .x在此处构建。

CPLAYBOOT,TRINKETBOOT ,FEATHERBOOT或GEMMABOOT驱动器不存在 ,您可能拥有其他板子。

只有Adafruit Express板子和Trinket M0和Gemma M0板子才装有UF2引导程序。 Feather M0 Basic,Feather M0 Adalogger和类似的电路板使用常规的Arduino兼容引导加载程序,该引导加载程序不显示boardnameBOOT驱动器。

MakeCode

如果您正在Circuit Playground Express上运行MakeCode程序,只需按一下重置按钮即可显示CPLAYBOOT驱动器。两次按下将不起作用。

Windows 10

您是否误安装了Adafruit Windows Drivers软件包?对于大多数Adafruit板,您不需要在Windows 10上安装此软件包。旧版本(v1.5)可能会干扰您的设备识别。转到设置-》 应用,并卸载所有“ Adafruit”驱动程序。

Windows 7

最新版本的Adafruit Windows驱动程序(2.0.0.0版或更高版本)将解决Windows 7上缺少的boardnameBOOT驱动器问题。要解决此问题,请先卸载旧版本的驱动程序:

拔下所有板子。在卸载或更改程序(控制面板-》程序-》卸载程序)中,卸载所有名为“ Windows Driver Package-Adafruit Industries LLC 。..”的内容。

现在安装新的2.3.0.0(或更高版本)的Adafruit Windows驱动程序包:

安装最新的Windows驱动程序

运行时安装程序,将显示一个可供选择的驱动程序列表。您可以选中和取消选中复选框以选择要安装的驱动程序。

现在应该完成!通过拔下并重新插入电路板进行测试。您应该看到CIRCUITPY驱动器,然后双击重置按钮(单击运行MakeCode的Circuit Playground Express一次),您应该看到相应的boardnameBOOT驱动器。

如果这不适合您,请在Adafruit支持论坛或Adafruit Discord上告诉我们!

访问boardnameBOOT驱动器时Windows资源管理器锁定

在Windows上,我们知道的一些第三方程序可能会引起问题。症状是您尝试访问boardnameBOOT驱动器,而Windows或Windows资源管理器似乎已锁定。已知这些程序会引起麻烦:

AIDA64 :要修复,请停止该程序。此问题已报告给AIDA64。他们获得了要测试的硬件,并发布了可解决该问题的beta版本。这可能已合并到最新版本中。如果您测试此插件,请在论坛中告诉我们。

硬盘前哨

卡巴斯基反病毒软件:修复后,您可能需要完全禁用卡巴斯基。禁用卡巴斯基的某些方面并不总是能够解决问题。已经向卡巴斯基报告了此问题。

将UF2复制到boardnameBOOT驱动器时,复制已挂起0%

在Windows上,其外部USB驱动器附带的 Western Digit(WD)实用程序干扰将UF2文件复制到boardnameBOOT驱动器。卸载该实用程序以解决问题。

未显示CIRCUITPY驱动器

卡巴斯基反病毒软件会阻止CIRCUITPY驱动器的出现。我们尚未发现可以防止这种情况的设置更改。完全卸载卡巴斯基可以解决此问题。

Norton防病毒软件可能会干扰CIRCUITPY。用户已在Windows 7上报告了此问题。该用户关闭了智能防火墙和自动保护,然后出现CIRCUITPY。

Mu中的串行控制台不显示任何内容

有时,串行控制台将完全不显示任何内容,例如例如,当当前没有代码在运行,或者在打开控制台之前没有串行输出的代码已经在运行。但是,如果您发现自己应该出现类似错误的情况,请考虑以下事项。

根据屏幕或Mu窗口的大小,在打开串行控制台时,串行控制台面板可能很小。这可能是个问题。一个基本的CircuitPython错误需要10行才能显示!

下载:文件

复制代码

Auto-reload is on. Simply save files over USB to run them or enter REPL to disable.

code.py output:

Traceback (most recent call last):

File “code.py”, line 7

SyntaxError: invalid syntax

Press any key to enter the REPL. Use CTRL-D to reload.

Auto-reload is on. Simply save files over USB to run them or enter REPL to disable.

code.py output:

Traceback (most recent call last):

File “code.py”, line 7

SyntaxError: invalid syntax

Press any key to enter the REPL. Use CTRL-D to reload.

更复杂的错误将占用更多行!

因此,如果您的串行控制台面板是高度不超过五行,您可能只会看到空白行或空白行,后跟Press any key to enter the REPL. Use CTRL-D to reload.。在这种情况下,您需要将鼠标悬停在面板顶部以利用该选项来调整串行面板的大小,或者使用右侧的滚动条向上滚动以查找消息。

这适用于任何类型的串行输出,无论是错误消息还是打印语句。因此,在开始尝试在硬件方面调试问题之前,请确保检查是否由于串行输出面板的高度而不只是错过了串行消息。

CircuitPython RGB状态灯

Feather M0 Express,Feather M4 Express,Metro M0 Express ,Metro M4 Express,ItsyBitsy M0 Express,ItsyBitsy M4 Express,Gemma M0和Trinket M0的板上都有单个NeoPixel或DotStar RGB LED,用于指示CircuitPython的状态。

电路游乐场Express没有状态指示灯。在引导加载程序中时,LED会闪烁绿色。它们在运行CircuitPython时不会指示任何状态。

以下是颜色和闪烁的含义:

稳定的绿色:code.py(或 code.txt,main.py或main.txt)正在运行

向绿色施加脉冲:code.py(等)完成或不存在

稳定黄色 :( 4.0.0-alpha.5及更高版本)CircuitPython正在等待重置以表明它应该在安全模式下启动

以脉冲方式黄色:电路Python处于安全模式:崩溃并重新启动

稳定的白色: REPL正在运行

稳定运行蓝色:boot.py正在运行

以下带有多次闪烁的颜色表示Python异常,然后表示行号错误。第一次闪烁的颜色表示错误的类型:

绿色:IndentationError

CYAN :SyntaxError

白色:NameError

橙色:OSError

紫色:ValueError

黄色:其他错误

这些错误之后会闪烁指示行号,包括位置值。 白色闪烁是数千个位置,蓝色是数百个位置,黄色是数十个位置,青色是一个人的地方。因此,例如,第32行的错误将黄色闪烁三下,然后 CYAN 闪烁两次。零表示为一个超长的暗间隙。

ValueError:不兼容的.mpy文件。

当导入以mpy二进制文件存储的模块时,会发生此错误,该二进制文件由CircuitPython的不同版本生成。它被加载到其中。特别是mpy二进制格式在CircuitPython版本2.x和3.x之间以及在1.x和2.x之间进行了更改。

例如,如果您升级了从2.x到CircuitPython 3.x,您需要下载库的更新版本,该库在import上触发了错误。它们都可以在Adafruit捆绑包中找到。

如果使用CircuitPython版本2.2.4,请确保下载文件名中具有2.0.0或更高版本的版本,以及具有3.0.0或更高版本的版本。如果使用的是CircuitPython 3.0版,则文件名应更高。

CIRCUITPY驱动器问题

您可能会发现无法再将文件保存到您的CIRCUITPY驱动器中。您可能会发现CIRCUITPY停止显示在文件资源管理器中,或显示为NO_NAME。这些是文件系统有问题的指示器。

第一次检查-您是否已使用Arduino对电路板进行编程?如果是这样,CircuitPython将不再能够提供USB服务。重置开发板,以便获得一个boardnameBOOT驱动器而不是一个CIRCUITPY驱动器,将最新版本的CircuitPython(.uf2)复制回到该板上,然后进行重置。这可能会恢复CIRCUITPY功能。

如果仍然损坏-当CIRCUITPY磁盘在通过按钮重置或与USB断开连接之前未安全弹出时,可能会损坏闪存驾驶。在Windows,Mac或Linux上都可能发生这种情况。

在这种情况下,必须完全擦除开发板,并且必须将CircuitPython重新加载到开发板上。

完成以下步骤后,您将失去董事会上的所有东西。如有可能,请复制代码,然后再继续。

最简单的方法:使用storage.erase_filesystem()

从2.3.0版开始,CircuitPython包含一个内置函数来擦除和重新格式化文件系统。如果您的电路板上有旧版本的CircuitPython,则可以执行此操作以更新到最新版本。

使用Mu或终端程序重新连接到CircuitPython。

类型:

下载:文件

复制代码

》》》 import storage

》》》 storage.erase_filesystem() 》》》 import storage

》》》 storage.erase_filesystem()

CIRCUITPY将被删除并重新格式化,然后您的电路板将重新启动。就是这样!

Circuit Playground Express,Feather M0 Express和Metro M0 Express:

如果您无法使用REPL,或者您正在运行2.3.0之前的CircuitPython版本,并且不想要升级,可以执行此操作。

1.下载正确的擦除文件:

Circuit Playground Express

羽毛M0 Express

羽毛M4 Express

Metro M0 Express

Metro M4 Express QSPI橡皮擦

格子M4 Express(QSPI)

大Central M4 Express(QSPI)

PyPortal M4 Express(QSPI)

电路游乐场Bluefruit(QSPI)

Monster M4SK(QSPI)

PyBadge/PyGamer QSPI Eraser.UF2

2.双击板上的重置按钮以调出boardnameBOOT驱动器。

3.拖动擦除.uf2文件放入boardnameBOOT驱动器。

4.板载NeoPixel将变为黄色或蓝色,表示擦除已开始。

5。大约15秒钟后,主板NeoPixel将点亮绿色。在NeoTrellis M4上,这是网格上的第一个NeoPixel。

6.双击板上的重置按钮以调出boardnameBOOT驱动器。

7.拖动适当的最新版本的CircuitPython .uf2驱动器上的cc = 1》文件。

它将自动重新启动,并且您应该在文件资源管理器中再次看到boardnameBOOT。

如果LED指示灯在步骤5期间呈红色闪烁,表示擦除失败。重复从2开始的步骤。

如果尚未为电路板下载最新版本的CircuitPython,请查看安装页面。您还需要安装您的库和代码!

旧方法:对于具有UF2引导程序(Gemma M0,Trinket M0)的非Express板:

如果您无法使用REPL,或者您正在运行CircuitPython版本2.3.0之前的版本,并且您不想升级,则可以执行此操作。

1.下载擦除文件:

Gemma M0,Trinket M0

2.双击板上的重置按钮以调出CIRCUITPY驱动器。

3.将擦除的boardnameBOOT文件拖到.uf2驱动器。

4.引导LED将再次开始闪烁,并且boardnameBOOT驱动器将重新出现。

5.将适当的最新发行版CircuitPython boardnameBOOT文件拖到.uf2驱动器。

它将自动重启,并且您应该在文件浏览器中再次看到boardnameBOOT。

如果尚未下载最新版本的CircuitPython您的面板上,请查看安装页面您还需要安装天秤座ries和代码!

没有UF2引导程序(羽毛M0基本原型,羽毛Adalogger,Arduino零)的非Express板:

如果您运行的是2.3.0之前的CircuitPython版本,并且不想升级,

只需按照以下说明使用CIRCUITPY重新加载CircuitPython,这将擦除并重新创建bossac。

p》

非Express板上文件空间不足

板上的文件系统非常小。 (比古老的软盘要小。)因此,很可能您会用完空间但不要惊慌!有两种释放空间的方法。

该板还附带Windows 7串行驱动程序!如果不需要或已经安装,请随时删除。它的大小约为12KiB。

删除某些内容!

释放空间的最简单方法是从驱动器中删除文件。也许CIRCUITPY文件夹中有一些不再使用的库,或者未使用的测试代码。不过,不要完全删除lib文件夹,只需删除不需要的内容即可。

使用标签

Python的一个独特功能是缩进代码很重要。通常建议对每个缩进使用四个空格缩进代码。通常,我们也建议这样做。 但是,存储更多人类可读代码的一个技巧是使用单个制表符进行缩进。这种方法使用缩进空间的1/4,当我们计算字节数时可能很重要。

Mac OSX喜欢添加额外的文件。

幸运的是,您可以禁用Mac上的一些其他隐藏文件OSX通过运行一些命令来添加禁用搜索索引并创建零字节占位符的功能。请按照以下步骤操作,以最大程度地利用OSX上的可用空间:

防止并删除Mac OSX隐藏文件

首先找到主板的卷名。插入木板后,在终端中运行以下命令以列出所有卷:

下载:文件

复制代码

lib ls -l /Volumes

查找名称类似于ls -l /Volumes的卷(默认用于CircuitPython)。卷的完整路径是CIRCUITPY路径。

现在按照此问题的步骤运行以下终端命令,以防止在板上创建隐藏文件:

下载:文件

复制代码

/Volumes/CIRCUITPY mdutil -i off /Volumes/CIRCUITPY

cd /Volumes/CIRCUITPY

rm -rf 。{,_.}{fseventsd,Spotlight-V*,Trashes}

mkdir .fseventsd

touch .fseventsd/no_log .metadata_never_index .Trashes

cd -

替换上面的命令中的mdutil -i off /Volumes/CIRCUITPY

cd /Volumes/CIRCUITPY

rm -rf 。{,_.}{fseventsd,Spotlight-V*,Trashes}

mkdir .fseventsd

touch .fseventsd/no_log .metadata_never_index .Trashes

cd -,如果不相同,请使用完整的木板音量路径。此时,应从开发板上清除所有隐藏文件,并阻止某些隐藏文件的创建。

但是,在某些情况下,Mac OSX仍会创建隐藏文件。特别是,如果您复制从Internet下载的文件,它将具有特殊的元数据,Mac OSX将这些元数据存储为隐藏文件。幸运的是,您可以从终端运行复制命令来不复制该隐藏的元数据文件。请参阅下面的步骤。

在Mac OSX上复制文件而不创建隐藏文件

在Mac上使用上述命令禁用并删除了隐藏文件后, OSX,您需要小心使用特殊命令将文件复制到板上,以防止将来创建隐藏文件。不幸的是,您无法在Finder中使用拖放副本,因为在某些情况下(对于从Internet下载的文件,例如Adafruit的模块),它仍会创建这些隐藏的扩展属性文件。

要复制文件或文件夹,请在终端中的 cp 命令中使用 -X 选项。例如,使用以下命令将/Volumes/CIRCUITPY文件复制到板上:

下载:文件

复制代码

foo.mpy cp -X foo.mpy /Volumes/CIRCUITPY

(将 cp -X foo.mpy /Volumes/CIRCUITPY

替换为您的文件名要复制。)或复制文件夹及其所有子文件/文件夹,请使用以下命令:

下载:文件

复制代码

foo.mpy cp -rX folder_to_copy /Volumes/CIRCUITPY

如果要复制到cp -rX folder_to_copy /Volumes/CIRCUITPY文件夹或其他文件夹,请确保该文件夹在复制之前存在。

下载:文件

复制代码

lib # if lib does not exist, you‘ll create a file named lib !

cp -X foo.mpy /Volumes/CIRCUITPY/lib

# This is safer, and will complain if a lib folder does not exist.

cp -X foo.mpy /Volumes/CIRCUITPY/lib/

其他Mac OSX节省空间的提示

如果需要查看驱动器上已使用的空间量并手动删除隐藏的文件,这里是操作方法。首先使用 df 命令列出# if lib does not exist, you’ll create a file named lib !

cp -X foo.mpy /Volumes/CIRCUITPY/lib

# This is safer, and will complain if a lib folder does not exist.

cp -X foo.mpy /Volumes/CIRCUITPY/lib/驱动器上使用的空间量:

让我们先删除CIRCUITPY个文件。

哇!我们比以前多了13 Ki!现在可以将此空间用于库和代码!

卸载CircuitPython

我们的许多开发板都可以与多种编程语言一起使用。例如,Circuit Playground Express可以与MakeCode,Code.org CS Discoveries,CircuitPython和Arduino一起使用。

也许您尝试过CircuitPython并想回到MakeCode或Arduino?没问题

随时可以随时删除/重新安装CircuitPython !哎呀,您每天都可以改变主意!

备份您的代码

在卸载CircuitPython之前,请不要忘记备份小磁盘驱动器上的代码。这意味着您的 main.py 或 code.py 任何其他文件, lib 文件夹等。删除CircuitPython时,这些文件可能会丢失,因此备份是关键!只需将文件拖到便携式计算机或台式计算机上的文件夹中,就像使用任何USB驱动器一样。

移动到MakeCode

如果您想重新使用MakeCode,这真的很容易。访问makecode.adafruit.com,找到您要上传的程序。单击下载以下载由MakeCode生成的 .uf2 文件。

现在,双击CircuitPython板,直到看到板载LED变绿并且 。.. BOOT 目录出现。

然后找到下载的MakeCode .uf2 文件,并将其拖到 。.. BOOT 驱动器上。

您的MakeCode现在正在运行,并且CircuitPython已删除。向前,您只需单击重置按钮

移至Arduino

如果要将固件更改为Arduino,这也非常简单。

首先插入板子,然后双击重置,直到获得绿色的板上LED为止-就像使用MakeCode

在Arduino IDE中一样,选择匹配的板,例如Circuit Playground Express

选择正确的匹配端口:

创建新简单的Blink草图示例:

下载:文件

复制代码

// the setup function runs once when you press reset or power the board

void setup() {

// initialize digital pin 13 as an output.

pinMode(13, OUTPUT);

}

// the loop function runs over and over again forever

void loop() {

digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)

delay(1000); // wait for a second

digitalWrite(13, LOW); // turn the LED off by making the voltage LOW

delay(1000); // wait for a second

} // the setup function runs once when you press reset or power the board

void setup() {

// initialize digital pin 13 as an output.

pinMode(13, OUTPUT);

}

// the loop function runs over and over again forever

void loop() {

digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)

delay(1000); // wait for a second

digitalWrite(13, LOW); // turn the LED off by making the voltage LOW

delay(1000); // wait for a second

}

确保LED仍为绿色,然后单击上传以上传闪烁。成功上传后,串行端口将更改,因此重新选择新的端口!

一旦上传了闪烁,您就不再需要双击进入引导加载程序模式,上传后Arduino将自动重置

欢迎来到社区!

CircuitPython是一种编程语言,入门非常简单,非常适合学习。它可以在微控制器上运行,并且可以直接使用。您可以将其插入并开始使用任何文本编辑器。最好的部分? CircuitPython带有一个很棒的支持社区。

每个人都欢迎! CircuitPython是开源的。这意味着任何人都可以使用,编辑,复制和改进它。这也意味着CircuitPython变得更好,因为您参与其中。不管这是您的第一个微控制器板还是计算机工程师,提供Adafruit CircuitPython社区都是重要的。我们将重点介绍您可以成为其中一部分的多种方式!

Adafruit Discord

Adafruit Discord服务器是最好的起点。 Discord是社区聚集在一起进行志愿活动并提供各种实时支持的地方。从一般讨论到详细的问题解决,以及介于两者之间的一切,Discord是一个数字制造商空间,来自世界各地的制造商。

有很多不同的渠道,因此您可以选择最适合自己的需求。每个通道在Discord上都显示为“ #channelname”。 #projecthelp频道可为您当前的项目提供帮助,或为下一个项目提供帮助。 #showandtell频道可用于炫耀您的最新作品。不要害怕在任何频道中提问!如果您不确定,#general是一个不错的起点。如果另一个渠道更有可能为您提供更好的答案,那么有人会指导您。

CircuitPython渠道是您处理CircuitPython问题的地方。 #circuitpython适用于新用户和开发人员,请随时提出问题或发表评论!任何经验水平的人士都可以参加。我们很想听听您怎么说!

对社区做出贡献的最简单方法是在Discord上为他人提供帮助。支持他人并不总是意味着回答问题。一起庆祝成功!庆祝你的错误!有时,只要听到别人经过类似的斗争就足以使制造商前进。

Adafruit Discord是您可以带给孙女的24x7x365黑客空间。

访问https://adafru.it/discord以注册Discord。我们期待与您见面!

Adafruit论坛

Adafruit论坛是理想的支持场所。 Adafruit有出色的付费支持人员,可以回答您可能遇到的任何问题。无论您的硬件给您带来了问题还是代码似乎都无法正常工作,论坛总是在那里供您提问。您需要一个Adafruit帐户才能发布到论坛。您可以使用从Adafruit订购的同一帐户。

尽管Discord可能会比论坛提供更快的响应,但论坛是更可靠的信息来源。如果您确定要得到Adafruit支持的答案,那么论坛是最好的选择。

论坛类别涵盖了所有主题,包括Adafruit的所有主题。在“受支持的产品和项目”下的Adafruit CircuitPython和MicroPython类别是发布CircuitPython问题的最佳位置。

请确保包括到达目的地的步骤。如果涉及布线,请张贴图片!如果您的代码给您带来麻烦,请将您的代码包括在您的帖子中!这些是确保有足够的信息来帮助您解决问题的好方法。

您可能会认为您才刚刚开始,但您肯定知道别人没有的东西。论坛的好处是您也可以帮助其他人!欢迎并鼓励大家对任何已发布的问题提供建设性的反馈。这是为社区做出贡献并分享您的知识的绝妙方法!

Adafruit Github

无论您是刚刚起步还是想要做出贡献的终生程序员,都有许多方法可以使每个人都参与构建CircuitPython。 GitHub是为CircuitPython本身做出贡献的最佳途径。如果您需要一个帐户,请访问https://github.com/并注册。

如果您是GitHub的新手或一般编程人员,那么您将有很多机会。转到GitHub上的adafruit/circuitpython,单击“问题”,您将找到一个列表,其中包含标有“良好的第一期”的问题。这些都是我们认为具有任何经验水平的人都可以帮助的事情。这些问题包括诸如更新文档,提供反馈和修复简单错误之类的选项。

已经经验丰富,正在寻找挑战?查看其余的问题列表,您会发现很多贡献的方法。您将找到从新驱动程序请求到核心模块更新的所有内容。任何级别的每个人都有很多机会!

使用CircuitPython时,您可能会发现问题。如果发现错误,那就太好了!我们喜欢虫子!将详细的问题发布到GitHub是有助于改进CircuitPython的宝贵方法。确保包括复制问题的步骤以及您认为相关的任何其他信息。越详细,越好!

测试新软件非常容易,而且非常有用。只需将最新版本的CircuitPython或库加载到CircuitPython硬件上,然后使用它。通过将新问题发布到GitHub,让我们知道您发现的任何问题。在当前和Beta版本中进行软件测试是贡献CircuitPython的非常重要的一部分。我们自己不可能找到所有问题!我们需要您的帮助以使CircuitPython变得更好。

在GitHub上,您可以提交功能请求,提供反馈,报告问题等等。如有疑问,请记住,Discord和论坛都在这里寻求帮助!

ReadTheDocs

ReadTheDocs是深入了解CircuitPython的绝佳资源。您可以在这里找到API文档和有关核心模块的详细信息。还有一个设计指南,其中包含有关CircuitPython的贡献指南。

RTD使您可以深入了解CircuitPython。有关每个核心模块的详细信息。每个模块都列出了可用的库。每个模块库页面列出了可用的参数以及每个参数的说明。在许多情况下,您会找到快速的代码示例,以帮助您了解模块和参数的工作方式,但是其中没有像《学习指南》这样的详细说明。如果您需要帮助来了解正在编写的任何CircuitPython代码的幕后情况,ReadTheDocs可以为您提供帮助!

CircuitPython内置插件

CircuitPython附带了“厨房水槽”-很多关于经典Python 3的知识和您喜欢的东西(有时称为CPython)已经起作用。有些事情不是,但是随着我们添加更多功能,我们将尝试使此列表保持更新!

这不是详尽的列表!这只是您可以使用的许多功能中的一部分。

内置且可以正常工作的东西

流控制

所有常见的if,elif,else,for,while

数学

import math将为您提供一系列方便的数学函数。

》》》 dir(math)

[‘__name__’, ‘e’, ‘pi’,

‘sqrt’, ‘pow’, ‘exp’, ‘log’, ‘cos’, ‘sin’, ‘tan’, ‘acos’, ‘asin’,

‘atan’, ‘atan2’, ‘ceil’, ‘copysign’, ‘fabs’, ‘floor’, ‘fmod’, ‘frexp’,

‘ldexp’, ‘modf’, ‘isfinite’, ‘isinf’, ‘isnan’, ‘trunc’, ‘radians’,

‘degrees’]

CircuitPython支持30位宽浮点值,因此您可以随时使用int和float。

语句,列表,数组和字典

您可以组织(),[]和{},包括字符串,对象,浮点数等。

类,对象和函数

我们使用对象和函数在我们的库中具有广泛的功能,因此请查看我们的许多示例之一,例如MCP9808库,以获取类示例。

Lambdas

是的!您可以按照自己喜欢的方式使用lambda创建函数-

》》》 g = lambda x: x**2

》》》 g(8)

64

随机数

随机数:

import random

random.random()将给出一个从0到1.0的浮点数。

random.randint(min, max)将为您提供一个在min和max之间的整数。

CircuitPython数字输入和输出

尽管以下示例使用Circuit Playground Express为了演示,该代码与Circuit Playground Bluefruit的工作方式完全相同。只需复制代码,然后遵循Circuit Playground Bluefruit!

与硬件接口的第一部分就是能够管理数字输入和输出。

这个快速入门的示例显示了如何使用Circuitpython轻松使用Circuit Playground Express按钮之一作为 input 来控制另一个数字 output -内置的LED

使用您喜欢的文本编辑器将代码块复制并粘贴到 code.py 中,然后保存文件以运行演示

下载:Project Zip 或 CircuitPlaygroundExpress_DigitalIO.py | 在Github上查看

复制代码

# Circuit Playground digitalio example

import time

import board

import digitalio

led = digitalio.DigitalInOut(board.D13)

led.switch_to_output()

button = digitalio.DigitalInOut(board.BUTTON_A)

button.switch_to_input(pull=digitalio.Pull.DOWN)

while True:

if button.value: # button is pushed

led.value = True

else:

led.value = False

time.sleep(0.01)

# Circuit Playground digitalio example

import time

import board

import digitalio

led = digitalio.DigitalInOut(board.D13)

led.switch_to_output()

button = digitalio.DigitalInOut(board.BUTTON_A)

button.switch_to_input(pull=digitalio.Pull.DOWN)

while True:

if button.value: # button is pushed

led.value = True

else:

led.value = False

time.sleep(0.01)

i》 在此示例中,我们使用内置按钮,因为它很容易上手,但是您可以使用各种不同的按钮和开关(甚至是像锡箔纸或便士这样的自制按钮)作为已连接的数字输入到数字IO键盘!

请注意,我们生气了如果代码的“ pythonic”比必要的少一些,则if/then可以用简单的led.value = not button.value代替,但是我想让它非常清楚如何测试输入。

当解释器开始评估button.value时,它将读取数字输入。

按下按钮A(左侧的按钮),板上的红色LED将会点亮!

请注意,至少在基于M0/SAMD的CircuitPython板上,使用外部按钮时,您还可以使用Pull.UP进行内部上拉,但内置按钮需要Pull.DOWN。

也许您正在使用上拉或下拉电阻设置自己的外部按钮。如果要关闭内部上拉/下拉,只需添加button.switch_to_input()。

超越了课程!

是时候展示您的新知识并尝试不同的东西了!

实验1 strong》

查看是否可以调整代码,以便使用按钮B而不是按钮A。

切换按钮仅需进行很小的更改。如果卡住了,请单击下面的模糊文本以显示提示,然后给出答案:

您需要更改一个单独的字母!

button = DigitalInOut(board.BUTTON_B)

实验2

也许您要确保红色LED不会意外发光!使其必须同时按下两个按钮才能点亮红色LED。

提示:

您需要为该变量声明一个变量第二个按钮,就像您对第一个按钮所做的一样。您还需要将其设置为具有下拉电阻的输入。

将原始的 button 变量重命名为 buttonA ,新设置为 buttonB。

要检查“ if”语句中的两个按钮,

if buttonA.value == True and buttonB.value == True:

实验3

尝试测试滑动开关而不是按钮。对于滑动开关,您需要使用 Pull.UP 而不是 Pull.DOWN 。

提示:

switch = DigitalInOut(board.SLIDE_SWITCH)

switch.direction = Direction.INPUT

switch.pull = Pull.UP

if switch.value is True: # switch is slid to the left

CircuitPython模拟输入

尽管以下示例使用Circuit Playground Express进行了演示,代码与Circuit Playground Bluefruit的工作方式完全相同。只需复制代码,然后跟随您的Circuit Playground Bluefruit!

此快速入门示例说明如何读取连接到Circuit的电位计的模拟电压Playground Express。

首先,使用三个鳄鱼夹导线将电位计连接到Circuit Playground Express,如图所示。连接是:

左电位连接到 3.3V

将中心电位计(抽头)连接到 A1

将右边电位计连接到 GND

转动电位计的旋钮时,抽头会左右旋转,从而增大或减小电阻。反过来,这会更改将由A1上的Circuit Playground Express读取的模拟电压电平。

将代码块复制并粘贴到使用您喜欢的代码编辑器code.py 并保存文件以运行演示。

下载:Project Zip 或 CircuitPlaygroundExpress_AnalogIn.py | 在Github上查看

复制代码

# Circuit Playground AnalogIn

# Reads the analog voltage level from a 10k potentiometer connected to GND, 3.3V, and pin A1

# and prints the results to the serial console.

import time

import board

import analogio

analogin = analogio.AnalogIn(board.A1)

def getVoltage(pin): # helper

return (pin.value * 3.3) / 65536

while True:

print(“Analog Voltage: %f” % getVoltage(analogin))

time.sleep(0.1)

# Circuit Playground AnalogIn

# Reads the analog voltage level from a 10k potentiometer connected to GND, 3.3V, and pin A1

# and prints the results to the serial console.

import time

import board

import analogio

analogin = analogio.AnalogIn(board.A1)

def getVoltage(pin): # helper

return (pin.value * 3.3) / 65536

while True:

print(“Analog Voltage: %f” % getVoltage(analogin))

time.sleep(0.1)

创建模拟输入

analogin = analogio.AnalogIn(board.A1)创建一个名为analogin的对象,该对象连接到Circuit Playground Express的A1垫。

您可以使用连接到Analog IO垫的许多不同类型的外部模拟传感器,例如距离传感器,柔性传感器等等!

GetVoltag e Helper

getVoltage(pin)是我们的小助手程序。默认情况下,模拟读数的范围为0(最小)至65535(最大)。该助手将转换pin.value的0-65535读数并将其转换为0-3.3V的电压读数。

主循环

主循环很简单,它将打印出电压作为浮点值(%f表示通过在每个模拟对象(在本例中为电位计)上调用getVoltage来打印为 f 浮点数。

如果您连接到串行控制台,您会看到打印出的电压。尝试旋转电位器的旋钮以查看电压变化!

CircuitPython Analog Out

此示例向您展示如何在引脚A0上设置DAC(真实模拟输出)。

A0是M0板上唯一的真实模拟输出。没有其他引脚可以实现真正的模拟输出!

使用您喜欢的编辑器将代码复制并粘贴到 code.py 中,并保存文件。

下载:Project Zip 或 CircuitPython_AnalogOut.py | 在Github上查看

复制代码

# CircuitPython IO demo - analog output

import board

from analogio import AnalogOut

analog_out = AnalogOut(board.A0)

while True:

# Count up from 0 to 65535, with 64 increment

# which ends up corresponding to the DAC‘s 10-bit range

for i in range(0, 65535, 64):

analog_out.value = i

# CircuitPython IO demo - analog output

import board

from analogio import AnalogOut

analog_out = AnalogOut(board.A0)

while True:

# Count up from 0 to 65535, with 64 increment

# which ends up corresponding to the DAC’s 10-bit range

for i in range(0, 65535, 64):

analog_out.value = i

创建模拟输出

analog_out = AnalogOut(A0)

创建一个对象analog_out并将该对象连接到 A0 ,这是M0和M4板上唯一可用的DAC引脚。 (M4有两个,A0和A1。)

设置模拟输出

SAMD21上的DAC是一个0-3.3V的10位输出。因此,从理论上讲,您将具有0.0032伏/位的分辨率。为了使CircuitPython具有足够的通用性,使其可以与具有8到16位DAC的任何芯片一起使用,DAC会采用16位值并将其内部划分。

例如,写入0等同于将其设置为0-0 V。

写入5000等同于将其设置为5000/64 = 78,以及78/1024 * 3.3V = 0.25V输出。

写入65535与1023相同,这是最高范围,您将获得3.3V输出

主循环

主循环非常简单,它遍历了DAC的整个范围,从0到65535,但是每次递增64。最终,它会为可用范围的10位中的每一个单击一个位。

CircuitPython的运行速度并不是很快,因此在最快的更新循环中,您将获得4 Hz。 DAC不适用于原样的音频输出。

Express板,例如Circuit Playground Express,Metro M0 Express,ItsyBitsy M0 Express,ItsyBitsy M4 Express,Metro M4 Express,Feather M4 Express ,或Feather M0 Express具有更多的代码空间,并且可以通过DAC执行音频播放功能。杰玛M0和小饰品M0无法!

请查看本指南的“音频输出”部分以获取示例!

查找引脚

使用下图查找带有洋红色箭头标记的A0引脚!

Circuit Playground Express

A0位于VOUT和A1之间,靠近电池端口。

小饰品M0

A0的标签为“ 1〜”小饰品!!A0位于板的中间,位于“ 0”和“ 2”之间,与红色LED相同。

Gemma M0

A0位于电路板右侧的中间,靠近On/Off开关。

羽毛M0 Express

A0位于GND和A1之间,位于板的与电池连接器相反的一侧,并朝向带有“复位”按钮的一端。

羽毛M4 Express

A0位于板的与电池连接器相反的一侧的GND和A1之间,朝向带有Reset按钮的一端,而p垫中有左右白色括号标记

ItsyBitsy M0 Express

A0位于VHI和A1之间,在“ Adafruit”中的“ A”附近,并且针垫周围有左右白色的括号标记。

ItsyBitsy M4 Express

A0位于VHI和A1之间,且引脚垫

Metro M0 Express

A0位于VIN和A1之间,并且位于将与桶形插孔适配器相同的板侧朝向板的那一侧的接头连接器的中间。

Metro M4 Express

A0在VIN和A1之间,并且沿着与桶形插孔适配器相同的方向位于板的同一侧,朝向板那侧的插头的中间。

在Metro M4 Express上,有两个真实的模拟输出:A0和A1。

CircuitPython PWM

您的开发板具有pulseio支持,这意味着您可以使用PWM LED,控制伺服器,蜂鸣压电和管理“脉冲序列”类型的设备,例如DHT22和红外线。

几乎每个引脚都支持PWM!例如,所有ATSAMD21板都有一个 A0 引脚,该引脚为‘true’模拟输出,而不具有PWM支持。

固定频率的PWM

此示例将向您展示如何使用PWM淡化板上的红色LED。

使用您喜欢的编辑器将代码复制并粘贴到 code.py 中,然后保存文件。

下载:Project Zip 或 CircuitPython_PWM.py | 在Github上查看

复制代码

import time

import board

import pulseio

led = pulseio.PWMOut(board.D13, frequency=5000, duty_cycle=0)

while True:

for i in range(100):

# PWM LED up and down

if i 《 50:

led.duty_cycle = int(i * 2 * 65535 / 100) # Up

else:

led.duty_cycle = 65535 - int((i - 50) * 2 * 65535 / 100) # Down

time.sleep(0.01)

import time

import board

import pulseio

led = pulseio.PWMOut(board.D13, frequency=5000, duty_cycle=0)

while True:

for i in range(100):

# PWM LED up and down

if i 《 50:

led.duty_cycle = int(i * 2 * 65535 / 100) # Up

else:

led.duty_cycle = 65535 - int((i - 50) * 2 * 65535 / 100) # Down

time.sleep(0.01)

创建PWM输出

led = pulseio.PWMOut(board.D13, frequency=5000, duty_cycle=0)

我们使用的是板载LED,我们将其称为对象led,使用pulseio.PWMOut创建输出并传递D13 LED引脚以供使用。

主循环

主循环使用range()循环循环。当范围低于50时,它将使LED亮度升高,而当范围高于50时,将PWM降低亮度。

需要time.sleep(),以使PWM过程在一段时间内发生,这就是它如何使LED变亮和变暗。否则,您看不到它发生得太快!

可变频率的PWM输出

固定频率输出非常适合脉冲LED或控制伺服器。但是,如果要用压电蜂鸣器,则需要改变频率。

下面的示例使用pulseio在压电体上产生一系列音调。

要与任何M0板一起使用,无需更改以下代码。

要与Metro M4 Express,ItsyBitsy M4 Express或Feather M4 Express一起使用,您需要必须注释掉 piezo = pulseio.PWMOut(board.A2, duty_cycle=0, frequency=440, variable_frequency=True) 行,并取消注释 piezo = pulseio.PWMOut(board.A1, duty_cycle=0, frequency=440, variable_frequency=True) 行。 M2板上不支持A2 PWM引脚!

记住:要“注释掉”一行,请在其前面加上#和空格。要“取消注释”一行,请从该行的开头删除#+空格。

下载:Project Zip 或 CircuitPython_PWM_Piezo.py | 在Github上查看

复制代码

import time

import board

import pulseio

# For the M0 boards:

piezo = pulseio.PWMOut(board.A2, duty_cycle=0, frequency=440, variable_frequency=True)

# For the M4 boards:

# piezo = pulseio.PWMOut(board.A1, duty_cycle=0, frequency=440, variable_frequency=True)

while True:

for f in (262, 294, 330, 349, 392, 440, 494, 523):

piezo.frequency = f

piezo.duty_cycle = 65536 // 2 # On 50%

time.sleep(0.25) # On for 1/4 second

piezo.duty_cycle = 0 # Off

time.sleep(0.05) # Pause between notes

time.sleep(0.5)

import time

import board

import pulseio

# For the M0 boards:

piezo = pulseio.PWMOut(board.A2, duty_cycle=0, frequency=440, variable_frequency=True)

# For the M4 boards:

# piezo = pulseio.PWMOut(board.A1, duty_cycle=0, frequency=440, variable_frequency=True)

while True:

for f in (262, 294, 330, 349, 392, 440, 494, 523):

piezo.frequency = f

piezo.duty_cycle = 65536 // 2 # On 50%

time.sleep(0.25) # On for 1/4 second

piezo.duty_cycle = 0 # Off

time.sleep(0.05) # Pause between notes

time.sleep(0.5)

如果您将simpleio库加载到板上的/lib文件夹中,则我们有一个一个不错的小帮手,只需一个命令即可为压电音调音调。

要与任何M0板一起使用,无需更改以下代码。

要与Metro M4 Express,ItsyBitsy M4 Express或Feather M4 Express一起使用,必须注释掉 simpleio.tone(board.A2, f, 0.25) 行并取消注释 simpleio.tone(board.A1, f, 0.25) 线。 M2板上不支持A2 PWM引脚!

下载:项目邮编或 CircuitPython_PWM_Piezo_simpleio.py | 在Github上查看

复制代码

import time

import board

import simpleio

while True:

for f in (262, 294, 330, 349, 392, 440, 494, 523):

# For the M0 boards:

simpleio.tone(board.A2, f, 0.25) # on for 1/4 second

# For the M4 boards:

# simpleio.tone(board.A1, f, 0.25) # on for 1/4 second

time.sleep(0.05) # pause between notes

time.sleep(0.5)

import time

import board

import simpleio

while True:

for f in (262, 294, 330, 349, 392, 440, 494, 523):

# For the M0 boards:

simpleio.tone(board.A2, f, 0.25) # on for 1/4 second

# For the M4 boards:

# simpleio.tone(board.A1, f, 0.25) # on for 1/4 second

time.sleep(0.05) # pause between notes

time.sleep(0.5)

如您所见,它要简单得多!

连接起来

使用下图帮助您连接压电。将压电的一根脚连接到M0板上的 A2 引脚或M4板上的 A1 上,另一根脚接地接地。哪条腿连接到哪个引脚都没有关系。它们是可互换的!

Circuit Playground Express

使用鳄鱼夹连接 A2 和任何 GND 到压电的不同支路。

CPX在以下引脚上具有PWM: A1,A2,A3,A6,RX,LIGHT,A8,温度,A9,BUTTON_B,D5,SLIDE_SWITCH,D7,D13,REMOTEIN,IR_RX,REMOTEOUT,IR_TX,IR_PROXIMITY,MICROPHONE_CLOCK,MICROPHONE_DATA,ACCELEROMETER_INTERRUPT,ACCELEROMETER_SDA,ACCE 》

没有PWM: A0,SPEAKER,A4,SCL,A5,SDA,A7,TX,BUTTON_A,D4,NEOPIXEL,D8,SCK,MOSI,MISO,FLASH_CS 。

小饰品M0

注意:小饰品上的A2也标记为数字“ 0”!

使用跳线将 GND 和 D0 连接到压电的不同支脚。

Trinket在以下引脚上具有PWM: D0,A2,SDA,D2,A1,SCL,MISO,D4,A4,TX,MOSI,D3,A3,RX,SCK,D13,APA102_MOSI,APA102_SCK。

A0,D1上没有PWM。

Gemma M0

使用鳄鱼夹将 A2 和 GND 附加到压电的不同支脚上。

在以下引脚上可以使用PWM:A1,D2,RX,SCL,A2,D0,TX,SDA,L,D13,APA102_MOSI,APA102_SCK。

上没有PWM :A0,D1。

羽毛M0 Express

使用跳线连接 A2 和其中之一

羽毛M0 Express在以下引脚上具有PWM: A2,A3,A4, SCK,MOSI,MISO,D0,RX,D1,TX,SDA,SCL,D5,D6,D9,D10,D11,D12,D13,NEOPIXEL 。

没有PWM:A0,A1,A5。

羽毛M4 Express

使用跳线连接 A1 和一根

中的两个 GND 中的一个。

要使用A1,请注释掉当前的引脚设置线,并取消标记为M4板。参见上面的详细信息!

羽毛M4 Express在以下引脚上具有PWM:A1,A3,SCK,D0,RX,D1,TX,SDA,SCL,D4,D5 ,D6,D9,D10,D11,D12,D13。

上没有PWM:A0,A2,A4,A5,MOSI,MISO。

ItsyBitsy M0 Express

使用跳线将 A2 和 G 附加到压电的不同分支上。

ItsyBitsy M0 Express在以下引脚上具有PWM: D0,RX,D1,TX,D2,D3,D4,D5,D6,D7,D8,D9,D10,D11, D12,D13,L,A2,A3,A4,MOSI,MISO,SCK,SCL,SDA,APA102_MOSI,APA102_SCK。

没有PWM开启:A0,A1,A5。

ItsyBitsy M4 Express

使用跳线将 A1 和 G 附加到压电的不同支脚上。

要使用A1,请注释掉当前的引脚设置行,并取消标记为M4板的行的注释。请参阅上面的详细信息!

ItsyBitsy M0 Express在以下引脚上具有PWM:A1,D0,RX,D1,TX,D2,D4,D5,D7,D9,D10 ,D11,D12,D13,SDA,SCL。

没有PWM:A2,A3,A4,A5,D3,SCK,MOSI,MISO。

Metro M0 Express

使用跳线将 A2 和 GND 中的任何一个连接到压电的不同支线上。

Metro M0 Express在以下引脚上具有PWM: A2,A3,A4,D0,RX,D1,TX,D2,D3,D4,D5,D6,D7,D8,D9 ,D10,D11,D12,D13,SDA,SCL,NEOPIXEL,SCK,MOSI,MISO 。

上没有PWM:A0,A1,A5 ,FLASH_CS。

Metro M4 Express

使用跳线将 A1 和 GND 中的任何一个连接到压电的不同支线上。

要使用A1,请注释掉当前的引脚设置行,并取消标记为M4板的行的注释。请参阅上面的详细信息!

Metro M4 Express的PWM开启:A1,A5,D0,RX,D1,TX,D2,D3,D4,D5,D6,D7,D8,D9, D10,D11,D12,D13,SDA,SCK,MOSI,MISO

上没有PWM:A0,A2,A3,A4,SCL,AREF,NEOPIXEL,LED_RX ,LED_TX。

“我的PWM”在哪里?

是否要查看自己的PWM引脚?我们已经编写了这个方便的脚本!它尝试在每个可用引脚上设置PWM,并让您知道哪些有效,哪些无效。

下载:Project Zip 或 PWM_Test_Script.py | 在Github上查看

复制代码

import board

import pulseio

for pin_name in dir(board):

pin = getattr(board, pin_name)

try:

p = pulseio.PWMOut(pin)

p.deinit()

print(“PWM on:”, pin_name) # Prints the valid, PWM-capable pins!

except ValueError: # This is the error returned when the pin is invalid.

print(“No PWM on:”, pin_name) # Prints the invalid pins.

except RuntimeError: # Timer conflict error.

print(“Timers in use:”, pin_name) # Prints the timer conflict pins.

except TypeError: # Error returned when checking a non-pin object in dir(board)。

pass # Passes over non-pin objects in dir(board)。

import board

import pulseio

for pin_name in dir(board):

pin = getattr(board, pin_name)

try:

p = pulseio.PWMOut(pin)

p.deinit()

print(“PWM on:”, pin_name) # Prints the valid, PWM-capable pins!

except ValueError: # This is the error returned when the pin is invalid.

print(“No PWM on:”, pin_name) # Prints the invalid pins.

except RuntimeError: # Timer conflict error.

print(“Timers in use:”, pin_name) # Prints the timer conflict pins.

except TypeError: # Error returned when checking a non-pin object in dir(board)。

pass # Passes over non-pin objects in dir(board)。

CircuitPython伺服器

为了使用伺服器,我们利用了pulseio的优势。现在,从理论上讲,您可以只使用原始的pulseio调用将频率设置为50 Hz,然后设置脉冲宽度。但是,我们宁愿使它更加优雅和容易!

因此,我们将使用adafruit_motor,它可以为您很好地管理伺服器! adafruit_motor是一个库,因此请确保从库捆绑中获取它!如果您在安装库方面需要帮助,请查看CircuitPython库页面。

伺服系统分为两种类型:

标准业余伺服器-喇叭移动180度(从零度到每个方向90度)。

连续伺服-喇叭移动180度,就像直流电动机一样。代替指定的角度,您可以将油门值设置为1.0向前全开,0.5向前半开,0停止,-1反向全开,其他值在之间。

伺服接线

伺服仅适用于具有PWM功能的引脚!检查您的电路板详细信息,以验证哪些引脚具有PWM输出。

伺服的连接与标准伺服和连续旋转伺服相同。

将伺服器的棕色或黑色接地线连接到CircuitPython板上的接地。

连接伺服器的红色电源线转为5V电源,USB电源适合一两个伺服器。除此之外,您还需要一个外部电池组。请勿使用3.3V为伺服器供电!

将伺服器的黄色或白色信号线连接到控制/数据引脚,在这种情况下 A1或 A2 ,但您可以使用任何具有PWM功能的引脚。

例如,要将伺服器连接到小装饰品,请将接地线连接到 GND ,电源线 USB ,信号线 0 。

记住,《小装饰品上的strong》 A2标记为“ 0”。

对于 Gemma ,请使用跨接线鳄鱼夹将接地线连接到 GND ,电源线连接到 VOUT ,信号线连接到 A2 。

对于 Circuit Playground Express和Circuit Playground Bluefruit ,请使用跨接线鳄鱼夹将接地线连接到 GND ,电源线连接到 VOUT ,信号线连接到 A2 。

对于诸如羽毛M0 Express , ItsyBitsy M0 Express 和 Metro M0 Express ,将地线连接到任何 GND ,将电源线连接到 USB或5V ,将信号线连接到 A2 。

对于 Metro M4 Express , ItsyBitsy M4 Express 和 Feather M4 Express ,将接地线连接到任何 G或 GND ,电源线连接到 USB或 5V ,信号线连接到 A1 。

标准伺服代码

下面是一个示例,该示例会将连接到引脚 A2 的伺服器从0度扫描到180度(-90至90度),然后反转:

下载:Project Zip 或 CircuitPython_Servo.py | span》 在Github上查看

复制代码

import time

import board

import pulseio

from adafruit_motor import servo

# create a PWMOut object on Pin A2.

pwm = pulseio.PWMOut(board.A2, duty_cycle=2 ** 15, frequency=50)

# Create a servo object, my_servo.

my_servo = servo.Servo(pwm)

while True:

for angle in range(0, 180, 5): # 0 - 180 degrees, 5 degrees at a time.

my_servo.angle = angle

time.sleep(0.05)

for angle in range(180, 0, -5): # 180 - 0 degrees, 5 degrees at a time.

my_servo.angle = angle

time.sleep(0.05)

import time

import board

import pulseio

from adafruit_motor import servo

# create a PWMOut object on Pin A2.

pwm = pulseio.PWMOut(board.A2, duty_cycle=2 ** 15, frequency=50)

# Create a servo object, my_servo.

my_servo = servo.Servo(pwm)

while True:

for angle in range(0, 180, 5): # 0 - 180 degrees, 5 degrees at a time.

my_servo.angle = angle

time.sleep(0.05)

for angle in range(180, 0, -5): # 180 - 0 degrees, 5 degrees at a time.

my_servo.angle = angle

time.sleep(0.05)

连续伺服代码

与C有两个区别连续Servos与标准Servos:

servo对象的创建方式类似于my_servo = servo.ContinuousServo(pwm),而不是my_servo = servo.Servo(pwm)

,而不是使用myservo.angle,则使用my_servo.throttle,并使用从1.0(全开)到0.0(停止)到-1.0(全反向)的油门值。两者之间的任何数字都将是部分速度向前(正)或反向(负)。这与使用 adafruit_motor 库的标准直流电动机控制非常相似。

此示例将正向运行2秒钟,停止运行2秒钟,向后运行完全反转。 2秒,然后停止4秒。

下载:Project Zip 或 CircuitPython_Continuous_Servo.py | 在Github上查看

复制代码

# Continuous Servo Test Program for CircuitPython

import time

import board

import pulseio

from adafruit_motor import servo

# create a PWMOut object on Pin A2.

pwm = pulseio.PWMOut(board.A2, frequency=50)

# Create a servo object, my_servo.

my_servo = servo.ContinuousServo(pwm)

while True:

print(“forward”)

my_servo.throttle = 1.0

time.sleep(2.0)

print(“stop”)

my_servo.throttle = 0.0

time.sleep(2.0)

print(“reverse”)

my_servo.throttle = -1.0

time.sleep(2.0)

print(“stop”)

my_servo.throttle = 0.0

time.sleep(4.0)

# Continuous Servo Test Program for CircuitPython

import time

import board

import pulseio

from adafruit_motor import servo

# create a PWMOut object on Pin A2.

pwm = pulseio.PWMOut(board.A2, frequency=50)

# Create a servo object, my_servo.

my_servo = servo.ContinuousServo(pwm)

while True:

print(“forward”)

my_servo.throttle = 1.0

time.sleep(2.0)

print(“stop”)

my_servo.throttle = 0.0

time.sleep(2.0)

print(“reverse”)

my_servo.throttle = -1.0

time.sleep(2.0)

print(“stop”)

my_servo.throttle = 0.0

time.sleep(4.0)

非常简单!

请注意,我们假设0度为0.5毫秒,而180度为2.5毫秒的脉冲宽度。这比官方 1-2ms脉冲宽度稍宽。如果您使用的伺服器具有不同的范围,则可以使用不同的servo和min_pulse初始化max_pulse对象。例如:

servo = adafruit_motor.servo.Servo(pwm, min_pulse = 500, max_pulse = 2500)

有关在CircuitPython中使用伺服的更多详细信息,请查看伺服指南的CircuitPython部分!

CircuitPython音频输出

尽管以下示例使用Circuit Playground Express进行了演示,代码与Circuit Playground Bluefruit的工作方式完全相同。只需复制代码,然后遵循Circuit Playground Bluefruit!

Circuit Playground Express具有一些不错的内置音频输出功能。

有两种方法来获得音频输出,一种是通过内置的小型扬声器。另一种是通过使用鳄鱼夹将耳机或有源扬声器连接到 A0/AUDIO 引脚。

扬声器在这里,虽然很小,但可以发出很大的声音!您可以启用或禁用扬声器。如果禁用扬声器,则音频只会从 A0/AUDIO 引脚输出。如果启用扬声器,则音频将同时从两者中发出!

如果要连接扬声器或耳机,请使用两个鳄鱼夹并将 GND 连接到耳机的套管,并将 A0/AUDIO 连接到尖端。

A0/AUDIO引脚不能直接驱动扬声器,请仅连接耳机或有源扬声器!

基本音调

我们可以先制作简单的音调。我们将播放正弦波。首先,我们使用math.sin函数在python中生成一个正弦波的单个周期,并将其粘贴到sine_wave中。

然后,通过设置SPEAKER_ENABLE引脚作为输出,而True。

我们可以使用此行创建音频对象,该行设置输出引脚和正弦波采样对象并为其提供采样数组

audio = AudioOut(board.SPEAKER)

sine_wave_sample = RawSample(sine_wave)

最后,您可以运行audio.play()-如果您只想播放一次样本,请直接调用。如果您希望它 loop 样本,我们肯定会这样做,它会发出一种长音,然后传入loop=True

将在后台播放,直到您调用audio.stop()

下载:Project Zip 或 CircuitPlaygroundExpress_AudioSine.py | 在Github上查看

复制代码

import time

import array

import math

import board

import digitalio

try:

from audiocore import RawSample

except ImportError:

from audioio import RawSample

try:

from audioio import AudioOut

except ImportError:

try:

from audiopwmio import PWMAudioOut as AudioOut

except ImportError:

pass # not always supported by every board!

FREQUENCY = 440 # 440 Hz middle ‘A’

SAMPLERATE = 8000 # 8000 samples/second, recommended!

# Generate one period of sine wav.

length = SAMPLERATE // FREQUENCY

sine_wave = array.array(“H”, [0] * length)

for i in range(length):

sine_wave[i] = int(math.sin(math.pi * 2 * i / 18) * (2 ** 15) + 2 ** 15)

# Enable the speaker

speaker_enable = digitalio.DigitalInOut(board.SPEAKER_ENABLE)

speaker_enable.direction = digitalio.Direction.OUTPUT

speaker_enable.value = True

audio = AudioOut(board.SPEAKER)

sine_wave_sample = RawSample(sine_wave)

audio.play(sine_wave_sample, loop=True) # Keep playing the sample over and over

time.sleep(1) # until.。.

audio.stop() # We tell the board to stop

import time

import array

import math

import board

import digitalio

try:

from audiocore import RawSample

except ImportError:

from audioio import RawSample

try:

from audioio import AudioOut

except ImportError:

try:

from audiopwmio import PWMAudioOut as AudioOut

except ImportError:

pass # not always supported by every board!

FREQUENCY = 440 # 440 Hz middle ‘A’

SAMPLERATE = 8000 # 8000 samples/second, recommended!

# Generate one period of sine wav.

length = SAMPLERATE // FREQUENCY

sine_wave = array.array(“H”, [0] * length)

for i in range(length):

sine_wave[i] = int(math.sin(math.pi * 2 * i / 18) * (2 ** 15) + 2 ** 15)

# Enable the speaker

speaker_enable = digitalio.DigitalInOut(board.SPEAKER_ENABLE)

speaker_enable.direction = digitalio.Direction.OUTPUT

speaker_enable.value = True

audio = AudioOut(board.SPEAKER)

sine_wave_sample = RawSample(sine_wave)

audio.play(sine_wave_sample, loop=True) # Keep playing the sample over and over

time.sleep(1) # until.。.

audio.stop() # We tell the board to stop

播放音频文件

声音很可爱,但可以播放一些音乐!您可以将音频文件拖放到 CIRCUITPY 驱动器上,然后使用Python命令播放它们。

这是我们要播放的两个文件:

rimshot.wav

laugh.wav

点击绿色按钮下载wave文件,并将其保存到您的 CIRCUITPY 驱动器,以及您的 code.py 和 lib 文件

这是我们将使用的示例代码

下载:Project Zip 或 CircuitPlaygroundExpress_AudioFiles.py | 在Github上查看

复制代码

import board

import digitalio

try:

from audiocore import WaveFile

except ImportError:

from audioio import WaveFile

try:

from audioio import AudioOut

except ImportError:

try:

from audiopwmio import PWMAudioOut as AudioOut

except ImportError:

pass # not always supported by every board!

# Enable the speaker

spkrenable = digitalio.DigitalInOut(board.SPEAKER_ENABLE)

spkrenable.direction = digitalio.Direction.OUTPUT

spkrenable.value = True

# Make the 2 input buttons

buttonA = digitalio.DigitalInOut(board.BUTTON_A)

buttonA.direction = digitalio.Direction.INPUT

buttonA.pull = digitalio.Pull.DOWN

buttonB = digitalio.DigitalInOut(board.BUTTON_B)

buttonB.direction = digitalio.Direction.INPUT

buttonB.pull = digitalio.Pull.DOWN

# The two files assigned to buttons A & B

audiofiles = [“rimshot.wav”, “laugh.wav”]

def play_file(filename):

print(“Playing file: ” + filename)

wave_file = open(filename, “rb”)

with WaveFile(wave_file) as wave:

with AudioOut(board.SPEAKER) as audio:

audio.play(wave)

while audio.playing:

pass

print(“Finished”)

while True:

if buttonA.value:

play_file(audiofiles[0])

if buttonB.value:

play_file(audiofiles[1])

import board

import digitalio

try:

from audiocore import WaveFile

except ImportError:

from audioio import WaveFile

try:

from audioio import AudioOut

except ImportError:

try:

from audiopwmio import PWMAudioOut as AudioOut

except ImportError:

pass # not always supported by every board!

# Enable the speaker

spkrenable = digitalio.DigitalInOut(board.SPEAKER_ENABLE)

spkrenable.direction = digitalio.Direction.OUTPUT

spkrenable.value = True

# Make the 2 input buttons

buttonA = digitalio.DigitalInOut(board.BUTTON_A)

buttonA.direction = digitalio.Direction.INPUT

buttonA.pull = digitalio.Pull.DOWN

buttonB = digitalio.DigitalInOut(board.BUTTON_B)

buttonB.direction = digitalio.Direction.INPUT

buttonB.pull = digitalio.Pull.DOWN

# The two files assigned to buttons A & B

audiofiles = [“rimshot.wav”, “laugh.wav”]

def play_file(filename):

print(“Playing file: ” + filename)

wave_file = open(filename, “rb”)

with WaveFile(wave_file) as wave:

with AudioOut(board.SPEAKER) as audio:

audio.play(wave)

while audio.playing:

pass

print(“Finished”)

while True:

if buttonA.value:

play_file(audiofiles[0])

if buttonB.value:

play_file(audiofiles[1])

此示例使用以下命令创建两个输入按钮板载按钮,然后具有帮助功能,该功能将:

使用wave_file = open(filename, “rb”)

在磁盘驱动器上打开文件,并使用

创建一个用with WaveFile(wave_file) as wave:

播放udio播放对象,最后播放直到完成:

with AudioOut(board.SPEAKER) as audio:

上传代码,然后尝试按两个按钮一次创建一个自己的笑声!

如果要使用自己的声音文件,可以!录制,采样,重新混音或仅从声音文件视域(例如freesample.org)下载文件。然后,要确保将文件转换为正确的规范,请在此处查看本指南,该指南将向您展示如何!剧透警告:您需要制作一个小的22Khz(或更低),16位PCM,单声道.wav文件!

CircuitPython Cap触摸

尽管以下示例使用Circuit Playground Express进行了演示,代码与Circuit Playground Bluefruit的工作方式完全相同。只需复制代码,然后遵循您的Circuit Playground Bluefruit!

此快速入门示例显示了如何读取内置在七个Circuit Playground Express垫(垫 A0/Audio 不是电容式触摸板)。

使用您喜欢的代码编辑器将代码块复制并粘贴到 code.py 中,然后保存文件以运行演示

下载:Project Zip 或 CircuitPlaygroundExpress_CapTouch.py | 在Github上查看

复制代码

# Circuit Playground Capacitive Touch

import time

import board

import touchio

touch_A1 = touchio.TouchIn(board.A1)

touch_A2 = touchio.TouchIn(board.A2)

touch_A3 = touchio.TouchIn(board.A3)

touch_A4 = touchio.TouchIn(board.A4)

touch_A5 = touchio.TouchIn(board.A5)

touch_A6 = touchio.TouchIn(board.A6)

touch_TX = touchio.TouchIn(board.TX)

while True:

if touch_A1.value:

print(“A1 touched!”)

if touch_A2.value:

print(“A2 touched!”)

if touch_A3.value:

print(“A3 touched!”)

if touch_A4.value:

print(“A4 touched!”)

if touch_A5.value:

print(“A5 touched!”)

if touch_A6.value:

print(“A6 touched!”)

if touch_TX.value:

print(“TX touched!”)

time.sleep(0.01)

# Circuit Playground Capacitive Touch

import time

import board

import touchio

touch_A1 = touchio.TouchIn(board.A1)

touch_A2 = touchio.TouchIn(board.A2)

touch_A3 = touchio.TouchIn(board.A3)

touch_A4 = touchio.TouchIn(board.A4)

touch_A5 = touchio.TouchIn(board.A5)

touch_A6 = touchio.TouchIn(board.A6)

touch_TX = touchio.TouchIn(board.TX)

while True:

if touch_A1.value:

print(“A1 touched!”)

if touch_A2.value:

print(“A2 touched!”)

if touch_A3.value:

print(“A3 touched!”)

if touch_A4.value:

print(“A4 touched!”)

if touch_A5.value:

print(“A5 touched!”)

if touch_A6.value:

print(“A6 touched!”)

if touch_TX.value:

print(“TX touched!”)

time.sleep(0.01)

您可以打开串行控制台,然后触摸每个触摸板以查看检测到并打印出的触摸。

创建电容式触摸输入

垫 A1-A6和TX 可用作电容式TouchIn设备:

touch_A1 = touchio.TouchIn(board.A1)

touch_A2 = touchio.TouchIn(board.A2)

touch_A3 = touchio.TouchIn(board.A3)

touch_A4 = touchio.TouchIn(board.A4)

touch_A5 = touchio.TouchIn(board.A5)

touch_A6 = touchio.TouchIn(board.A6)

touch_TX = touchio.TouchIn(board.TX)

此代码创建了七个对象,每个对象都连接到每个电容式触摸板。

主循环

主循环检查每个传感器一个接一个,以确定是否已被触摸。如果touch_A1.value返回True,则表示该垫A1检测到触摸。对于每个触摸板,如果已触摸它,则会打印一条消息。

在末尾添加了一个小的睡眠延迟,因此循环不会很快运行。您可能需要将延迟从0.1秒更改为0秒以减慢速度,或将其增加以加快速度。

请注意,不需要额外的硬件,您可以直接触摸护垫,但您可能希望连接鳄鱼夹或铝箔胶带粘贴到金属或导电物体上。尝试在桌子周围尝试银器,水果或其他食物,液体,铝箔和物品!

您可能需要在更改附件后重新启动代码/板,因为电容式触摸代码会根据其首次看到的内容进行“校准”启动。因此,如果触摸信号过多或不足,请点击该重置按钮!

带有导电胶粘剂的铜箔胶带-6毫米x 15米卷

产品ID:1128

铜箔胶带可以是您工具箱中的一个有趣补充。胶带本身由纯铜制成,因此非常柔软,几乎可以呈现任何形状。您可以轻松地。..

$ 5.95

入库存

添加到购物车

带有导电胶的铜箔胶带-25mm x 15米卷

产品ID:1127

铜带可以是您工具箱中的一个有趣的补充。胶带本身由纯铜制成,因此非常柔软,几乎可以呈现任何形状。您可以轻松地。..

$ 19.95

进货

添加到购物车

小鳄鱼夹测试线(12套)

产品编号:1008

使用这些方便的迷你鳄鱼夹测试线将其连接至该端子而无需焊接。 15“电缆,两端带有鳄鱼夹,用颜色编码。您将获得12股6种颜色。。..

$ 3.95

IN库存

添加到购物车

电容触摸和电路游乐场蓝果上的音频引脚

在电路游乐场蓝果上,如果您同时触摸任何一个触摸板触摸音频引脚时,您可能会听到扬声器发出喀哒声或嗡嗡声,这是由于Bluefruit电容式触摸的工作原理所致。如果遇到这种情况并希望避免这种情况,可以使用代码关闭扬声器通过在您的 code.py 中添加以下内容:

下载:文件

复制代码

import digitalio

speaker = digitalio.DigitalInOut(board.SPEAKER_ENABLE)

speaker.switch_to_output(value=False) import digitalio

speaker = digitalio.DigitalInOut(board.SPEAKER_ENABLE)

speaker.switch_to_output(value=False)

CircuitPython NeoPixel

尽管以下示例使用Circuit Playground Express进行了演示,该代码与Circuit Playground Bluefruit的工作方式完全相同。只需复制代码,然后遵循您的Circuit Playground Bluefruit!

NeoPixels是一种革命性且广受欢迎的方法,可以为项目添加灯光和颜色。这些绞合的RGB灯在LED的内部具有控制器,因此您只需推动RGB数据,LED即可为您完成所有工作!它们非常适合CircuitPython。

您可以通过亮度控制(例如,将brightness=0.2设置为20%亮度)驱动300个像素,而没有亮度(例如,不设置brightness或在对象创建中设置brightness=1.0。这是因为要调整亮度,我们必须在每次写入时动态地重新创建数据流。

下面是一个示例,您可以检出许多不同的视觉效果。如果还没有文件,则需要 neopixel.mpy 库文件!

下载:Project Zip 或 CircuitPlaygroundExpress_NeoPixel.py | 在Github上查看

复制代码

# Circuit Playground NeoPixel

import time

import board

import neopixel

pixels = neopixel.NeoPixel(board.NEOPIXEL, 10, brightness=0.2, auto_write=False)

# choose which demos to play

# 1 means play, 0 means don‘t!

color_chase_demo = 1

flash_demo = 1

rainbow_demo = 1

rainbow_cycle_demo = 1

def wheel(pos):

# Input a value 0 to 255 to get a color value.

# The colours are a transition r - g - b - back to r.

if pos 《 0 or pos 》 255:

return (0, 0, 0)

if pos 《 85:

return (255 - pos * 3, pos * 3, 0)

if pos 《 170:

pos -= 85

return (0, 255 - pos * 3, pos * 3)

pos -= 170

return (pos * 3, 0, 255 - pos * 3)

def color_chase(color, wait):

for i in range(10):

pixels[i] = color

time.sleep(wait)

pixels.show()

time.sleep(0.5)

def rainbow_cycle(wait):

for j in range(255):

for i in range(10):

rc_index = (i * 256 // 10) + j * 5

pixels[i] = wheel(rc_index & 255)

pixels.show()

time.sleep(wait)

def rainbow(wait):

for j in range(255):

for i in range(len(pixels)):

idx = int(i + j)

pixels[i] = wheel(idx & 255)

pixels.show()

time.sleep(wait)

RED = (255, 0, 0)

YELLOW = (255, 150, 0)

GREEN = (0, 255, 0)

CYAN = (0, 255, 255)

BLUE = (0, 0, 255)

PURPLE = (180, 0, 255)

WHITE = (255, 255, 255)

OFF = (0, 0, 0)

while True:

if color_chase_demo:

color_chase(RED, 0.1) # Increase the number to slow down the color chase

color_chase(YELLOW, 0.1)

color_chase(GREEN, 0.1)

color_chase(CYAN, 0.1)

color_chase(BLUE, 0.1)

color_chase(PURPLE, 0.1)

color_chase(OFF, 0.1)

if flash_demo:

pixels.fill(RED)

pixels.show()

# Increase or decrease to change the speed of the solid color change.

time.sleep(1)

pixels.fill(GREEN)

pixels.show()

time.sleep(1)

pixels.fill(BLUE)

pixels.show()

time.sleep(1)

pixels.fill(WHITE)

pixels.show()

time.sleep(1)

if rainbow_cycle_demo:

rainbow_cycle(0.05) # Increase the number to slow down the rainbow.

if rainbow_demo:

rainbow(0.05) # Increase the number to slow down the rainbow.

# Circuit Playground NeoPixel

import time

import board

import neopixel

pixels = neopixel.NeoPixel(board.NEOPIXEL, 10, brightness=0.2, auto_write=False)

# choose which demos to play

# 1 means play, 0 means don’t!

color_chase_demo = 1

flash_demo = 1

rainbow_demo = 1

rainbow_cycle_demo = 1

def wheel(pos):

# Input a value 0 to 255 to get a color value.

# The colours are a transition r - g - b - back to r.

if pos 《 0 or pos 》 255:

return (0, 0, 0)

if pos 《 85:

return (255 - pos * 3, pos * 3, 0)

if pos 《 170:

pos -= 85

return (0, 255 - pos * 3, pos * 3)

pos -= 170

return (pos * 3, 0, 255 - pos * 3)

def color_chase(color, wait):

for i in range(10):

pixels[i] = color

time.sleep(wait)

pixels.show()

time.sleep(0.5)

def rainbow_cycle(wait):

for j in range(255):

for i in range(10):

rc_index = (i * 256 // 10) + j * 5

pixels[i] = wheel(rc_index & 255)

pixels.show()

time.sleep(wait)

def rainbow(wait):

for j in range(255):

for i in range(len(pixels)):

idx = int(i + j)

pixels[i] = wheel(idx & 255)

pixels.show()

time.sleep(wait)

RED = (255, 0, 0)

YELLOW = (255, 150, 0)

GREEN = (0, 255, 0)

CYAN = (0, 255, 255)

BLUE = (0, 0, 255)

PURPLE = (180, 0, 255)

WHITE = (255, 255, 255)

OFF = (0, 0, 0)

while True:

if color_chase_demo:

color_chase(RED, 0.1) # Increase the number to slow down the color chase

color_chase(YELLOW, 0.1)

color_chase(GREEN, 0.1)

color_chase(CYAN, 0.1)

color_chase(BLUE, 0.1)

color_chase(PURPLE, 0.1)

color_chase(OFF, 0.1)

if flash_demo:

pixels.fill(RED)

pixels.show()

# Increase or decrease to change the speed of the solid color change.

time.sleep(1)

pixels.fill(GREEN)

pixels.show()

time.sleep(1)

pixels.fill(BLUE)

pixels.show()

time.sleep(1)

pixels.fill(WHITE)

pixels.show()

time.sleep(1)

if rainbow_cycle_demo:

rainbow_cycle(0.05) # Increase the number to slow down the rainbow.

if rainbow_demo:

rainbow(0.05) # Increase the number to slow down the rainbow.

NeoPixel对象的参数列表需要您要使用的引脚(可以使用任何引脚)和像素数。有两个可选参数,brightness(范围从0到1.0的全亮度)和auto_write。未设置时auto_write默认为True。当auto_write设置为True时,每次更改都会立即写入像素带,这更易于使用,但 way 较慢。如果您设置auto_write=False,那么当您想实际写出颜色数据时,就必须调用pixels.show()。

您可以通过索引位置。例如,pixels[n] = (red, green, blue)将第一个像素设置为中等亮度的红色,而pixels[0] = (100, 0, 0)将第三个像素设置为明亮的绿色。然后,如果您有pixels[2] = (0, 255, 0),请不要忘记拨打auto_write=False!

您不仅限于板载NeoPixels,也可以通过任何数字IO引脚驱动外部连接的NeoPixels。

3.3V稳压器输出为电路板上的像素供电时,可处理约500mA的峰值,“平均”使用时约为50个像素。如果您真的想要明亮的灯光和很多像素,建议您直接从电源供电。在Circuit Playground Express上,这是 Vout 垫-该垫可通过USB或BAT(电池)直接供电,具体取决于哪个电压更高。

验证插排或设备上的接线-插入“ DOUT端是一个常见错误!仅在未打开Circuit Playground Express的情况下才为NeoPixels接线,以避免可能的损坏!

如果NeoPixels的电源大于5.5V,则驱动某些条带可能会有些困难,在这种情况下,您可能需要降低电压至4.5-5V或使用电平转换器

我们有一吨更多有关通用NeoPixel知识的信息,请参见我们的NeoPixel UberGuide https://learn.adafruit.com/adafruit-neopixel-uberguide

CircuitPython DotStar

与NeoPixel的一根电线不同,DotStars使用两根电线。它们非常相似,但是您可以使用硬件SPI 更快地写入DotStars,并且它们具有更快的PWM周期,因此更适合进行光绘。

任何引脚都可以使用但是,如果这两个引脚可以形成硬件SPI端口,则库将自动切换到硬件SPI。如果您使用硬件SPI,那么您将获得4 MHz的时钟速率(这意味着在大约500uS内更新64像素链-这是0.0005秒)。如果您使用非硬件SPI引脚,则将下降到大约3KHz,是原来的1000倍!

您可以驱动300个带有亮度控制的DotStar LED(在对象创建中设置brightness=1.0)和没有1000个LED。这是因为要调整亮度,我们必须在每次写入时动态地重新创建数据流。

如果您还没有库,则需要 adafruit_dotstar.mpy 库。您的/lib文件夹!您可以从CircuitPython库捆绑中获取它。如果需要安装库的帮助,请查看CircuitPython库页面。

连接起来

您需要先焊接DotStars。确认您的连接位于 DATA INPUT 或 DI 和 CLOCK INPUT 或 CI 一侧。插入DATA OUT/DO或CLOCK OUT/CO端是一个常见错误!连接带有标签,某些格式带有箭头以指示数据必须流向的方向。始终用肉眼检查来验证接线,因为连接顺序因条带而异!

要为电路板上的像素供电,3.3V稳压器输出可处理约500mA峰值,约为“平均”使用50个像素。如果您真的想要明亮的灯光和很多像素,建议您使用外部电源直接供电。

在Gemma M0和Circuit Playground Express上,这是 Vout 垫-该垫可以直接从USB或电池供电,具体取决于哪个是更高的电压。 USB 或 BAT 引脚将为您提供来自USB端口或电池的直接电源。

在Metro M0 Express和Metro M4 Express上,使用 5V 引脚,而不管它是通过USB还是DC插孔供电。

如果DotStars的电源大于5.5V,则在驱动某些条带时可能会遇到一些困难您可能需要将电压降低到4.5-5V或使用电平转换器。

请勿在Metro M0 Express或Metro M4 Express上直接使用VIN引脚!电压可以达到9V,这可能会损坏您的DotStars!

请注意,DotStar条形或形状上的导线订购可能不正确与上图完全匹配。检查标记以确认哪个引脚是DIN,CIN,5V和GND

代码

此示例包含多种视觉效果。使用您喜欢的编辑器将代码复制并粘贴到 code.py 中,然后保存文件。

下载:Project Zip 或 CircuitPython_DotStar.py | 在Github上查看

复制代码

# CircuitPython demo - Dotstar

import time

import adafruit_dotstar

import board

num_pixels = 30

pixels = adafruit_dotstar.DotStar(board.A1, board.A2, num_pixels, brightness=0.1, auto_write=False)

def wheel(pos):

# Input a value 0 to 255 to get a color value.

# The colours are a transition r - g - b - back to r.

if pos 《 0 or pos 》 255:

return (0, 0, 0)

if pos 《 85:

return (255 - pos * 3, pos * 3, 0)

if pos 《 170:

pos -= 85

return (0, 255 - pos * 3, pos * 3)

pos -= 170

return (pos * 3, 0, 255 - pos * 3)

def color_fill(color, wait):

pixels.fill(color)

pixels.show()

time.sleep(wait)

def slice_alternating(wait):

pixels[::2] = [RED] * (num_pixels // 2)

pixels.show()

time.sleep(wait)

pixels[1::2] = [ORANGE] * (num_pixels // 2)

pixels.show()

time.sleep(wait)

pixels[::2] = [YELLOW] * (num_pixels // 2)

pixels.show()

time.sleep(wait)

pixels[1::2] = [GREEN] * (num_pixels // 2)

pixels.show()

time.sleep(wait)

pixels[::2] = [TEAL] * (num_pixels // 2)

pixels.show()

time.sleep(wait)

pixels[1::2] = [CYAN] * (num_pixels // 2)

pixels.show()

time.sleep(wait)

pixels[::2] = [BLUE] * (num_pixels // 2)

pixels.show()

time.sleep(wait)

pixels[1::2] = [PURPLE] * (num_pixels // 2)

pixels.show()

time.sleep(wait)

pixels[::2] = [MAGENTA] * (num_pixels // 2)

pixels.show()

time.sleep(wait)

pixels[1::2] = [WHITE] * (num_pixels // 2)

pixels.show()

time.sleep(wait)

def slice_rainbow(wait):

pixels[::6] = [RED] * (num_pixels // 6)

pixels.show()

time.sleep(wait)

pixels[1::6] = [ORANGE] * (num_pixels // 6)

pixels.show()

time.sleep(wait)

pixels[2::6] = [YELLOW] * (num_pixels // 6)

pixels.show()

time.sleep(wait)

pixels[3::6] = [GREEN] * (num_pixels // 6)

pixels.show()

time.sleep(wait)

pixels[4::6] = [BLUE] * (num_pixels // 6)

pixels.show()

time.sleep(wait)

pixels[5::6] = [PURPLE] * (num_pixels // 6)

pixels.show()

time.sleep(wait)

def rainbow_cycle(wait):

for j in range(255):

for i in range(num_pixels):

rc_index = (i * 256 // num_pixels) + j

pixels[i] = wheel(rc_index & 255)

pixels.show()

time.sleep(wait)

RED = (255, 0, 0)

YELLOW = (255, 150, 0)

ORANGE = (255, 40, 0)

GREEN = (0, 255, 0)

TEAL = (0, 255, 120)

CYAN = (0, 255, 255)

BLUE = (0, 0, 255)

PURPLE = (180, 0, 255)

MAGENTA = (255, 0, 20)

WHITE = (255, 255, 255)

while True:

# Change this number to change how long it stays on each solid color.

color_fill(RED, 0.5)

color_fill(YELLOW, 0.5)

color_fill(ORANGE, 0.5)

color_fill(GREEN, 0.5)

color_fill(TEAL, 0.5)

color_fill(CYAN, 0.5)

color_fill(BLUE, 0.5)

color_fill(PURPLE, 0.5)

color_fill(MAGENTA, 0.5)

color_fill(WHITE, 0.5)

# Increase or decrease this to speed up or slow down the animation.

slice_alternating(0.1)

color_fill(WHITE, 0.5)

# Increase or decrease this to speed up or slow down the animation.

slice_rainbow(0.1)

time.sleep(0.5)

# Increase this number to slow down the rainbow animation.

rainbow_cycle(0)

# CircuitPython demo - Dotstar

import time

import adafruit_dotstar

import board

num_pixels = 30

pixels = adafruit_dotstar.DotStar(board.A1, board.A2, num_pixels, brightness=0.1, auto_write=False)

def wheel(pos):

# Input a value 0 to 255 to get a color value.

# The colours are a transition r - g - b - back to r.

if pos 《 0 or pos 》 255:

return (0, 0, 0)

if pos 《 85:

return (255 - pos * 3, pos * 3, 0)

if pos 《 170:

pos -= 85

return (0, 255 - pos * 3, pos * 3)

pos -= 170

return (pos * 3, 0, 255 - pos * 3)

def color_fill(color, wait):

pixels.fill(color)

pixels.show()

time.sleep(wait)

def slice_alternating(wait):

pixels[::2] = [RED] * (num_pixels // 2)

pixels.show()

time.sleep(wait)

pixels[1::2] = [ORANGE] * (num_pixels // 2)

pixels.show()

time.sleep(wait)

pixels[::2] = [YELLOW] * (num_pixels // 2)

pixels.show()

time.sleep(wait)

pixels[1::2] = [GREEN] * (num_pixels // 2)

pixels.show()

time.sleep(wait)

pixels[::2] = [TEAL] * (num_pixels // 2)

pixels.show()

time.sleep(wait)

pixels[1::2] = [CYAN] * (num_pixels // 2)

pixels.show()

time.sleep(wait)

pixels[::2] = [BLUE] * (num_pixels // 2)

pixels.show()

time.sleep(wait)

pixels[1::2] = [PURPLE] * (num_pixels // 2)

pixels.show()

time.sleep(wait)

pixels[::2] = [MAGENTA] * (num_pixels // 2)

pixels.show()

time.sleep(wait)

pixels[1::2] = [WHITE] * (num_pixels // 2)

pixels.show()

time.sleep(wait)

def slice_rainbow(wait):

pixels[::6] = [RED] * (num_pixels // 6)

pixels.show()

time.sleep(wait)

pixels[1::6] = [ORANGE] * (num_pixels // 6)

pixels.show()

time.sleep(wait)

pixels[2::6] = [YELLOW] * (num_pixels // 6)

pixels.show()

time.sleep(wait)

pixels[3::6] = [GREEN] * (num_pixels // 6)

pixels.show()

time.sleep(wait)

pixels[4::6] = [BLUE] * (num_pixels // 6)

pixels.show()

time.sleep(wait)

pixels[5::6] = [PURPLE] * (num_pixels // 6)

pixels.show()

time.sleep(wait)

def rainbow_cycle(wait):

for j in range(255):

for i in range(num_pixels):

rc_index = (i * 256 // num_pixels) + j

pixels[i] = wheel(rc_index & 255)

pixels.show()

time.sleep(wait)

RED = (255, 0, 0)

YELLOW = (255, 150, 0)

ORANGE = (255, 40, 0)

GREEN = (0, 255, 0)

TEAL = (0, 255, 120)

CYAN = (0, 255, 255)

BLUE = (0, 0, 255)

PURPLE = (180, 0, 255)

MAGENTA = (255, 0, 20)

WHITE = (255, 255, 255)

while True:

# Change this number to change how long it stays on each solid color.

color_fill(RED, 0.5)

color_fill(YELLOW, 0.5)

color_fill(ORANGE, 0.5)

color_fill(GREEN, 0.5)

color_fill(TEAL, 0.5)

color_fill(CYAN, 0.5)

color_fill(BLUE, 0.5)

color_fill(PURPLE, 0.5)

color_fill(MAGENTA, 0.5)

color_fill(WHITE, 0.5)

# Increase or decrease this to speed up or slow down the animation.

slice_alternating(0.1)

color_fill(WHITE, 0.5)

# Increase or decrease this to speed up or slow down the animation.

slice_rainbow(0.1)

time.sleep(0.5)

# Increase this number to slow down the rainbow animation.

rainbow_cycle(0)

我们选择了引脚A1和A2,但它们不是所有电路板上的SPI引脚。使用硬件SPI时,DotStars响应速度更快!

创建LED

我们要做的第一件事是创建LED对象。 DotStar对象具有三个必需参数和两个可选参数。您需要设置要用于数据的引脚,设置要用于时钟的引脚,并提供要使用的像素数。您可以选择设置brightness和auto_write。

DotStars可以由任意两个引脚驱动。我们选择 A1 作为时钟,选择 A2 作为数据。要设置引脚,请在对象创建的开始时包括引脚名称,在这种情况下为board.A1和board.A2。

要提供像素数,请分配变量num_pixels为您要使用的像素数。在此示例中,我们使用的是72条带。

我们选择设置brightness=0.1或10%。

默认情况下, auto_write=True,表示您对像素所做的任何更改都会自动发送。由于True是默认设置,因此,如果使用该设置,则根本不需要将其包含在LED对象中。我们选择设置auto_write=False。如果设置auto_write=False,则每次要将数据发送到像素时都必须包含pixels.show()。这使您的代码更加复杂,但可以使您的LED动画更快!

DotStar Helpers

我们包含了一些帮助程序功能,以创建此代码中发现的超级有趣的视觉效果。

首先是wheel(),我们刚刚通过学习内部RGB LED。然后,我们有color_fill(),要求您提供color以及希望显示的时间长度。接下来,是slice_alternating(),slice_rainbow()和rainbow_cycle(),它们要求您提供动画每一步之间的时间间隔(秒)。

最后一个,我们为颜色添加了一个变量列表。如果在代码中的任何地方重用颜色,以及添加更多颜色以在多个位置使用,这将变得更加容易。在CircuitPython内部RGB LED页面的本节中介绍了分配和使用RGB颜色。

两个切片助手利用DotStar库的一个漂亮功能,允许我们使用数学方法以重复模式点亮LED。 。 slice_alternating()首先点亮偶数个LED,然后点亮奇数个LED,并前后重复此操作。 slice_rainbow()每六个LED用六种彩虹色之一点亮一次,直到填充条为止。两者都使用我们方便的颜色变量。仅当LED的总数可被切片大小整除时(在我们的示例2和6中),此切片代码才有效。DotStars分为30、60、72和144的条带,所有这些都可被2和6整除。如果将它们切成不同大小的条,则本示例中的代码如果不进行修改可能无法工作。但是,只要您提供可被切片整除的LED总数,代码就可以使用。

主循环

我们的主循环从对列表中的每个color_fill()调用一次color开始,并设置每个对秒。您可以更改此数字以更改每种颜色的显示速度。接下来,我们调用0.5,这意味着动画的每次更改之间有0.1秒的延迟。然后,我们将条带填充为白色以创建干净的背景以显示彩虹。然后,我们将slice_alternating(0.1)称为动画延迟0.1秒。最后我们称为slice_rainbow(0.1),这意味着它尽可能快。增大或减小这些数字之一可以加快或降低动画的速度!

请注意,LED灯带的时间越长,完成动画所需的时间就越长。

我们在DotStar UberGuide上提供了有关通用DotStar专有技术的大量信息https://learn .adafruit.com/adafruit-dotstar-leds

是SPI吗?

在本节的开头,我们解释了如果您使用硬件SPI,则LED响应速度更快。在某些板上,有直接以MOSI和SCK形式提供的HW SPI引脚。但是,硬件SPI不仅限于这些引脚。但是,您如何找出哪个呢?简单!我们编写了一个方便的脚本。

我们为示例代码选择了引脚 A1 和 A2 。要查看这些是否是您正在使用的板上的硬件SPI,请使用您喜欢的编辑器将代码复制并粘贴到 code.py 中,然后保存文件。然后连接到串行控制台以查看结果。

要检查其他引脚组合是否具有硬件SPI,请将线路读数上的引脚名称更改:rainbow_cycle(0)更改为要使用的引脚。然后,在串行控制台中检查结果。

下载:Project Zip 或 SPI_Test_Script.py | 在Github上查看

复制代码

if is_hardware_SPI(board.A1, board.A2): import board

import busio

def is_hardware_spi(clock_pin, data_pin):

try:

p = busio.SPI(clock_pin, data_pin)

p.deinit()

return True

except ValueError:

return False

# Provide the two pins you intend to use.

if is_hardware_spi(board.A1, board.A2):

print(“This pin combination is hardware SPI!”)

else:

print(“This pin combination isn‘t hardware SPI.”)

阅读文档

有关更多信息,请参见深入了解import board

import busio

def is_hardware_spi(clock_pin, data_pin):

try:

p = busio.SPI(clock_pin, data_pin)

p.deinit()

return True

except ValueError:

return False

# Provide the two pins you intend to use.

if is_hardware_spi(board.A1, board.A2):

print(“This pin combination is hardware SPI!”)

else:

print(“This pin combination isn’t hardware SPI.”)

可以做什么,请在“阅读文档”中查看DotStar。

CircuitPython UART串行

除了用于REPL的USB串行连接外,还可以使用硬件 UART。与GPS设备,某些传感器或其他微控制器之类的UART设备进行通信非常方便!

此快速入门示例显示了如何创建用于与硬件串行设备通信的UART设备。

要使用该示例,您将需要一些东西来生成UART数据。我们已经使用了GPS!请注意,GPS会为您提供UART数据,而不会修复您的位置。您可以在办公桌上直接使用此示例!您将拥有要读取的数据,只是其中不包含您的实际位置。

如果您还没有库文件夹,则需要 adafruit_bus_device 库文件夹。/lib文件夹!您可以从CircuitPython库捆绑中获取它。如果需要安装库的帮助,请查看CircuitPython库页面。

使用您喜欢的编辑器将代码复制并粘贴到 code.py 中,然后保存文件。

p》

下载:Project Zip 或 CircuitPython_UART.py | span》 在Github上查看

复制代码

# CircuitPython Demo - USB/Serial echo

import board

import busio

import digitalio

led = digitalio.DigitalInOut(board.D13)

led.direction = digitalio.Direction.OUTPUT

uart = busio.UART(board.TX, board.RX, baudrate=9600)

while True:

data = uart.read(32) # read up to 32 bytes

# print(data) # this is a bytearray type

if data is not None:

led.value = True

# convert bytearray to string

data_string = ‘’.join([chr(b) for b in data])

print(data_string, end=“”)

led.value = False

# CircuitPython Demo - USB/Serial echo

import board

import busio

import digitalio

led = digitalio.DigitalInOut(board.D13)

led.direction = digitalio.Direction.OUTPUT

uart = busio.UART(board.TX, board.RX, baudrate=9600)

while True:

data = uart.read(32) # read up to 32 bytes

# print(data) # this is a bytearray type

if data is not None:

led.value = True

# convert bytearray to string

data_string = ‘’.join([chr(b) for b in data])

print(data_string, end=“”)

led.value = False

代码

首先,我们创建UART对象。我们提供要使用的引脚board.TX和board.RX,并设置baudrate=9600。虽然这些针脚在大多数板上都贴有标签,但要注意,RX和TX在Gemma上没有贴标签,而是在Trinket的底部贴标签。请参见下图,以帮助您找到板上正确的引脚。

创建对象后,您可以使用read(numbytes)读取数据,您可以在其中指定最大字节数。如果已经收到任何内容,它将返回一个字节数组类型的对象。注意,由于有内部缓冲区,它将总是立即返回!因此,请尽可能多地读取数据。

如果没有可用数据,read()将返回None,因此请在继续操作之前进行检查。

返回的数据位于字节数组中,如果要将其转换为字符串,则可以使用以下方便的代码行,其将在每个字节上运行chr():

datastr = ‘’.join([chr(b) for b in data]) # convert bytearray to string

您的结果将如下所示:

有关您的数据的更多信息,重新阅读和Ultimate GPS,请查看Ultimate GPS指南:https://learn.adafruit.com/adafruit-ultimate-gps

将其连接

您将需要一些操作来将GPS连接到板上

对于Gemma M0和Circuit Playground Express,您可以使用鳄鱼夹连接到Flora Ultimate GPS模块。

对于小饰品M0,羽毛M0 Express, Metro M0 Express和ItsyBitsy M0 Express,您需要一块面包板和跨接线才能连接到Ultimate GPS Breakout。

我们提供了一些示意图,向您展示了如何将GPS连接到板上。在这些图中,电线的颜色与每块板上的相同引脚匹配。

黑色电线在接地引脚之间进行连接。

红色电线连接GPS上的电源插针和您的电路板之间。

蓝色电线从GPS上的 TX 连接到板上的 RX 。

白色电线从 RX连接在GPS上以 TX 在您的板上。

查看下面的列表以获取特定板的图表!

当心!与UART串口的常见混淆是,一块板上的RX连接到另一块板上的TX!但是,有时板子上的RX标记为TX,反之亦然。因此,您需要从连接到TX的RX开始,但是如果不起作用,请尝试其他方法!

Circuit Playground Express和Circuit Playground Bluefruit

将CPX上的 3.3v 连接到GPS上的 3.3v 。

连接 GND 》在CPX上》到GPS上的 GND 。

将CPX上的 RX/A6 连接到GPS上的 TX 。

将CPX上的 TX/A7 连接到GPS上的 RX 。

小饰品M0

将小装饰品上的 USB 连接到 VIN

将小装饰品上的 Gnd 连接到GPS上的 GND 。

连接 D3 转到GPS上的 TX 。

将Trinket上的 D4 连接到GPS上的 RX GPS。

Gemma M0

将Gemma上的 3vo 连接到GPS上的 3.3v 。

将Gemma上的 GND 连接到GPS上的 GND 。

将GPS上的 A1/D2 连接起来。将Gemma插入GPS上的 TX 。

将Gemma上的 A2/D0 连接到GPS上的 RX 。

《圣rong》羽毛M0 Express和羽毛M4 Express

将羽毛上的 USB 连接到GPS上的 VIN 。

将羽毛上的 GND 连接到GPS上的 GND 。

将 RX 连接到GPS

将Feather上的 TX 连接到GPS上的 RX 。

ItsyBitsy M0 Express和ItsyBitsy M4 Express

将ItsyBitsy上的 USB 连接到GPS上的 VIN

将ItsyBitsy上的 G 连接到GPS上的 GND 。

将 RX/0 连接GPS上的ItsyBitsy到 TX 。

将ItsyBitsy上的 TX/1 连接到GPS上的 RX GPS。

Metro M0 Express和Metro M4 Express

将Metro上的 5V 连接到 VIN

将Metro上的 GND 连接到GPS上的 GND 。

连接 RX/D0 到GPS上的 TX 。

将Metro上的 TX/D1 连接到 RX

我的UART在哪里?

在SAMD21上,我们可以灵活地为UART使用各种引脚。将此与某些带有 fixed UART引脚的ESP8266芯片进行比较。好消息是您可以使用很多,但不能使用所有 引脚。鉴于我们拥有大量的SAMD板卡,除标有‘TX’和‘RX’之外的其他任何东西都无法保证,因此,如果您需要其他设置或多个UART,您将如何找到这些引脚?简单!我们已经编写了一个方便的脚本。

您所要做的就是将该文件复制到您的电路板上,将其重命名为 code.py ,连接到串行控制台并检出输出!结果会打印出一个不错的RX和TX引脚对列表,供您使用。

这些是Trinket M0的结果,您的输出可能会有所不同,可能非常长。有关UART和SERCOM的更多详细信息,请在此处查看我们的详细指南

下载:Project Zip 或 UART_Test_Script.py | 在Github上查看

复制代码

import board

import busio

from microcontroller import Pin

def is_hardware_uart(tx, rx):

try:

p = busio.UART(tx, rx)

p.deinit()

return True

except ValueError:

return False

def get_unique_pins():

exclude = [‘NEOPIXEL’, ‘APA102_MOSI’, ‘APA102_SCK’]

pins = [pin for pin in [

getattr(board, p) for p in dir(board) if p not in exclude]

if isinstance(pin, Pin)]

unique = []

for p in pins:

if p not in unique:

unique.append(p)

return unique

for tx_pin in get_unique_pins():

for rx_pin in get_unique_pins():

if rx_pin is tx_pin:

continue

else:

if is_hardware_uart(tx_pin, rx_pin):

print(“RX pin:”, rx_pin, “ TX pin:”, tx_pin)

else:

pass

import board

import busio

from microcontroller import Pin

def is_hardware_uart(tx, rx):

try:

p = busio.UART(tx, rx)

p.deinit()

return True

except ValueError:

return False

def get_unique_pins():

exclude = [‘NEOPIXEL’, ‘APA102_MOSI’, ‘APA102_SCK’]

pins = [pin for pin in [

getattr(board, p) for p in dir(board) if p not in exclude]

if isinstance(pin, Pin)]

unique = []

for p in pins:

if p not in unique:

unique.append(p)

return unique

for tx_pin in get_unique_pins():

for rx_pin in get_unique_pins():

if rx_pin is tx_pin:

continue

else:

if is_hardware_uart(tx_pin, rx_pin):

print(“RX pin:”, rx_pin, “ TX pin:”, tx_pin)

else:

pass

小饰品M0:在I2C之前创建UART

在小饰品上M0(仅),如果同时使用busio.UART和busio.I2C,则必须首先创建UART对象,例如:

下载:文件

复制代码

》》》 import board,busio

》》》 uart = busio.UART(board.TX, board.RX)

》》》 i2c = busio.I2C(board.SCL, board.SDA) 》》》 import board,busio

》》》 uart = busio.UART(board.TX, board.RX)

》》》 i2c = busio.I2C(board.SCL, board.SDA)

创建busio.I2C首先不起作用:

下载:文件

复制代码

》》》 import board,busio

》》》 i2c = busio.I2C(board.SCL, board.SDA)

》》》 uart = busio.UART(board.TX, board.RX)

Traceback (most recent call last):

File “”, line 1, in

ValueError: Invalid pins 》》》 import board,busio

》》》 i2c = busio.I2C(board.SCL, board.SDA)

》》》 uart = busio.UART(board.TX, board.RX)

Traceback (most recent call last):

File “”, line 1, in

ValueError: Invalid pins

CircuitPython I2C

I2C是用于与简单传感器和设备进行通信的2线协议,这意味着它使用两个连接来传输和接收数据。有许多I2C设备可用,并且它们实际上非常容易与CircuitPython一起使用。库捆绑包中有许多I2C设备可用的库。 (如果您没有找到所需的传感器,请继续检查,一直在写更多的信息!)

在本节中,我们要做的就是学习如何扫描所有连接设备的I2C总线。然后,我们将学习如何与I2C设备进行交互。

我们将使用普通的低成本光传感器TSL2561。虽然我们运行的确切代码特定于TSL2561,但是对于任何I2C传感器或设备,整个过程都是相同的。

您将需要 adafruit_tsl2561.mpy 库和 adafruit_bus_device 库文件夹(如果您的/lib文件夹中还没有)!您可以从CircuitPython库捆绑中获取它。如果需要安装库的帮助,请查看CircuitPython库页面。

这些示例将使用TSL2561 lux传感器Flora和Breakout。您要做的第一件事就是连接传感器,以便您的电路板可以与I2C进行通信。

连接起来

将TSL2561连接到板上需要做一些事情。

对于Gemma M0和Circuit Playground Express,您可以使用鳄鱼夹连接到Flora TSL2561 Lux传感器。

对于小饰品M0,羽毛M0 Express,Metro M0 Express和ItsyBitsy M0 Express,您需要一块面包板和跨接线连接到TSL2561 Lux传感器分支板上。

我们提供的示意图向您展示了如何将TSL2561连接到板上。在这些图中,电线的颜色与每块板上的相同引脚匹配。

黑色电线在接地引脚之间进行连接。

红色线连接TSL2561的电源引脚和您的电路板上。

黄色电线从TSL2561上的 SCL 连接到板上的 SCL 。

蓝色电线从 SDA连接。 到TSL2561上的 SDA 。

查看下面的列表以获取特定板的图表!

请注意,Adafruit微控制器板上没有内置的I2C上拉电阻!所有的Adafruit分支都可以,但是,如果您要构建自己的电路板或使用非Adafruit分支,则必须在SDA和SCL上均向2.2V添加2.2K-10K欧姆上拉。

电路Playground Express和Circuit Playground Bluefruit

将CPX上的 3.3v 连接到 3.3v 上的TSL2561。

将CPX上的 GND 连接到TSL2561上的 GND 。

连接 CPX上的SCL/A4 到TSL2561上的 SCL 。

将CPX上的 SDL/A5 连接到 SDA 在您的TSL2561上。

饰品M0

将饰品上的 USB 连接到TSL2561上的 VIN 。

将附件上的 Gnd 连接到TSL2561上的 GND 。

将Tstrong256上的 D2 连接起来。 Tli将TSL2561上的 SCL 放置在小装饰品上。

将Trinket上的 D0 连接到TSL2561上的 SDA 。

Gemma M0

将Gemma上的 3vo 连接到TSL2561上的 3V 。

将Gemma上的 GND 连接到TSL2561上的 GND 。

将 A1/D2 连接到

将Gemma上的 A2/D0 连接到TSL2561上的 SDA 。

li》

羽毛M0 Express和羽毛M4 Express

将羽毛上的 USB 连接到TSL2561上的 VIN 。

连接 GND 插入到TSL2561上的 GND 。

将羽毛上的 SCL 连接到TSL2561上的 SCL 。 TSL2561。

将羽毛上的 SDA 连接到TSL2561上的 SDA 。

ItsyBitsy M0 Express和ItsyBitsy M4 Express

将ItsyBitsy上的 USB 连接到TSL2561上的 VIN

将ItsyBitsy上的 G 连接到 GND

将ItsyBitsy上的 SCL 连接到TSL2561上的 SCL 。

连接 SDA ,位于TSL2561上的 SDA 上。

Metro M0 Express和Metro M4 Express

将Metro上的 5V 连接到TSL2561上的 VIN 。

将Metro上的 GND 连接到 GND 。

将Metro上的 SCL 连接到TSL2561上的 SCL 。

将Metro上的 SDA 连接到TSL2561上的 SDA 。

查找传感器

第一件事传感器连接好后要做的事,我确保连接正确。我们将进行I2C扫描,以查看是否检测到板子,如果是,则打印出其I2C地址。

将代码复制并粘贴到 code.py 使用您喜欢的编辑器,然后保存文件。

下载:Project Zip 或 CircuitPython_I2C_Scan.py | 在Github上查看

复制代码

# CircuitPython demo - I2C scan

import time

import board

import busio

i2c = busio.I2C(board.SCL, board.SDA)

while not i2c.try_lock():

pass

while True:

print(“I2C addresses found:”, [hex(device_address)

for device_address in i2c.scan()])

time.sleep(2)

# CircuitPython demo - I2C scan

import time

import board

import busio

i2c = busio.I2C(board.SCL, board.SDA)

while not i2c.try_lock():

pass

while True:

print(“I2C addresses found:”, [hex(device_address)

for device_address in i2c.scan()])

time.sleep(2)

首先,我们创建i2c对象,并提供I2C引脚board.SCL和board.SDA。

为了能够对其进行扫描,我们需要锁定I2C,因此唯一可以访问它的就是代码。因此,接下来我们包含一个等待I2C锁定然后继续执行扫描功能的循环。

最后,我们有一个运行实际扫描的循环i2c_scan()。由于I2C通常以十六进制形式引用地址,因此我们包含了将结果格式化为十六进制格式的以下代码:[hex(device_address) for device_address in i2c.scan()]。

打开串行控制台以查看结果!该代码打印出一个地址数组。我们已经连接了具有7位I2C地址0x39的TSL2561。该传感器的结果为I2C addresses found: [‘0x39’]。如果未返回任何地址,请参考接线图以确保已正确连接传感器。

I2C传感器数据

现在我们可以确定我们的传感器已连接并且可以使用了。让我们找出如何从传感器获取数据!

使用您喜欢的编辑器将代码复制并粘贴到 code.py 中,然后保存文件。

下载:Project Zip 或 CircuitPython_I2C_TSL2561.py | 在Github上查看

复制代码

# CircuitPython Demo - I2C sensor

import time

import adafruit_tsl2561

import board

import busio

i2c = busio.I2C(board.SCL, board.SDA)

# Lock the I2C device before we try to scan

while not i2c.try_lock():

pass

# Print the addresses found once

print(“I2C addresses found:”, [hex(device_address)

for device_address in i2c.scan()])

# Unlock I2C now that we‘re done scanning.

i2c.unlock()

# Create library object on our I2C port

tsl2561 = adafruit_tsl2561.TSL2561(i2c)

# Use the object to print the sensor readings

while True:

print(“Lux:”, tsl2561.lux)

time.sleep(1.0)

# CircuitPython Demo - I2C sensor

import time

import adafruit_tsl2561

import board

import busio

i2c = busio.I2C(board.SCL, board.SDA)

# Lock the I2C device before we try to scan

while not i2c.try_lock():

pass

# Print the addresses found once

print(“I2C addresses found:”, [hex(device_address)

for device_address in i2c.scan()])

# Unlock I2C now that we’re done scanning.

i2c.unlock()

# Create library object on our I2C port

tsl2561 = adafruit_tsl2561.TSL2561(i2c)

# Use the object to print the sensor readings

while True:

print(“Lux:”, tsl2561.lux)

time.sleep(1.0)

此代码以与扫描代码相同的方式开始。我们包含了扫描代码,因此您可以验证传感器是否已正确连接并被检测到。它只打印一次地址。扫描后,我们使用i2c_unlock()解锁I2C,以便可以使用传感器获取数据。

我们使用传感器库创建传感器对象。我们称它为tsl2561,并为其提供i2c对象。

然后,我们有一个简单的循环,使用我们创建的传感器对象打印出照度读数。我们添加了time.sleep(1.0),因此每秒仅打印一次。连接到串行控制台以查看结果。尝试照亮它,以查看结果是否发生变化!

我的I2C在哪里?

在SAMD21,SAMD51和nRF52840上,我们可以灵活地为I2C使用多种引脚。在nRF52840上,任何引脚都可以用于I2C!某些芯片(例如ESP8266)需要使用bitbangio,但也可以将任何引脚用于I2C。还有一些其他的芯片可能具有固定的I2C引脚。

好消息是,您可以使用很多但不是所有的引脚。鉴于我们拥有大量的SAMD板卡,除标有‘SDA’和‘SCL’之外的其他任何东西都无法保证,因此,如果您需要其他设置或多个I2C接口,您将如何找到这些引脚?简单!我们已经编写了一个方便的脚本。

您所要做的就是将该文件复制到您的电路板上,将其重命名为 code.py ,连接到串行控制台并检出输出!结果将打印出一个方便使用的SCL和SDA引脚对列表。

这些是ItsyBitsy M0 Express的结果。您的输出可能会有所不同,可能很长很长。有关I2C和SERCOM的更多详细信息,请在此处查看我们的详细指南。

下载:Project Zip 或 I2C_Test_Script.py | 在Github上查看

复制代码

import board

import busio

from microcontroller import Pin

def is_hardware_I2C(scl, sda):

try:

p = busio.I2C(scl, sda)

p.deinit()

return True

except ValueError:

return False

except RuntimeError:

return True

def get_unique_pins():

exclude = [‘NEOPIXEL’, ‘APA102_MOSI’, ‘APA102_SCK’]

pins = [pin for pin in [

getattr(board, p) for p in dir(board) if p not in exclude]

if isinstance(pin, Pin)]

unique = []

for p in pins:

if p not in unique:

unique.append(p)

return unique

for scl_pin in get_unique_pins():

for sda_pin in get_unique_pins():

if scl_pin is sda_pin:

continue

else:

if is_hardware_I2C(scl_pin, sda_pin):

print(“SCL pin:”, scl_pin, “ SDA pin:”, sda_pin)

else:

pass

import board

import busio

from microcontroller import Pin

def is_hardware_I2C(scl, sda):

try:

p = busio.I2C(scl, sda)

p.deinit()

return True

except ValueError:

return False

except RuntimeError:

return True

def get_unique_pins():

exclude = [‘NEOPIXEL’, ‘APA102_MOSI’, ‘APA102_SCK’]

pins = [pin for pin in [

getattr(board, p) for p in dir(board) if p not in exclude]

if isinstance(pin, Pin)]

unique = []

for p in pins:

if p not in unique:

unique.append(p)

return unique

for scl_pin in get_unique_pins():

for sda_pin in get_unique_pins():

if scl_pin is sda_pin:

continue

else:

if is_hardware_I2C(scl_pin, sda_pin):

print(“SCL pin:”, scl_pin, “ SDA pin:”, sda_pin)

else:

pass

CircuitPython HID键盘

尽管以下示例使用Circuit Playground Express进行了演示,代码与Circuit Playground Bluefruit的工作方式完全相同。只需复制代码,然后遵循您的Circuit Playground Bluefruit!

我们加入CircuitPython的一件事是“ HID”控件-键盘和鼠标功能。这意味着Circuit Playground Express可以像键盘设备和按下键一样操作,也可以像鼠标一样使鼠标四处移动并按下按钮。这真的很方便,因为即使您无法使软件适应硬件运行,也几乎总是有键盘接口-因此,如果您想为游戏提供电容式触摸界面,那么键盘仿真通常可以使您快速入门!

您需要从库捆绑中复制 adafruit_hid 模块,该模块包括键盘,键码和鼠标支持

,然后尝试运行以下示例代码会将Circuit Playground Express的 Button_A 和 Button_B 设置为HID键盘“键”。

下载:Project Zip 或 CircuitPlaygroundExpress_HIDKeyboard.py | 在Github上查看

复制代码

# Circuit Playground HID Keyboard

import time

import board

from adafruit_hid.keyboard import Keyboard

from adafruit_hid.keyboard_layout_us import KeyboardLayoutUS

from adafruit_hid.keycode import Keycode

from digitalio import DigitalInOut, Direction, Pull

# A simple neat keyboard demo in CircuitPython

# The button pins we‘ll use, each will have an internal pulldown

buttonpins = [board.BUTTON_A, board.BUTTON_B]

# our array of button objects

buttons = []

# The keycode sent for each button, will be paired with a control key

buttonkeys = [Keycode.A, “Hello World! ”]

controlkey = Keycode.SHIFT

# the keyboard object!

# sleep for a bit to avoid a race condition on some systems

time.sleep(1)

kbd = Keyboard()

# we’re americans :)

layout = KeyboardLayoutUS(kbd)

# make all pin objects, make them inputs with pulldowns

for pin in buttonpins:

button = DigitalInOut(pin)

button.direction = Direction.INPUT

button.pull = Pull.DOWN

buttons.append(button)

led = DigitalInOut(board.D13)

led.direction = Direction.OUTPUT

print(“Waiting for button presses”)

while True:

# check each button

# when pressed, the LED will light up,

# when released, the keycode or string will be sent

# this prevents rapid-fire repeats!

for button in buttons:

if button.value: # pressed?

i = buttons.index(button)

print(“Button #%d Pressed” % i)

# turn on the LED

led.value = True

while button.value:

pass # wait for it to be released!

# type the keycode or string

k = buttonkeys[i] # get the corresponding keycode or string

if isinstance(k, str):

layout.write(k)

else:

kbd.press(controlkey, k) # press.。.

kbd.release_all() # release!

# turn off the LED

led.value = False

time.sleep(0.01)

# Circuit Playground HID Keyboard

import time

import board

from adafruit_hid.keyboard import Keyboard

from adafruit_hid.keyboard_layout_us import KeyboardLayoutUS

from adafruit_hid.keycode import Keycode

from digitalio import DigitalInOut, Direction, Pull

# A simple neat keyboard demo in CircuitPython

# The button pins we‘ll use, each will have an internal pulldown

buttonpins = [board.BUTTON_A, board.BUTTON_B]

# our array of button objects

buttons = []

# The keycode sent for each button, will be paired with a control key

buttonkeys = [Keycode.A, “Hello World! ”]

controlkey = Keycode.SHIFT

# the keyboard object!

# sleep for a bit to avoid a race condition on some systems

time.sleep(1)

kbd = Keyboard()

# we’re americans :)

layout = KeyboardLayoutUS(kbd)

# make all pin objects, make them inputs with pulldowns

for pin in buttonpins:

button = DigitalInOut(pin)

button.direction = Direction.INPUT

button.pull = Pull.DOWN

buttons.append(button)

led = DigitalInOut(board.D13)

led.direction = Direction.OUTPUT

print(“Waiting for button presses”)

while True:

# check each button

# when pressed, the LED will light up,

# when released, the keycode or string will be sent

# this prevents rapid-fire repeats!

for button in buttons:

if button.value: # pressed?

i = buttons.index(button)

print(“Button #%d Pressed” % i)

# turn on the LED

led.value = True

while button.value:

pass # wait for it to be released!

# type the keycode or string

k = buttonkeys[i] # get the corresponding keycode or string

if isinstance(k, str):

layout.write(k)

else:

kbd.press(controlkey, k) # press.。.

kbd.release_all() # release!

# turn off the LED

led.value = False

time.sleep(0.01)

按按钮A或按钮B发送按键。

创建了Keyboard和Layout对象,我们现在只有美国(如果您进行其他布局,请提交GitHub pull请求!)

# the keyboard object!

kbd = Keyboard()

# we‘re americans :)

layout = KeyboardLayoutUS(kbd)

然后您可以发送kbd.press(keycode, 。..)的按键输入一次最多可以按下6次。请注意,这些都是键码,因此,如果您要发送大写字母A,则同时需要SHIFT和A。不要忘了不久之后拨打kbd.release_all(),否则您的键会被卡住

您也可以使用layout.write(“Hello World! ”)发送完整的字符串-它将使用布局确定要按下的键控代码。

有关更多详细信息,请参阅https://circuitpython.readthedocs.io/projects/hid/en/latest/

CircuitPython HID键盘和鼠标

我们加入CircuitPython的一件事是’HID‘( H uman I 界面 D 服务)-表示键盘和鼠标功能。这意味着您的CircuitPython开发板可以像键盘设备一样操作并按下键盘命令,或者像鼠标一样使鼠标指针移动并按下按钮。这真的很方便,因为即使您无法使软件适应硬件运行,也几乎总是有键盘接口-因此,如果您想为游戏提供电容式触摸界面,那么键盘仿真通常可以使您快速入门!

本节将向您介绍创建键盘或鼠标模拟器的代码。首先,我们将通过一个示例,该示例使用板上的引脚来模拟键盘输入。然后,我们将向您展示如何连接操纵杆以充当鼠标,并介绍实现该操作所需的代码。

您将需要 adafruit_hid 库文件夹如果您的/lib文件夹中还没有它!您可以从CircuitPython库捆绑中获取它。如果需要安装库的帮助,请查看CircuitPython库页面。

CircuitPython键盘模拟器

使用您喜欢的编辑器将代码复制并粘贴到 code.py 中,然后保存文件。

下载:Project Zip 或 CircuitPython_HID_Keyboard.py | 在Github上查看

复制代码

# CircuitPython demo - Keyboard emulator

import time

import board

import digitalio

from adafruit_hid.keyboard import Keyboard

from adafruit_hid.keyboard_layout_us import KeyboardLayoutUS

from adafruit_hid.keycode import Keycode

# A simple neat keyboard demo in CircuitPython

# The pins we’ll use, each will have an internal pullup

keypress_pins = [board.A1, board.A2]

# Our array of key objects

key_pin_array = []

# The Keycode sent for each button, will be paired with a control key

keys_pressed = [Keycode.A, “Hello World! ”]

control_key = Keycode.SHIFT

# The keyboard object!

time.sleep(1) # Sleep for a bit to avoid a race condition on some systems

keyboard = Keyboard()

keyboard_layout = KeyboardLayoutUS(keyboard) # We‘re in the US :)

# Make all pin objects inputs with pullups

for pin in keypress_pins:

key_pin = digitalio.DigitalInOut(pin)

key_pin.direction = digitalio.Direction.INPUT

key_pin.pull = digitalio.Pull.UP

key_pin_array.append(key_pin)

led = digitalio.DigitalInOut(board.D13)

led.direction = digitalio.Direction.OUTPUT

print(“Waiting for key pin.。.”)

while True:

# Check each pin

for key_pin in key_pin_array:

if not key_pin.value: # Is it grounded?

i = key_pin_array.index(key_pin)

print(“Pin #%d is grounded.” % i)

# Turn on the red LED

led.value = True

while not key_pin.value:

pass # Wait for it to be ungrounded!

# “Type” the Keycode or string

key = keys_pressed[i] # Get the corresponding Keycode or string

if isinstance(key, str): # If it’s a string.。.

keyboard_layout.write(key) # 。..Print the string

else: # If it‘s not a string.。.

keyboard.press(control_key, key) # “Press”。..

keyboard.release_all() # 。..“Release”!

# Turn off the red LED

led.value = False

time.sleep(0.01)

# CircuitPython demo - Keyboard emulator

import time

import board

import digitalio

from adafruit_hid.keyboard import Keyboard

from adafruit_hid.keyboard_layout_us import KeyboardLayoutUS

from adafruit_hid.keycode import Keycode

# A simple neat keyboard demo in CircuitPython

# The pins we’ll use, each will have an internal pullup

keypress_pins = [board.A1, board.A2]

# Our array of key objects

key_pin_array = []

# The Keycode sent for each button, will be paired with a control key

keys_pressed = [Keycode.A, “Hello World! ”]

control_key = Keycode.SHIFT

# The keyboard object!

time.sleep(1) # Sleep for a bit to avoid a race condition on some systems

keyboard = Keyboard()

keyboard_layout = KeyboardLayoutUS(keyboard) # We‘re in the US :)

# Make all pin objects inputs with pullups

for pin in keypress_pins:

key_pin = digitalio.DigitalInOut(pin)

key_pin.direction = digitalio.Direction.INPUT

key_pin.pull = digitalio.Pull.UP

key_pin_array.append(key_pin)

led = digitalio.DigitalInOut(board.D13)

led.direction = digitalio.Direction.OUTPUT

print(“Waiting for key pin.。.”)

while True:

# Check each pin

for key_pin in key_pin_array:

if not key_pin.value: # Is it grounded?

i = key_pin_array.index(key_pin)

print(“Pin #%d is grounded.” % i)

# Turn on the red LED

led.value = True

while not key_pin.value:

pass # Wait for it to be ungrounded!

# “Type” the Keycode or string

key = keys_pressed[i] # Get the corresponding Keycode or string

if isinstance(key, str): # If it’s a string.。.

keyboard_layout.write(key) # 。..Print the string

else: # If it‘s not a string.。.

keyboard.press(control_key, key) # “Press”。..

keyboard.release_all() # 。..“Release”!

# Turn off the red LED

led.value = False

time.sleep(0.01)

连接引脚 A1 或 A2 接地,使用电线或鳄鱼夹,然后断开连接以发送按键“ A”或字符串“ Hello world!”

此接线示例显示了A1

记住,在小装饰品上,A1和A2标记为2和0!在其他板上,您将按预期标记A1和A2。

创建对象和变量

首先,我们分配一些变量供以后使用。我们创建分配给变量的三个数组:keypress_pins,key_pin_array和keys_pressed。首先是我们将要使用的引脚。第二个为空,因为我们稍后将填充它。第三个是我们希望“键盘”输出的内容-在这种情况下为字母“ A”和短语“ Hello world!”。我们创建分配给control_key的最后一个变量,这允许我们以后将Shift键应用于按键。我们将使用两个按键,但是一次最多可以有六个按键。

下一个keyboard和keyboard_layout对象被创建。我们现在只有美国(如果您进行其他布局,请提交GitHub拉取请求!)。 time.sleep(1)避免了在主机完成连接到板之前,一旦插入板就立即运行程序的错误。

然后我们选择我们选择的引脚上方,并创建图钉对象,设置方向并为其分别上拉。然后,将别针对象应用于key_pin_array,以便以后使用。

接下来,我们将红色的小LED设置到该位置,以便将其用作状态灯。

在开始循环之前,我们要做的最后一件事是print,“正在等待钥匙扣。..”,因此您知道代码已准备就绪,正在等待!

主循环

在循环内部,我们检查每个引脚以查看状态是否已更改,即您将引脚接地。更改后,将打印“ Pin#已接地”。让您知道已检测到基态。然后,我们打开红色LED。代码等待状态再次改变,即等待您通过断开连接到引脚的电线从地面断开来使引脚接地。

然后代码从阵列中获取相应的按键。如果您将A1接地,那么代码将检索按键a,如果您将A2接地,则代码将检索字符串“Hello world!”

,如果代码找到了该字符串一个字符串,它使用keyboard_layout打印该字符串,以确定按键。否则,代码将打印control_key中的按键和按键“ a”,结果为“ A”。然后,它调用keyboard.release_all()。您总是想在按键后立即调用此命令,否则最终会遇到令人讨厌的卡住按键!

您可以尝试像我们一样为按钮接线,而不是使用电线将引脚接地在CircuitPython Digital In&Out中完成。尝试更改代码以添加更多用于更多按键选项的针脚!

CircuitPython鼠标模拟器

使用您喜欢的编辑器将代码复制并粘贴到 code.py 中,然后保存文件。

下载:项目Zip 或 CircuitPython_HID_Mouse.py | 在Github上查看

复制代码

import time

import analogio

import board

import digitalio

from adafruit_hid.mouse import Mouse

mouse = Mouse()

x_axis = analogio.AnalogIn(board.A0)

y_axis = analogio.AnalogIn(board.A1)

select = digitalio.DigitalInOut(board.A2)

select.direction = digitalio.Direction.INPUT

select.pull = digitalio.Pull.UP

pot_min = 0.00

pot_max = 3.29

step = (pot_max - pot_min) / 20.0

def get_voltage(pin):

return (pin.value * 3.3) / 65536

def steps(axis):

“”“ Maps the potentiometer voltage range to 0-20 ”“”

return round((axis - pot_min) / step)

while True:

x = get_voltage(x_axis)

y = get_voltage(y_axis)

if select.value is False:

mouse.click(Mouse.LEFT_BUTTON)

time.sleep(0.2) # Debounce delay

if steps(x) 》 11.0:

# print(steps(x))

mouse.move(x=1)

if steps(x) 《 9.0:

# print(steps(x))

mouse.move(x=-1)

if steps(x) 》 19.0:

# print(steps(x))

mouse.move(x=8)

if steps(x) 《 1.0:

# print(steps(x))

mouse.move(x=-8)

if steps(y) 》 11.0:

# print(steps(y))

mouse.move(y=-1)

if steps(y) 《 9.0:

# print(steps(y))

mouse.move(y=1)

if steps(y) 》 19.0:

# print(steps(y))

mouse.move(y=-8)

if steps(y) 《 1.0:

# print(steps(y))

mouse.move(y=8)

import time

import analogio

import board

import digitalio

from adafruit_hid.mouse import Mouse

mouse = Mouse()

x_axis = analogio.AnalogIn(board.A0)

y_axis = analogio.AnalogIn(board.A1)

select = digitalio.DigitalInOut(board.A2)

select.direction = digitalio.Direction.INPUT

select.pull = digitalio.Pull.UP

pot_min = 0.00

pot_max = 3.29

step = (pot_max - pot_min) / 20.0

def get_voltage(pin):

return (pin.value * 3.3) / 65536

def steps(axis):

“”“ Maps the potentiometer voltage range to 0-20 ”“”

return round((axis - pot_min) / step)

while True:

x = get_voltage(x_axis)

y = get_voltage(y_axis)

if select.value is False:

mouse.click(Mouse.LEFT_BUTTON)

time.sleep(0.2) # Debounce delay

if steps(x) 》 11.0:

# print(steps(x))

mouse.move(x=1)

if steps(x) 《 9.0:

# print(steps(x))

mouse.move(x=-1)

if steps(x) 》 19.0:

# print(steps(x))

mouse.move(x=8)

if steps(x) 《 1.0:

# print(steps(x))

mouse.move(x=-8)

if steps(y) 》 11.0:

# print(steps(y))

mouse.move(y=-1)

if steps(y) 《 9.0:

# print(steps(y))

mouse.move(y=1)

if steps(y) 》 19.0:

# print(steps(y))

mouse.move(y=-8)

if steps(y) 《 1.0:

# print(steps(y))

mouse.move(y=8)

我们通过选择按钮连接了2轴拇指操纵杆。我们使用它来模拟鼠标的移动和鼠标的左键单击。要连接此操纵杆,请执行以下操作:

将操纵杆上的 VCC 连接到板上的 3V 。将地面连接到地面。

连接操纵杆上的 Xout ,将您的 A0 固定在

连接操纵杆上的 Yout 以将 A1 固定到板上。

连接 Sel 在操纵杆上将 A2 固定在板上。

请记住,小饰品的引脚标记不同。检查“小装饰品的引脚排列”页面以验证接线。

要使用此演示,只需移动操纵杆即可。如果将操纵杆偏离中心一点,鼠标将缓慢移动;如果将操纵杆向远处移动,鼠标将更快地移动。在操纵杆上按下以单击鼠标。太棒了!现在让我们看一下代码。

创建对象和变量

首先,我们创建鼠标对象。

接下来,我们将x_axis和y_axis设置为引脚A0和A1。然后将select设置为A2,将其设置为输入并进行上拉。

操纵杆上的x和y轴的作用类似于2个电位器。我们将像在CircuitPython Analog In中一样使用它们。我们将pot_min和pot_max设置为从电位计读取的最小和最大电压。我们分配step = (pot_max - pot_min) / 20.0用于帮助器功能。

CircuitPython HID鼠标助手

首先,我们有get_voltage()助手,因此我们可以从电位计获取正确的读数。看起来熟悉?我们在模拟输入中了解了它。

第二,我们有steps(axis)。要使用它,请为其提供要读取的轴。这是我们将使用前面分配的step变量的地方。电位器范围为0-3.29。这是一个很小的范围。操纵杆的尺寸甚至更小,因为操纵杆位于此范围的中心1.66,并且每个轴的+和-都在该数字的上方和下方。由于我们的代码中需要包含阈值,因此我们将使用此辅助函数将0-3.29的范围映射到0-20.0之间的数字。这样,我们可以简化代码并为阈值使用更大的范围,而不是试图找出微小的十进制数字变化。

主循环

首先,我们分配x和y来读取x_axis和y_axis的电压。

接下来,我们检查一下选择按钮的状态何时为False。未按下时默认为True,因此,如果状态为False,则表示已按下该按钮。按下时,它发送命令以单击鼠标左键。 time.sleep(0.2)可以防止您只单击一次即可读取多次点击。

然后,我们使用steps()函数来设置鼠标的移动。每个轴有两组两个if语句。请记住,10是中心步骤,因为我们已经映射了范围0-20。每个轴的第一组表示操纵杆是否偏离中心1步(对于x轴,向左或向右移动;对于y轴,向上或向下移动),以将鼠标向适当的方向移动1个单位。每个轴的第二组表示是否将操纵杆移动到每个轴的最低或最高步长,以将鼠标向适当的方向移动8个单位。这样,您可以选择缓慢或快速移动鼠标!

要查看移动时操纵杆的位置,请取消注释step语句,以取消注释。在类似于print的行中单击# ,并连接到串行控制台以查看输出。考虑一次只取消注释一组,否则您将很快滚动大量信息,这可能很难阅读!

有关更多详细信息,请参阅https://circuitpython.readthedocs.io/projects/hid/en/latest/

中的文档div》

CircuitPython CPU温度

每个ATSAMD21,ATSAMD51和nRF52840芯片都内置有CPU温度传感器。 CircuitPython使得从该传感器读取数据非常简单。可以在Adafruit CircuitPython板上使用,该板上已内置在这些板上的微控制器中。

使用两个简单的命令即可读取数据。我们将在REPL中输入它们。插入您的电路板,连接到串行控制台,然后输入REPL。然后,在REPL中输入以下命令:

下载:文件

复制代码

import microcontroller

microcontroller.cpu.temperature import microcontroller

microcontroller.cpu.temperature

就是这样!您已经将摄氏温度打印到了REPL。请注意,这不完全是环境温度,也不是非常精确。

如果要在华氏温度下打印出来,请使用以下简单公式:Celsius *(9/5)+32。使用CircuitPython进行数学运算非常容易。看看吧!

请注意,nRF52840内置的温度传感器的分辨率为0.25摄氏度,因此您打印出的任何温度均为以0.25度为单位。

CircuitPython存储

CircuitPython开发板显示为USB驱动器,使您可以直接在开发板上编辑代码。您已经这样做了一段时间。到现在为止,您也许想知道,“我可以将来自 CircuitPython 的数据写入存储驱动器以充当数据记录器吗?”答案是是!

但是,这有点棘手。您需要向 boot.py 添加一些特殊的代码,而不仅仅是 code.py 。这是因为当您需要从计算机将代码编辑到磁盘上时,必须将文件系统设置为只读,而当您希望CircuitPython核心能够写入时,请将文件系统设置为可写。

您只能让计算机编辑CIRCUITPY驱动器文件或CircuitPython。您不能同时将两者写入驱动器。 (会发生错误的事情,因此我们不允许您这样做!)

以下是您的新 boot.py 。使用您喜欢的编辑器将代码复制并粘贴到 boot.py 中。您可能需要创建一个新文件。

Download:Project Zip 或 CircuitPython_Logger_Boot.py | 在Github上查看

复制代码

import board

import digitalio

import storage

# For Gemma M0, Trinket M0, Metro M0/M4 Express, ItsyBitsy M0/M4 Express

switch = digitalio.DigitalInOut(board.D2)

# For Feather M0/M4 Express

# switch = digitalio.DigitalInOut(board.D5)

# For Circuit Playground Express, Circuit Playground Bluefruit

# switch = digitalio.DigitalInOut(board.D7)

switch.direction = digitalio.Direction.INPUT

switch.pull = digitalio.Pull.UP

# If the switch pin is connected to ground CircuitPython can write to the drive

storage.remount(“/”, switch.value)

import board

import digitalio

import storage

# For Gemma M0, Trinket M0, Metro M0/M4 Express, ItsyBitsy M0/M4 Express

switch = digitalio.DigitalInOut(board.D2)

# For Feather M0/M4 Express

# switch = digitalio.DigitalInOut(board.D5)

# For Circuit Playground Express, Circuit Playground Bluefruit

# switch = digitalio.DigitalInOut(board.D7)

switch.direction = digitalio.Direction.INPUT

switch.pull = digitalio.Pull.UP

# If the switch pin is connected to ground CircuitPython can write to the drive

storage.remount(“/”, switch.value)

对于 Gemma M0, 小装饰品M0,Metro M0 Express,Metro M4 Express,ItsyBitsy M0 Express和ItsyBitsy M4 Express ,无需更改初始代码。

对于 Feather M0 Express和Feather M4 Express ,将switch = digitalio.DigitalInOut(board.D2)注释掉,并取消注释switch = digitalio.DigitalInOut(board.D5)。

对于 Circuit Playground Express和Circuit Playground Bluefruit ,请注释 switch = digitalio.DigitalInOut(board.D2),并取消注释switch = digitalio.DigitalInOut(board.D7)。请记住,D7是板载滑动开关,因此不需要多余的电线或鳄鱼夹。

记住:要“注释掉”一行,请在其前面加上#和空格。要“取消注释”一行,请从该行的开头删除#+空格。

以下是您的新 code.py 。使用您喜欢的编辑器将代码复制并粘贴到 code.py 中。

下载:Project Zip 或 CircuitPython_Logger.py | 在Github上查看

复制代码

import time

import board

import digitalio

import microcontroller

led = digitalio.DigitalInOut(board.D13)

led.switch_to_output()

try:

with open(“/temperature.txt”, “a”) as fp:

while True:

temp = microcontroller.cpu.temperature

# do the C-to-F conversion here if you would like

fp.write(’{0:f} ‘.format(temp))

fp.flush()

led.value = not led.value

time.sleep(1)

except OSError as e:

delay = 0.5

if e.args[0] == 28:

delay = 0.25

while True:

led.value = not led.value

time.sleep(delay)

import time

import board

import digitalio

import microcontroller

led = digitalio.DigitalInOut(board.D13)

led.switch_to_output()

try:

with open(“/temperature.txt”, “a”) as fp:

while True:

temp = microcontroller.cpu.temperature

# do the C-to-F conversion here if you would like

fp.write(’{0:f} ‘.format(temp))

fp.flush()

led.value = not led.value

time.sleep(1)

except OSError as e:

delay = 0.5

if e.args[0] == 28:

delay = 0.25

while True:

led.value = not led.value

time.sleep(delay)

记录温度

boot.py的工作方式是检查是否在代码中的开关设置中指定的引脚已连接到接地引脚。 。如果是这样,它将更改文件系统的读写状态,因此CircuitPython核心可以开始将温度记录到板上。

有关查找正确引脚的帮助,请参见中的接线图和信息。在CircuitPython数字输入和输出指南的查找引脚部分。不过,您无需使用开关接线,而是可以使用鳄鱼夹或跳线将引脚直接接地。

boot.py仅在设备首次启动时运行,如果您用ctrl + D重新加载串行控制台或保存文件,则不会运行。您必须弹出USB驱动器,然后按一下复位按钮!

将文件复制到板上后,将其弹出并从计算机上拔下。如果您正在使用Circuit Playground Express,则只需确保开关在右侧即可。否则,请使用鳄鱼夹或跨接线将所选的引脚接地。然后,将板子重新插入计算机。

您将无法再编辑CIRCUITPY驱动器上的代码!

红色LED应该每秒闪烁一次,您将看到一个新的温度.txt 文件放在CIRCUITPY上。

此文件每秒更新一次,但您不会看到实时数据。相反,当您准备好获取数据时,弹出并拔下电路板的电源。对于CPX,将开关向左移动,否则请断开将引脚接地的电线。现在,您可以再次从计算机写入文件系统了,但是它不会记录数据。

我们在此处提供了有关该项目的更详细的指南:使用CircuitPython记录CPU温度。如果您想要更多详细信息,请查看!

CircuitPython的期望

在我们继续开发CircuitPython和创建新版本时,我们将停止支持较旧的版本。访问https://circuitpython.org/downloads为您的电路板下载最新版本的CircuitPython。您必须下载与您的CircuitPython版本匹配的CircuitPython库捆绑包。请更新CircuitPython,然后访问https://circuitpython.org/libraries下载最新的库捆绑包。

始终运行最新版本的CircuitPython和库

在继续开发CircuitPython和创建新版本时,我们将不再支持较旧版本发布。 您需要更新到最新的CircuitPython。

您需要下载与您的CircuitPython版本匹配的CircuitPython库捆绑包。 请更新CircuitPython,然后下载最新的软件包。

当我们发布CircuitPython的新版本时,我们将停止提供以前的软件包作为Adafruit CircuitPython库软件包仓库中自动创建的下载文件。 。如果必须继续使用早期版本,则仍可以从CircuitPython存储库上特定版本的CircuitPython中下载mpy-cross的相应版本,并创建自己的兼容.mpy库文件。 但是,最好将CircuitPython和库捆绑包都更新为最新版本。

我必须继续使用CircuitPython 3.x或2.x,在哪里可以找到兼容的库?

我们是不再构建或支持CircuitPython 2.x和3.x库包。我们强烈建议您将CircuitPython更新到最新版本并使用当前版本的库。。但是,如果由于某种原因而无法更新,则可以在此处找到最后一个可用的2.x版本和最后一个可用的3版本。 .x在此处构建。

在CircuitPython之间切换和Arduino

许多CircuitPython板也运行Arduino。但是,如何在两者之间切换?在CircuitPython和Arduino之间切换很容易。

如果您当前正在运行Arduino,并想开始使用CircuitPython,请按照“欢迎使用CircuitPython:安装CircuitPython”中的步骤进行操作。

如果您当前正在运行CircuitPython,并想开始使用Arduino,插入您的电路板,然后加载Arduino草图。如果有任何问题,您可以双击“重置”按钮进入引导加载程序,然后尝试加载您的草图。始终备份要与CircuitPython一起使用的要保存的文件,因为它们可能会被删除。

就是这样!在这两者之间切换非常简单。

Express和Non-Express板之间的区别

在讨论CircuitPython时,我们经常引用“ Express”和“ Non-Express”板。这是什么意思?

Express是指板上包含一个额外的2MB闪存芯片,从而为CircuitPython和代码提供了额外的空间。这意味着我们可以在CircuitPython中包含更多功能,并且与在非Express板上相比,您可以在Express板上使用更多代码。

Express板包括Circuit Playground Express,ItsyBitsy M0 Express,Feather M0 Express,Metro M0 Express和Metro M4 Express。

非Express板包括Trinket M0,Gemma M0,Feather M0 Basic和其他非Express Feather M0变体。/p》

非速递板:Gemma和Trinket

CircuitPython可以在Gemma M0或Trinket M0上很好地运行,但是存在一些限制

磁盘空间小

由于我们将内部闪存用于磁盘,因此这是共享的使用运行时代码,其局限性!仅约50KB的空间。

没有音频或NVM

放弃将FLASH用作磁盘的一部分意味着我们无法容纳所有内容。目前,不提供任何支持用于硬件音频播放包或NVM’eeprom‘。不包括模块audioio和bitbangio。为此,请查看Circuit Playground Express或其他Express板。

但是,I2C,UART,电容式触摸,NeoPixel,DotStar,PWM,模拟输入和输出,数字IO,日志存储和HID做工作!检查CircuitPython Essentials中所有示例。

CircuitPython和MicroPython之间的区别

有关CircuitPython和MicroPython之间的区别,请查看CircuitPython文档。

CircuitPython和Python之间的差异

Python(也称为CPython)是MicroPython和CircuitPython所基于的语言。有许多相似之处,但也有许多差异。这是其中一些差异的列表。

Python库

Python的广告宣传为“包含电池”,这意味着包括许多标准库。不幸的是,由于空间原因,许多Python库不可用。因此,例如,虽然我们希望您可以import numpy,但numpy不可用。因此,您可能需要在自己身上移植一些代码!

CircuitPython中的整数

在非Express板上,整数最长只能为31位。不支持无限大小的整数。可以表示的最大正整数是2 30 -1,1073741823,最大负整数是-2 30 ,-1073741824。

从CircuitPython 3.0开始,Express板具有与Python中相同的任意长整数。

CircuitPython中的浮点数和浮点精度数字

CircuitPython中的浮点数是单精度(而不是Python中的双精度)。可以表示的最大浮点量约为+/- 3.4e38。可以以全精度表示的最小幅度约为+/- 1.7e-38,尽管可以以降低的精度表示小至+/- 5.6e-45的数字。

CircuitPython的浮点数为8指数位和22位尾数(不是24个常规的单精度浮点数),大约是5或6个十进制数字的精度。

MicroPython和Python之间的区别

对于有关CircuitPython和Python之间差异的更详细列表,您可以查看MicroPython文档。我们紧跟MicroPython稳定版本,因此请在此处查看它们记录的核心“差异”。

游乐场光传感器

尽管以下示例使用Circuit Playground Express进行了演示,代码与Circuit Playground Bluefruit的工作方式完全相同。只需复制代码,然后跟随您的Circuit Playground Bluefruit!

Circuit Playground Express可以看到您!好吧,不是真的。

但这会令人毛骨悚然。它可以感应明暗,甚至颜色和脉搏!!

板左上方的光传感器(看一下) (用于眼睛图标)是一个光电晶体管。以下是将其用作光传感器的方法:

下载:Project Zip 或 CircuitPlaygroundExpress_LightSensor.py | 在Github上查看

复制代码

# Circuit Playground Light Sensor

# Reads the on-board light sensor and graphs the brightness with NeoPixels

import time

import board

import neopixel

import analogio

import simpleio

pixels = neopixel.NeoPixel(board.NEOPIXEL, 10, brightness=.05, auto_write=False)

pixels.fill((0, 0, 0))

pixels.show()

light = analogio.AnalogIn(board.LIGHT)

while True:

# light value remapped to pixel position

peak = simpleio.map_range(light.value, 2000, 62000, 0, 9)

print(light.value)

print(int(peak))

for i in range(0, 9, 1):

if i 《= peak:

pixels[i] = (0, 255, 0)

else:

pixels[i] = (0, 0, 0)

pixels.show()

time.sleep(0.01)

# Circuit Playground Light Sensor

# Reads the on-board light sensor and graphs the brightness with NeoPixels

import time

import board

import neopixel

import analogio

import simpleio

pixels = neopixel.NeoPixel(board.NEOPIXEL, 10, brightness=.05, auto_write=False)

pixels.fill((0, 0, 0))

pixels.show()

light = analogio.AnalogIn(board.LIGHT)

while True:

# light value remapped to pixel position

peak = simpleio.map_range(light.value, 2000, 62000, 0, 9)

print(light.value)

print(int(peak))

for i in range(0, 9, 1):

if i 《= peak:

pixels[i] = (0, 255, 0)

else:

pixels[i] = (0, 0, 0)

pixels.show()

time.sleep(0.01)

将该代码复制并粘贴到文本编辑器中,然后将其保存为 code.py 。

代码读取光线传感器,然后根据光线水平像条形图一样点亮NeoPixels。尝试将手挥舞着,或用手电筒照亮以查看其变化!

游乐场温度

尽管以下示例使用Circuit Playground Express进行了演示,该代码与Circuit Playground Bluefruit的工作方式完全相同。只需复制代码,然后跟随您的Circuit Playground Bluefruit!

,但请等待!还有更多的东西-Circuit Playground Express也可以告诉温度!

您怎么问?内置热敏电阻。这个小传感器是一个热敏电阻,这意味着它的电阻会根据温度而变化。

我们可以通过导入 adafruit_thermistor 库,然后使用board.TEMPERATURE引脚以读取热敏电阻值。

将下面的代码复制到一个新文件中,然后将其作为main.py保存到板上。然后,打开一个REPL会话,您将同时看到摄氏温度和华氏温度的读数。

i》下载:Project Zip 或 CircuitPlaygroundExpress_Temperature.py | 在Github上查看

复制代码

# Circuit Playground Temperature

# Reads the on-board temperature sensor and prints the value

import time

import adafruit_thermistor

import board

thermistor = adafruit_thermistor.Thermistor(

board.TEMPERATURE, 10000, 10000, 25, 3950)

while True:

temp_c = thermistor.temperature

temp_f = thermistor.temperature * 9 / 5 + 32

print(“Temperature is: %f C and %f F” % (temp_c, temp_f))

time.sleep(0.25)

# Circuit Playground Temperature

# Reads the on-board temperature sensor and prints the value

import time

import adafruit_thermistor

import board

thermistor = adafruit_thermistor.Thermistor(

board.TEMPERATURE, 10000, 10000, 25, 3950)

while True:

temp_c = thermistor.temperature

temp_f = thermistor.temperature * 9 / 5 + 32

print(“Temperature is: %f C and %f F” % (temp_c, temp_f))

time.sleep(0.25)

尝试将手指放在传感器上(您会在板上看到温度计图标)并观察读数的变化。

游乐场鼓机

尽管以下示例使用Circuit Playground Express进行了演示,代码与Circuit Playground Bluefruit的工作方式完全相同。只需复制代码并跟随您的Circuit Playground Bluefruit!

一个聪明人曾经说过, -O-Eight。”

(那个聪明的人是Beastie Boys的Adam Horovitz。)

Ad-Rock所指的808是Roland TR-808鼓机。让我们为尊敬的808制作一些Circuit Playground Express吧!代替功能完备的鼓模式音序器,我们将重点放在机器的打击垫上,这些垫用于手指击鼓,以播放采样的鼓声。

我们可以在Circuit Playground上使用电容式触摸板表达为触发器,以及用于鼓声的小.wav文件!

首先,下载以下.zip文件,其中包含我们将使用的所有鼓采样。将文件保存到桌面或其他易于查找的位置,然后解压缩。

drumSamples.zip

您可以插入Circuit Playground Express。 ,然后将鼓文件拖到其上。它显示为CIRCUITPY驱动器。

现在是时候了为Circuit Playground Express编写代码!复制下面显示的代码,然后将其粘贴到您选择的代码编辑器中。将文件另存为CIRCUITPY驱动器上的 code.py 。

下载:Project Zip 或 CircuitPlaygroundExpress_808_Drum_Machine.py | 在Github上查看

复制代码

# Circuit Playground 808 Drum machine

import time

import board

import touchio

import digitalio

try:

from audiocore import WaveFile

except ImportError:

from audioio import WaveFile

try:

from audioio import AudioOut

except ImportError:

try:

from audiopwmio import PWMAudioOut as AudioOut

except ImportError:

pass # not always supported by every board!

bpm = 120 # Beats per minute, change this to suit your tempo

# Enable the speaker

speaker_enable = digitalio.DigitalInOut(board.SPEAKER_ENABLE)

speaker_enable.direction = digitalio.Direction.OUTPUT

speaker_enable.value = True

# Make the input capacitive touchpads

capPins = (board.A1, board.A2, board.A3, board.A4, board.A5,

board.A6, board.TX)

touchPad = []

for i in range(7):

touchPad.append(touchio.TouchIn(capPins[i]))

# The seven files assigned to the touchpads

audiofiles = [“bd_tek.wav”, “elec_hi_snare.wav”, “elec_cymbal.wav”,

“elec_blip2.wav”, “bd_zome.wav”, “bass_hit_c.wav”,

“drum_cowbell.wav”]

audio = AudioOut(board.SPEAKER)

def play_file(filename):

print(“playing file ” + filename)

file = open(filename, “rb”)

wave = WaveFile(file)

audio.play(wave)

time.sleep(bpm / 960) # Sixteenth note delay

while True:

for i in range(7):

if touchPad[i].value:

play_file(audiofiles[i])

# Circuit Playground 808 Drum machine

import time

import board

import touchio

import digitalio

try:

from audiocore import WaveFile

except ImportError:

from audioio import WaveFile

try:

from audioio import AudioOut

except ImportError:

try:

from audiopwmio import PWMAudioOut as AudioOut

except ImportError:

pass # not always supported by every board!

bpm = 120 # Beats per minute, change this to suit your tempo

# Enable the speaker

speaker_enable = digitalio.DigitalInOut(board.SPEAKER_ENABLE)

speaker_enable.direction = digitalio.Direction.OUTPUT

speaker_enable.value = True

# Make the input capacitive touchpads

capPins = (board.A1, board.A2, board.A3, board.A4, board.A5,

board.A6, board.TX)

touchPad = []

for i in range(7):

touchPad.append(touchio.TouchIn(capPins[i]))

# The seven files assigned to the touchpads

audiofiles = [“bd_tek.wav”, “elec_hi_snare.wav”, “elec_cymbal.wav”,

“elec_blip2.wav”, “bd_zome.wav”, “bass_hit_c.wav”,

“drum_cowbell.wav”]

audio = AudioOut(board.SPEAKER)

def play_file(filename):

print(“playing file ” + filename)

file = open(filename, “rb”)

wave = WaveFile(file)

audio.play(wave)

time.sleep(bpm / 960) # Sixteenth note delay

while True:

for i in range(7):

if touchPad[i].value:

play_file(audiofiles[i])

尝试一下!点击电容垫时,会触发相应的鼓采样!!

请注意,东西有点塞满了,因此您可以尝试添加铝箔,铜带,鳄鱼夹,等,以便增加击鼓的表面积和物理空间!

电容在启动时已校准,因此您可能需要将导线连接到打击垫后,请重置板!

如果您要使用自己的声音文件,可以!录制,采样,重新混音或仅从声音文件视域(例如freesample.org)下载文件。然后,要确保将文件转换为正确的规格,请在此处查看本指南,该指南将向您展示如何操作!剧透警报:您需要制作一个小的22Khz(或更低),16位PCM,单声道.wav文件!

想要在身体运动时聆听鼓机的数量?没问题!将1/8“或1/4”唱机输出连接到 GND 和 A0/Audio 垫,然后插入放大器!我在小型吉他放大器上尝试过,听起来很棒。

游乐场声音计

尽管以下示例使用Circuit Playground Express进行了演示,代码与Circuit Playground Bluefruit的工作方式完全相同。只需复制代码,然后跟随您的Circuit Playground蓝莓吧!

在Circuit Playground Express上使用麦克风来测量声级并将其显示在VU-像米一样的显示器!

该程序在下面。您可以更改许多设置,以使读数或多或少敏感并且显示或多或少跳动。尝试将CURVE更改为4或1或10或-2并查看会发生什么。

程序会在短时间内采样音频,并计算采样中的能量(对应于音量)使用均方根计算(RMS)。您可以尝试改变样本大小。

log_scale()函数会以指数方式点亮NeoPixels点亮的次数,因为声音的大小在响亮和柔和之间可能相差10倍。尝试改变计算方式以查看会发生什么。

该程序在开始设置“安静”声级时会采集一个样本。如果这对您不起作用,请将input_floor设置为固定数字。如果仪表似乎过于敏感,请尝试将input_ceiling = input_floor + 500更改为 input_ceiling = input_floor + 2000或更高。或采用其他方法。

您还可以更改颜色。尝试使用不同的方法计算volume_color(i)以获得更多的彩虹效果,或者如果您不喜欢更改颜色,则将其设为常数。

下载:Project Zip 或 CircuitPlaygroundExpress_SoundMeter.py | 在Github上查看

复制代码

# The MIT License (MIT)

#

# Copyright (c) 2017 Dan Halbert for Adafruit Industries

# Copyright (c) 2017 Kattni Rembor, Tony DiCola for Adafruit Industries

#

# Permission is hereby granted, free of charge, to any person obtaining a copy

# of this software and associated documentation files (the “Software”), to deal

# in the Software without restriction, including without limitation the rights

# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

# copies of the Software, and to permit persons to whom the Software is

# furnished to do so, subject to the following conditions:

#

# The above copyright notice and this permission notice shall be included in

# all copies or substantial portions of the Software.

#

# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

# THE SOFTWARE.

# Circuit Playground Sound Meter

import array

import math

import audiobusio

import board

import neopixel

# Color of the peak pixel.

PEAK_COLOR = (100, 0, 255)

# Number of total pixels - 10 build into Circuit Playground

NUM_PIXELS = 10

# Exponential scaling factor.

# Should probably be in range -10 。. 10 to be reasonable.

CURVE = 2

SCALE_EXPONENT = math.pow(10, CURVE * -0.1)

# Number of samples to read at once.

NUM_SAMPLES = 160

# Restrict value to be between floor and ceiling.

def constrain(value, floor, ceiling):

return max(floor, min(value, ceiling))

# Scale input_value between output_min and output_max, exponentially.

def log_scale(input_value, input_min, input_max, output_min, output_max):

normalized_input_value = (input_value - input_min) / \

(input_max - input_min)

return output_min + \

math.pow(normalized_input_value, SCALE_EXPONENT) \

* (output_max - output_min)

# Remove DC bias before computing RMS.

def normalized_rms(values):

minbuf = int(mean(values))

samples_sum = sum(

float(sample - minbuf) * (sample - minbuf)

for sample in values

return math.sqrt(samples_sum / len(values))

def mean(values):

return sum(values) / len(values)

def volume_color(volume):

return 200, volume * (255 // NUM_PIXELS), 0

# Main program

# Set up NeoPixels and turn them all off.

pixels = neopixel.NeoPixel(board.NEOPIXEL, NUM_PIXELS, brightness=0.1, auto_write=False)

pixels.fill(0)

pixels.show()

mic = audiobusio.PDMIn(board.MICROPHONE_CLOCK, board.MICROPHONE_DATA,

sample_rate=16000, bit_depth=16)

# Record an initial sample to calibrate. Assume it’s quiet when we start.

samples = array.array(‘H’, [0] * NUM_SAMPLES)

mic.record(samples, len(samples))

# Set lowest level to expect, plus a little.

input_floor = normalized_rms(samples) + 10

# OR: used a fixed floor

# input_floor = 50

# You might want to print the input_floor to help adjust other values.

# print(input_floor)

# Corresponds to sensitivity: lower means more pixels light up with lower sound

# Adjust this as you see fit.

input_ceiling = input_floor + 500

peak = 0

while True:

mic.record(samples, len(samples))

magnitude = normalized_rms(samples)

# You might want to print this to see the values.

# print(magnitude)

# Compute scaled logarithmic reading in the range 0 to NUM_PIXELS

c = log_scale(constrain(magnitude, input_floor, input_ceiling),

input_floor, input_ceiling, 0, NUM_PIXELS)

# Light up pixels that are below the scaled and interpolated magnitude.

pixels.fill(0)

for i in range(NUM_PIXELS):

if i 《 c:

pixels[i] = volume_color(i)

# Light up the peak pixel and animate it slowly dropping.

if c 》= peak:

peak = min(c, NUM_PIXELS - 1)

elif peak 》 0:

peak = peak - 1

if peak 》 0:

pixels[int(peak)] = PEAK_COLOR

pixels.show()

# The MIT License (MIT)

#

# Copyright (c) 2017 Dan Halbert for Adafruit Industries

# Copyright (c) 2017 Kattni Rembor, Tony DiCola for Adafruit Industries

#

# Permission is hereby granted, free of charge, to any person obtaining a copy

# of this software and associated documentation files (the “Software”), to deal

# in the Software without restriction, including without limitation the rights

# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

# copies of the Software, and to permit persons to whom the Software is

# furnished to do so, subject to the following conditions:

#

# The above copyright notice and this permission notice shall be included in

# all copies or substantial portions of the Software.

#

# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

# THE SOFTWARE.

# Circuit Playground Sound Meter

import array

import math

import audiobusio

import board

import neopixel

# Color of the peak pixel.

PEAK_COLOR = (100, 0, 255)

# Number of total pixels - 10 build into Circuit Playground

NUM_PIXELS = 10

# Exponential scaling factor.

# Should probably be in range -10 。. 10 to be reasonable.

CURVE = 2

SCALE_EXPONENT = math.pow(10, CURVE * -0.1)

# Number of samples to read at once.

NUM_SAMPLES = 160

# Restrict value to be between floor and ceiling.

def constrain(value, floor, ceiling):

return max(floor, min(value, ceiling))

# Scale input_value between output_min and output_max, exponentially.

def log_scale(input_value, input_min, input_max, output_min, output_max):

normalized_input_value = (input_value - input_min) / \

(input_max - input_min)

return output_min + \

math.pow(normalized_input_value, SCALE_EXPONENT) \

* (output_max - output_min)

# Remove DC bias before computing RMS.

def normalized_rms(values):

minbuf = int(mean(values))

samples_sum = sum(

float(sample - minbuf) * (sample - minbuf)

for sample in values

return math.sqrt(samples_sum / len(values))

def mean(values):

return sum(values) / len(values)

def volume_color(volume):

return 200, volume * (255 // NUM_PIXELS), 0

# Main program

# Set up NeoPixels and turn them all off.

pixels = neopixel.NeoPixel(board.NEOPIXEL, NUM_PIXELS, brightness=0.1, auto_write=False)

pixels.fill(0)

pixels.show()

mic = audiobusio.PDMIn(board.MICROPHONE_CLOCK, board.MICROPHONE_DATA,

sample_rate=16000, bit_depth=16)

# Record an initial sample to calibrate. Assume it‘s quiet when we start.

samples = array.array(’H‘, [0] * NUM_SAMPLES)

mic.record(samples, len(samples))

# Set lowest level to expect, plus a little.

input_floor = normalized_rms(samples) + 10

# OR: used a fixed floor

# input_floor = 50

# You might want to print the input_floor to help adjust other values.

# print(input_floor)

# Corresponds to sensitivity: lower means more pixels light up with lower sound

# Adjust this as you see fit.

input_ceiling = input_floor + 500

peak = 0

while True:

mic.record(samples, len(samples))

magnitude = normalized_rms(samples)

# You might want to print this to see the values.

# print(magnitude)

# Compute scaled logarithmic reading in the range 0 to NUM_PIXELS

c = log_scale(constrain(magnitude, input_floor, input_ceiling),

input_floor, input_ceiling, 0, NUM_PIXELS)

# Light up pixels that are below the scaled and interpolated magnitude.

pixels.fill(0)

for i in range(NUM_PIXELS):

if i 《 c:

pixels[i] = volume_color(i)

# Light up the peak pixel and animate it slowly dropping.

if c 》= peak:

peak = min(c, NUM_PIXELS - 1)

elif peak 》 0:

peak = peak - 1

if peak 》 0:

pixels[int(peak)] = PEAK_COLOR

pixels.show()

设置Arduino IDE

由于Circuit Playground Express使用以48 MHz运行的ATSAMD21芯片,因此您可以轻松地使其与Arduino IDE一起使用。大多数库(包括像NeoPixels和display这样的流行库)都可以与M0一起使用,尤其是使用i2c或SPI的设备和传感器。

Circuit Playground Express在Arduino IDE中是“本地”支持的,因此非常容易设置!

安装SAMD支持

通过导航到工具-》委员会菜单

打开委员会管理器

首先,安装 Arduino SAMD开发板版本 1.6.16 或更高版本

您可以在顶部搜索栏中输入 Arduino SAMD ,然后在看到时条目,单击安装

即使从理论上讲您也不需要-我建议重新启动IDE

退出并重新打开Arduino IDE 确保所有板卡均已正确安装。现在,您应该能够选择并上传到工具-》面板菜单中列出的新面板。

选择Circuit Playground Express面板:

还有一个定义Adafruit电路板支持包中的Adafruit Circuit Playground Express。如果您出于某些原因要尝试使用该定义,请

首先按照此页面激活Adafruit URL

然后按照此页面安装Adafruit SAMD软件包

安装驱动程序(仅Windows 7)

插入板卡时,可能需要安装驱动程序

单击下面的按钮以下载我们的驱动程序安装程序

下载Adafruit驱动程序安装程序v2.0.0.0

下载并运行安装程序,更多详细信息在此处

眨眼

现在您可以上传您的第一个眨眼素描!

插入Circuit Playground Express中,然后等待它被操作系统识别(只需几秒钟)。它将创建一个串行/COM端口,您现在可以从下拉列表中选择它,甚至可以“指示”为Circuit Playground Express板!

现在加载眨眼示例

下载:文件

复制代码

// the setup function runs once when you press reset or power the board

void setup() {

// initialize digital pin 13 as an output.

pinMode(13, OUTPUT);

}

// the loop function runs over and over again forever

void loop() {

digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)

delay(1000); // wait for a second

digitalWrite(13, LOW); // turn the LED off by making the voltage LOW

delay(1000); // wait for a second

} // the setup function runs once when you press reset or power the board

void setup() {

// initialize digital pin 13 as an output.

pinMode(13, OUTPUT);

}

// the loop function runs over and over again forever

void loop() {

digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)

delay(1000); // wait for a second

digitalWrite(13, LOW); // turn the LED off by making the voltage LOW

delay(1000); // wait for a second

}

,然后单击上载!就这样,您可以在适应 delay()调用时看到LED闪烁速率的变化。

如果遇到问题,请确保在菜单中选择了与您手中的硬件相匹配的匹配板。

上传成功

如果成功上传后,您会收到一堆红色文字,告诉您已找到设备,并且已对其进行了编程,验证和重置

编译问题

如果收到类似

的警报,则无法运行程序“ {runtime.tools.arm-none-eabi-gcc。 path} \ bin \ arm-non-eabi-g ++“

确保已安装 Arduino SAMD 开发板软件包,尝试重新安装或获取最新版本!另外,尝试更新IDE

手动引导加载

处于引导加载程序模式后,您可以选择新创建的COM/串行端口,然后重试上载。

ul》如果您曾经在引导加载程序中遇到“怪异”的地方,或者您上载的代码崩溃了并且无法自动重启进入引导程序,单击 RESET 按钮两次(类似于双击)返回引导程序。

红色LED将会脉动,所有NeoPixels都将变为绿色,因此您知道它处于引导加载程序模式。

在在Arduino IDE中,重新选择串行端口到为引导加载程序创建的新端口。

然后上传 Blink -确保

一旦生效,下次您要使用常规上传功能时,返回并重新选择“普通” USB串行端口。

Ubuntu&Linux问题修复

请注意,如果您使用的是Ubuntu 15.04(或者也许是其他较新的Linux发行版)调制解调器管理器服务存在问题,导致Bluefruit LE micro难以编程。如果在尝试编程时遇到“设备或资源繁忙”,“文件描述符错误”或“端口繁忙”之类的错误,那么您正在解决此问题。

此问题的解决方法是:确保将Adafruit的自定义udev规则应用于您的系统。制定了这些规则之一,以配置调制解调器管理器不要接触Feather板,这将解决编程困难的问题。请按照此页面上安装Adafruit的udev规则的步骤进行操作。

Arduino开关

与硬件接口的第一部分是能够管理数字输入和输出。借助内置的Circuit Playground硬件和Arduino库,超级简单!

此快速入门示例显示了如何使用Circuit Playground按钮之一作为输入来控制另一个数字输出-内置LED

下载:Project Zip 或 digitalio_lib.ino | 在Github上查看

复制代码

#include

void setup() {

// Initialize the circuit playground

CircuitPlayground.begin();

}

void loop() {

// If the left button is pressed.。..

if (CircuitPlayground.leftButton()) {

CircuitPlayground.redLED(HIGH); // LED on

} else {

CircuitPlayground.redLED(LOW); // LED off

}

}

#include

void setup() {

// Initialize the circuit playground

CircuitPlayground.begin();

}

void loop() {

// If the left button is pressed.。..

if (CircuitPlayground.leftButton()) {

CircuitPlayground.redLED(HIGH); // LED on

} else {

CircuitPlayground.redLED(LOW); // LED off

}

}

请注意,我们使代码的优雅程度有所降低,if/then可以替换为简单的CircuitPlayground.redLED(CircuitPlayground.leftButton()),但我想非常清楚如何测试输入。

按按钮A(左侧的一个),板载红色LED将会点亮!

没有库辅助

如果您对与硬件的“较低级别”接口感兴趣,则不必具有以使用CircuitPlayground帮助器库。此代码显示了手动将按钮/LED引脚设置为输入和输出以及设置和读取引脚状态的方法:

下载:Project Zip 或 digitalio.ino | 在Github上查看

复制代码

#include

void setup() {

pinMode(CPLAY_LEFTBUTTON, INPUT_PULLDOWN);

pinMode(CPLAY_REDLED, OUTPUT);

}

void loop() {

// If the left button is pressed.。..

if (digitalRead(CPLAY_LEFTBUTTON)) {

digitalWrite(CPLAY_REDLED, HIGH); // LED on

} else {

digitalWrite(CPLAY_REDLED, LOW); // LED off

}

}

#include

void setup() {

pinMode(CPLAY_LEFTBUTTON, INPUT_PULLDOWN);

pinMode(CPLAY_REDLED, OUTPUT);

}

void loop() {

// If the left button is pressed.。..

if (digitalRead(CPLAY_LEFTBUTTON)) {

digitalWrite(CPLAY_REDLED, HIGH); // LED on

} else {

digitalWrite(CPLAY_REDLED, LOW); // LED off

}

}

请注意,至少在基于M0/SAMD的CircuitPython开发板上,您还可以使用内部上拉INPUT_PULLUP使用外部按钮时,但内置按钮需要INPUT_PULLDOWN。

也许您要使用上拉或下拉电阻设置自己的外部按钮。如果要关闭内部上拉/下拉,只需将pinMode()设置为普通INPUT

使草图适应M0和M4

ATSAMD21和51是非常好的小芯片,但是随着与Arduino兼容的内核的发展,它还是相当新的。 大多数草图和库都可以使用,但这是我们注意到的一些东西。

下面的注释涵盖了Adafruit M0和M4板的范围,但并非每条规则都适用于每条规则板(例如小饰品和Gemma M0没有ARef,因此您可以跳过“模拟参考”注释!)。

模拟参考

如果您想将 ARef 引脚用作非3.3V模拟参考,使用的代码是analogReference(AR_EXTERNAL)(不是AR_EXTERNAL,不是EXTERNAL)

Pin输出和上拉

打开引脚作为上拉输入的老式方式是使用

pinMode(pin, INPUT)

digitalWrite(pin, HIGH)

这是因为8位AVR芯片上的上拉选择寄存器与输出选择寄存器相同。

对于M0和M4板,不能再这样做了!而是使用:

pinMode(pin, INPUT_PULLUP)

以这种方式编写的代码仍然具有与AVR向后兼容的优点。您不需要

串行与串行USB

99.9%的现有Arduino草图使用 Serial.print 进行调试并提供输出。对于官方的Arduino SAMD/M0内核,此连接到Serial5端口,该端口未在Feather上公开。官方Arduino M0内核的USB端口称为 SerialUSB 。

在Adafruit M0/M4内核中,我们将其固定为串行连接到USB,因此它将自动正常工作。

但是,在偶然的情况下,您使用的是官方Arduino SAMD内核,而不是 Adafruit版本(实际上,我们建议您使用我们的版本,因为它已调整到我们的主板上),并且您希望串行打印和读取使用USB端口,请使用 SerialUSB 代替草图中的序列。

如果您已有草图和代码,并且希望它们与M0一起使用而不需要大量查找,则将

#if defined(ARDUINO_SAMD_ZERO) && defined(SERIAL_PORT_USBVIRTUAL)

// Required for Serial on Zero based boards

#define Serial SERIAL_PORT_USBVIRTUAL

#endif

在代码中第一个函数定义的正上方。例如:

Feather/Metro M0上的AnalogWrite/PWM

在SAMD21数据表中,我们发现多路复用器表中列出的某些选项在Feather M0所使用的特定芯片上不存在。

对于所有SAMD21芯片,有两个外设可以产生PWM信号:定时器/计数器(TC)和用于控制应用的定时器/计数器(TCC)。每个SAMD21都有各自的多个副本,称为“实例”。

每个TC实例都有一个计数寄存器,一个控制寄存器和两个输出通道。可以启用和禁用任何一个通道,并且可以反转任何一个通道。连接到TC实例的引脚可以输出相同版本的相同PWM波形或互补波形。

每个TCC实例都有一个计数寄存器,但是有多个比较寄存器和输出通道。

SAMD21系列的最大成员有五个带有两个“波形输出”(WO)通道的TC实例,还有一个用于不同类型的波形的选项。具有八个WO通道的三个TCC实例:

TC [0-4],WO [0-1]

TCC [0-2],WO [0-7 ]

这些是数据表的多路复用器表中显示的。

Feather M0中使用的SAMD21G只有三个带两个输出通道的TC实例和三个TCC具有八个输出通道的实例:

TC [3-5],WO [0-1]

TCC [0-2 ],WO [0-7]

跟踪到Feather M0上断开的引脚的信号,以下引脚根本无法执行PWM:

模拟引脚A5

只要SPI,I2C和UART,可以将以下引脚配置为PWM,而没有任何信号冲突引脚保留其协议功能:

数字引脚5、6、9、10、11、12和13

模拟引脚A3和A4

如果仅SPI引脚保持其协议功能,则还可以执行PWM在以下引脚上:

TX和SDA(数字引脚1和20)

analogWrite()PWM范围

在AVR上,如果将引脚的PWM设置为analogWrite(pin, 255)它将使引脚完全变为高电平。在ARM皮质上,它将设置为255/256,因此会有非常细小的但仍然存在的0V脉冲。如果您需要完全固定该引脚,请添加测试代码以检查是否要尝试analogWrite(pin, 255),而是执行digitalWrite(pin, HIGH)

如果您尝试使用

analogWrite()A0上的DAC

1》要控制 A0 上的DAC输出,请确保您没有没有设置将引脚设置为输出的线。 删除 :analogWrite()。

缺少头文件

可能有一些代码使用了M0内核不支持的库。例如,如果您的行与

pinMode(A0, OUTPUT)

相对应,则会显示一条错误消息

#include

在这种情况下,您只需找到行所在的位置(错误将为您提供文件名和行号),然后用#ifdef将其“换行”,如下所示:

下载:文件

复制代码

fatal error: util/delay.h: No such file or directory

#include

^

compilation terminated.

Error compiling. #if !defined(ARDUINO_ARCH_SAM) && !defined(ARDUINO_ARCH_SAMD) && !defined(ESP8266) && !defined(ARDUINO_ARCH_STM32F2)

#include

#endif

上面的内容还将确保其他体系结构不包含头文件

如果arduino草图本身包含#include,则可以尝试删除该行。

Bootloader启动

对于大多数其他AVR,在插入USB时单击重置会手动启动引导程序,引导程序将在几秒钟后超时。对于M0/M4,您需要 双击 按钮。您将看到红色的脉动LED,以告知您处于引导加载程序模式。一旦进入该模式,它就不会超时!如果要返回启动代码,请再次单击“重置”。

对齐的内存访问

这不太可能发生在您身上,但它发生在我身上!如果您习惯使用8位平台,则可以在可以键入变量的地方做这件好事。例如

#if !defined(ARDUINO_ARCH_SAM) && !defined(ARDUINO_ARCH_SAMD) && !defined(ESP8266) && !defined(ARDUINO_ARCH_STM32F2)

#include

#endif

uint8_t mybuffer[4];

您不能保证它可以在32位平台上运行,因为 mybuffer 可能未与2或4字节边界对齐。 ARM Cortex-M0只能直接访问16位边界(每2或4个字节)上的数据。尝试访问奇数边界字节(位于1或3字节位置)将导致硬件故障并停止MCU。值得庆幸的是,有一个简单的解决方法。..只需使用memcpy!

float f = (float)mybuffer;

浮点转换

类似于AVRArduino,M0库不完全支持将浮点数转换为ASCII字符串。像sprintf这样的函数不会转换浮点数。幸运的是,标准的AVR-LIBC库包含dtostrf函数,可以为您处理转换。

不幸的是,M0运行时库没有dtostrf。您可能会看到一些使用 #include 来获取dtostrf的引用。尽管可以编译,但它不起作用。

相反,请查看此线程以找到可以在代码中包含的有效dtostrffunction:

http://forum.arduino.cc/index.php?topic=368720.0

有多少可用内存?

ATSAMD21G18具有32K RAM,但是出于某些原因,您可能仍需要对其进行跟踪。您可以使用以下便捷功能进行操作:

下载:文件

复制代码

uint8_t mybuffer[4];

float f;

memcpy(&f, mybuffer, 4) extern “C” char *sbrk(int i);

int FreeRam () {

char stack_dummy = 0;

return &stack_dummy - sbrk(0);

}

Thx到http://forum.arduino.cc/index.php?topic=365830.msg2542879#msg2542879提示!

在FLASH中存储数据

如果您习惯使用AVR,则可能已使用 PROGMEM 使编译器知道您要在闪存中放入变量或字符串以保存在RAM中。在ARM上,它稍微容易一些,只需在变量名之前添加 const :

const char str [] =“我的长字符串”;

该字符串现在位于FLASH中。您可以像处理RAM数据一样操作字符串,编译器将自动从FLASH中读取数据,因此您不需要特殊的可编程序知识功能。

您可以通过打印地址来验证数据的存储位置:

Serial.print(“ str $的地址”); Serial.println((int)&str,HEX);

如果地址为$ 2000000或更大,则位于SRAM中。如果地址在$ 0000到$ 3FFFF之间,则为FLASH

漂亮地打印出寄存器

SAMD21上有很多寄存器,您经常需要通过ASF或其他框架来获得它们。因此,有一种方法可以准确地了解正在发生的事情。这个来自drewfish的库将帮助很多!

https://github.com/drewfish/arduino-ZeroRegs

M4性能选项

自 Adafruit SAMD开发板软件包的1.4.0版开始在Arduino开发板管理器中,一些选项可用于使基于M4的设备获得额外的性能。这些位于工具菜单中。

所有这些性能调整都涉及一定程度的不确定性。不能保证在任何给定项目中都会改善性能,并且有些甚至可能有害,不能部分或全部起作用。如果遇到问题,请选择默认性能设置并重新上传。

这就是您所得到的以及可能遇到的一些问题……

CPU速度(超频)

此选项可让您调整微控制器核心时钟…处理指令的速度…超出了官方数据表的规格。

制造商通常会保守地评估速度,因为此类设备是为苛刻的工业环境而销售的……如果系统崩溃,则可能会失去优势或更糟。但是大多数创造性的任务并不那么关键,并且可以在更舒适的环境中运行,并且如果我们想要更高的速度,我们可以稍作努力。

发生代码锁定的机会很小,但也不为零或完全无法运行。如果发生这种情况,请尝试将速度调低一个档并重新上传,看看它是否更稳定。

更有可能的是,某些代码或库可能不会使用非标准的CPU速度发挥出色。例如,当前NeoPixel库假设CPU速度为120 MHz,并且在其他设置下不会发布正确的数据(此方法可以解决)。其他库可能也会出现类似的问题,通常是任何严格取决于CPU时序的问题……您可能会遇到与音频或伺服相关的代码,具体取决于编写方式。如果遇到此类代码或库,请将CPU速度设置为默认为120 MHz并重新上传。

优化

通常,解决问题的方法不只一种,而且比其他方法更耗费资源。自Arduino在资源有限的AVR微控制器上开始以来,C ++编译器就一直致力于最小的编译程序大小。 “ Optimize”菜单为编译器提供了一些选择,使编译器可以采用不同的方法,并且通常采用更快的方法,但代价是程序尺寸稍大……M4设备具有巨大的闪存容量,这现在几乎没有问题。

“ 小”设置将像以往一样编译您的代码,以最小的编译程序大小为目标。

“ 快速 ”设置会调用各种速度优化。生成的程序应产生相同的结果,稍大一些,并且通常(但不总是)明显更快。值得一试!

“ 这里是龙”调用了一些更深入的优化…代码将变得更大,更快,但是这些优化有可能导致意外行为。 某些代码可能与以前的工作方式不同。因此得名。也许您会在这里发现宝藏,或者您可能会驶向世界的边缘。

无论优化程序如何设置,大多数代码和库将继续起作用。如果确实遇到问题,请将其拨回一个档并重新上传。

缓存

此选项比访问闪存可以更快地访问少量指令和数据,从而提高了性能。默认情况下,它已启用,并且可以与所有代码和库一起正常工作。但是,如果遇到一些深奥的情况,可以禁用缓存,然后重新编译并上传。

Max SPI和Max QSPI

这些应该保留为默认值。它们主要用于我们自己的实验,并且可以导致严重的头痛。

最大SPI确定M4的SPI外设的时钟源。在正常情况下,这允许传输高达24 MHz,通常应保持该设置。但是…如果您使用的是只写SPI设备(例如TFT或OLED显示器),则可以使用此选项更快地驱动它们(我们已经成功地将60 MHz用于某些TFT屏幕)。需要注意的是,如果使用任何读/写设备(例如SD卡),这将根本无法工作。.. SPI会绝对读取 在默认的24 MHz设置下最大输出,否则任何其他操作都会失败。 写入=确定。读取=失败。 这是正确的,即使您的代码使用的是较低的比特率设置…只是时钟源不同也会阻止SPI读取。

Max QSPI的工作原理与此类似用于M4“ Express”板上的额外闪存。 很少 Arduino草图完全可以访问该存储,更不用说在带宽受限的情况下了,所以这几乎没人能受益。此外,由于选择了时钟分频器,仅当某些“ CPU Speed”设置处于活动状态时,这才会提供一些好处。如果使用QSPI闪光灯,我们的PyPortal动画GIF显示器运行效果会更好。

在某些M4板上启用降压转换器

如果要降低功耗,我们的某些板上有一个电感,因此可以使用1.8V降压转换器代替内置线性稳压器。如果电路板上确实有一个电感器(请参见原理图),则可以将extern “C” char *sbrk(int i);

int FreeRam () {

char stack_dummy = 0;

return &stack_dummy - sbrk(0);

}行添加到代码中以切换到它。请注意,这会使ADC/DAC的读取噪声更大,因此默认情况下不使用它。您将节省〜4mA。

故障排除

使用外部NeoPixel条/Arduino中带有Circuit Playground的点

我们在Arduino CircuitPlayground库中具有NeoPixel库的“内部”版本。如果要使用外部LED,请确保草图的顶部包含库,以使NeoPixel最先出现。例如:

#include

#include

CPLAYBOOT在Windows 10上不出现;

Arduino中的“ ARM7TDMI”错误

安装Arduino IDE和Arduino板支持包 Arduino SAMD 和/或 Adafruit SAMD 后,有些人在Windows 10上使用Circuit Playground Express遇到了困难。问题是这些板级支持软件包在Windows 10上安装了不必要的驱动程序。这会导致两个问题:

1。双击板上的重置按钮时,不会出现 CPLAYBOOT 。

2。尝试上传Arduino程序会产生错误,例如:

An error occurred while uploading the sketch

chipId=0x30455553

Unsupported ARM7TDMI architecture

Arduino更新了这些软件包以解决问题。同时,解决方法是卸载错误的驱动程序。安装了三个不必要的驱动程序,一个用于 CPLAYBOOT ,一个用于 CIRCUITPY ,另一个用于在Circuit Playground Express上运行的Arduino程序。您应该卸载所有它们。

在所有三种情况下,都可以通过右键单击“开始”菜单并选择“设备管理器”来打开设备管理器。然后在新窗口中打开端口部分。您会看到类似以下清单的内容。措词会有所不同,但其中将包括“ Adafruit Circuit Playground Express”。

您要卸载该设备的驱动程序。右键单击设备,选择卸载设备,然后在出现对话框时,选中“删除该设备的驱动程序软件”框。并单击确定。看起来像这样:

您需要执行上述操作三次,每次都遵循上述步骤。

1。首先,双击重置按钮,使所有NeoPixels变为绿色。通常会出现 CPLAYBOOT ,但如果安装了错误的驱动程序,则不会出现。然后拔下并重新插入板上。

2。再次双击重置按钮。这次应该出现 CPLAYBOOT 。遵循本指南Arduino部分中的说明,将Arduino程序上载到板上,例如Blink。

3。如果您将 CIRCUITPY 作为驱动器显示在板上,则进行卸载(如果您已在电路板上安装了CircuitPython)。

每次您都会在“设备管理器”中看到与上述类似的条目,并带有措辞略有不同,COM端口也不同。如上图所示,卸载设备。

如果时间紧迫,则数字1是要卸载的最重要的驱动程序。

分别卸载后,设备,您可以拔下并重新插入开发板,它将使用内置的Windows驱动程序(而不是错误的驱动程序)重新安装。双击重置按钮以获取 CPLAYBOOT 并重新安装。新设备将在设备管理器中显示为“ USB串行设备(COMxx)”,而不是“ Adafruit Circuit Playground”,如下图所示:

责任编辑:wv

声明:本文由入驻电子说专栏的作者撰写或者网上转载,观点仅代表作者本人,不代表电子发烧友网立场。如有侵权或者其他问题,请联系举报。侵权投诉

收藏

相关话题

评论(0)

加载更多评论

分享到

QQ空间 QQ好友 微博
取消