软件使用基础¶
Basic Of Mixly¶
Mixly 简介¶
Mixly（米思齐）是一款图形化编程软件。用户可以通过拼接积木块的方式来编写程序。目前为止，Mixly已经支持Arduino，micropython，python等编程语言。
简介¶
Mixly（米思齐）是在北京师范大学傅骞博士团队组织开发的一款国内自主研发，且免费开源的图形化编程工具。在国内外都掀起创客教育的浪潮中，傅骞老师认真分析了当前电子领域内的创客教育，并认为“如果不能给学生提供一个足够简单的、不能给教师提供一个容易上手的，不能给各大生产厂商提供一个足够自主的编程工具，所谓的“创”也只能是停留在表面的浮云，风一吹便散。”为了大力贯彻落实创客实验室“自主实践，分享快乐”的教育理念，傅骞老师带领其团队，开发出具有易用性、简单性、功能性、普适性、延续性及生态性等特点的Mixly。
特点¶
易用性¶
当前多数中小学机房安装了硬盘保护卡，频繁的软件安装与更新工作，给机房的管理工作造成极大的不便。为此，Mixly在设计上做到了完全绿色使用。用户直接从网上下载Mixly软件包，解压后即可在Windows XP及以上的操作系统运行。软件无需额外安装浏览器，也不用安装Java运行环境，极大方便了师生的使用。
简单性¶
Mixly采用了Blockly图形化编程引擎，使用图形化的积木块代替了复杂的文本操作，为学生的快速入门奠定了良好的基础。另外，Mixly的开发团队使用以下方式来帮助师生快速熟悉软件：第一，用不同颜色的示意图标代表不同类型的功能块，方便用户归类区分；第二，在复合功能块中提供默认选项，有效减少用户的拖动次数；第三，在同一个界面整合软件的所有功能；第四，提供参考教程及代码示例。
功能性¶
当前，很多学校将组织或参与创客类比赛作为创客教育的一种途径，比赛的竞技性对软件的功能提出了更高的要求。因此，Mixly在功能的设计上力求和Arduino IDE的文本编程保持一致，目前最新发布的Mixly 0.97版已经实现Arduino的所有官方功能（包括中断处理），并加入了大量的第三方扩展库功能，如红外遥控、超声波等，可以保证课程开设和各类创客比赛的双重需求。
普适性¶
Mixly在设计上考虑了绝对的普适性。首先，对于Arduino官方支持的所有开发板，Mixly都提供了完美的支持：Mixly会根据开发板的类型自动改变模块中的管脚号、中断号、模拟输出管脚等；其次，对于Arduino支持的第三方开发板，Mixly同样支持，用户只要把相应开发板的定义复制到Mixly中即可。如国内大量的ESP8266开发板、各类用户修改后的开发板等等，以保证用户在开发板选择上的最大自由度。
延续性¶
图形化编程系统的目标绝对不是替换原有的文本编程方式，而是希望学生通过图形化编程更好更快地理解编程的原理和程序的思维，并为未来的文本编程打好基础。Mixly的设计理念也是如此。在软件的设计上加入了更多的可延续性内容，从而保护用户的学习成果。具体来说，包括引入变量类型、在模块的设计上尽量保持和文本编程的一致、支持图形编程和文本编程的对照等。
生态性¶
生态性是Mixly最重要的设计理念，也是它区别于其它Arduino图形化编程的最重要特征。为了实现Mixly可持续发展，Mixly在设计上既允许厂商开发自己的特有模块（当前已经支持DfRobot、StartLab、MakeBlock、Sense、Seeed、Lubot，Microduino、Ruilong、NodeMcu，Nova，用户需要有JavaScript编程基础才能制作这部分模块），也允许用户直接利用Mixly的图形化编程功能生成通用模块（如数码管显示、蜂鸣音播报等，用户只需会使用Mixly即可制作这部分模块）。以上两类模块均可通过“导入库”功能导入Mixly系统，从而在Mixly软件的普及中实现用户自身的价值。
软件安装与更新¶
目前最新版本为1.0.0，支持Windows 7/8/10、MacOS、Linux(非arm框架)。
下载软件¶
- 【Window系统 地址1】 Mixly For Win7or10
- 【Window系统 地址2】 Mixly For Win7or10
- 【Mac系统】 Mixly For Mac
Windows版本安装¶
安装软件¶
下载Mixly_WIN.7z压缩包，右键解压到本地磁盘。
Note
- 建议解压到硬盘根目录，路径不能包含中文及特殊字符(如:. _ ( ) 等)。
- 建议安装路径如E:Mixly
解压后目录如图所示。
第一次解压的软件只含有最基础的文件，不能直接运行。需要先运行 一键更新.bat 或 update.bat下载最新版的Mixly软件。
等待片刻后，会显示更新进度。
当看到提示“Mixly更新完成”时，说明软件下载完毕。
更新完成后，软件目录如图所示，可以双击Mixly.exe打开Mixly软件。
更新软件¶
Mixly软件的更新是基于git设计的，每次更新会自动对比最新版与用户使用的版本的差异，只更新差异文件，避免重复下载造成版本混乱。
先关闭Mixly软件，再运行 一键更新.bat或update.bat 启动更新程序。
稍等片刻后，更新完成。
驱动安装¶
开发板与电脑连接通讯需要安装相应的串口芯片驱动，常用的串口芯片驱动有CH340和CP2102。 在arduino/drivers目录中可以找到这两种串口芯片驱动。
根据使用的开发板的串口芯片选择相应的驱动，如果不确定是哪种串口芯片，也可以将两个驱动都安装上。
Mac版本安装¶
解压软件¶
下载jre-8u221-macosx-x64.dmg Java 安装包，根据提示默认安装。
下载Mixly1.0_MAC.zip压缩包，右键解压到本地磁盘。
解压后目录如图所示。
1.MAC必须安装JDK8,而且只能安装JDK8,高版本JAVA不行，可以直接使用云盘目录自带的JDK 2.需要安装相应的开源硬件驱动，常用的就是云盘自带的cp210x驱动和ch34x驱动 3.需要自行安装 python3(安装包在云盘) 4.安装完python3之后，运行以下命令行操作
1 2 3 4 5 6 7 | sudo xcode-select --install
ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
brew install portaudio
pip3 install pyaudio
brew install opencv
pip3 install opencv-python
pip3 install baidu-aip matplotlib pandas numpy
|
5.解压Mixy后双击Mixly.jar即可使用
驱动安装¶
开发板与电脑连接通讯需要安装相应的串口芯片驱动，常用的串口芯片驱动有CH340和CP2102。 Mixly/drivers目录中可以找到这两种串口芯片驱动。
根据使用的开发板的串口芯片选择相应的驱动，如果不确定是哪种串口芯片，也可以将两个驱动都安装上。
更新软件¶
Mixly软件的更新是基于git设计的，每次更新会自动对比最新版与用户使用的版本的差异，只更新差异文件，避免重复下载造成版本混乱。
先关闭Mixly软件。 打开 终端 并通过 cd 命令进入mixly软件所在目录（输入 cd后可以将mixly文件夹拖入 终端 窗口）。
依次输入输入更新命令：
1 2 3 | git add *
git stash
git pull origin master
|
稍等片刻，就可以看到更新文件完成。
界面介绍¶
Mixly软件主要分成图形化程序选择区、图形化程序编辑区、代码预览区、系统功能区、消息提示区。
程序编写区¶
程序编写¶
我们通常把能完成一定功能的代码块拖动到该区域处进行连接。
程序删除¶
- 将不需要的代码拖到右下方的垃圾桶。
- 将不用的代码拖到最左侧的图形化程序选择区。
- 选中不用的代码后点击键盘Delete或者Backspace键。
撤销及重做¶
在选择语言的左边还有两个箭头，分别是撤销（undo，Ctrl + Z）及重做（redo，Ctrl + Y）。
撤销功能是当我们编写代码时误删代码后，便可点击左箭头或直接按Ctrl + Z来恢复误删代码。
而重做则是和Ctrl + Z相反，它是恢复上一步操作，该功能也可通过点击右箭头或直接键入Ctrl + Y 来实现。
帮助文档¶
在选择语言的左侧?图标是帮助文档的链接，点击该图标可以打开帮助文档。
代码预览区¶
该区域可通过点击右侧深灰色箭头来显示或隐藏。
在图形化程序选择区拖拽图形块后，在代码编辑区会生成对应的代码。可以帮助用户掌握代码的学习。
Attention
在该区域无法直接对代码进行编辑，需要点击图形化程序选择区左上角的 代码 按钮才能进行编辑。
一般功能¶
Mixly的一般功能包括新建、打开、保存、另存为，其中代码保存或另存为的格式为.mix或者.ino。
当用户需要打开已保存的文件时，可以先打开Mixly软件，再点击“打开”，找到*.mix文件。也可以直接双击*.mix文件打开。
库功能¶
为了方便用户使用及代码分享，Mixly特增加了库功能。库功能分别包括：导出库，导入库以及管理库。 当用户编写完一段代码后（比如语音播报），可这个代码集成在一个函数中（假设该函数为sayNum）。之后只需要点击导出库并给该库起个名字便能使用。
保存后就可以将该库上传至平台，供他人下载使用、学习。
当有人下载该代码后，可直接将该库进行导入并使用。点击导入库找到该文件的位置。
导入后界面会刷新，耐心等待1-2秒，便可在模块选择区见到新导入的库，同时，在消息提示区也会提示“导入自定义库成功！”接着可直接点击sayNum库，将指令拖入程序构建区，调用该函数即可。
管理库的功能是可以对已导入的库进行重命名、删除和打开目录。
编译&上传¶
当用户编写完代码后，如果想要检查代码逻辑是否有误，可点击编译。
如果显示“编译失败”，则需要根据提示检查自己的代码，如显示“编译成功”则证明代码逻辑上无误，可上传。
如果出现“上传失败”，大多数情况插拔USB线即可解决该问题。
如果出现“上传成功”，则证明代码已上传至板子上。当然，如果用户对于代码逻辑信心十足，可直接点击上传按钮。
板卡&端口¶
当用户点击主控板下拉三角时即可看到有众多主控板型号可供选择。用户需按照当前手中主控板型号予以选择。
Attention
开始编程前就要先选择板卡，编写好程序再切换板卡将导致程序丢失。
选择好板卡后，还需要选择该板卡对应的端口号，端口号是计算机与板卡通信的通道。
串口监视器¶
串口监视器与模块选择区的通信模块中的串口通信指令一起使用。 可以用于输出变量、传感器数值等。
界面缩放¶
在串口监视器右侧有一个左右可拉的按钮，该按钮可放大或缩小Mixly整个界面的大小。
与程序构建区内的放大、缩小不同（该按钮只可放大或缩小程序构建区代码的大小），拖动缩放界面可放大除消息提示区外所有区域的大小。
支持板卡¶
从语言上来说，Mixly目前支持Arduino、MicroPython、Python三种语言。 当我们开始使用Mixly编写程序时，需要先在Mixly软件右下角选择正确的板卡
Arduino板卡¶
该类别下采用Arduino编程，支持板卡如下：
- Arduino/Genuino Uno
- Arduino Nano
- Arduino/Genuino Mega or Mega 2560
- Arduino Leonardo
- Generic ESP8266 Module
- NodeMCU 1.0 (ESP-12E Module)
- LOLIN(WEMOS) D1 R2 & mini
- WeMos D1 R1
- ESP32 Dev Module
- Arduino MixGo
- Arduino HandBit
- Arduino MixePi
MicroPython板卡¶
该类别下采用MicroPython编程，支持板卡如下。
- MicroPython[ESP32_Generic]
- MicroPython[ESP32_HandBit]
- MicroPython[ESP32_MixGo]
- MicroPython[NRF51822_microbit]
范例¶
创客教育的核心不是知识的重复复制或复杂功能的底层实现，而是激发学生的创新并享受分享所带来的快乐。基于Mixly的创意电子课程也要遵循这样的理念。遂从Mixly的技术特点出发，将Mixly的应用模式分为以下几类：
模仿延展类¶
该模式主要用于Mixly初学者学习创意电子的基础知识，其具体步骤如下：
- 由教师创设情境，并提出本次课（活动）的具体任务；
- 启发学生思考，得出实现本任务的基本思路并鼓励学生尝试实现；
- 教师给出参考实例，学生基于教师的代码模仿完成；
- 教师给出扩展任务方向，引导学生修改原有的代码实现。
下面以《两只老虎》为例描述这一过程。本课的目标是让学生学会使用蜂鸣器播放简单的音乐。首先，教师需要讲解基本乐理知识及Mixly中声音的播放方法，然后引导学生思考并鼓励学生尝试实现。在实际教学中，学生最初的实现过于浅显，与目标任务相差甚远。在给出合适的鼓励后再给出如图4-1所示的实现方式（使用四个数组分别用来表示基本音阶、音乐的音高、变调和时长），并引导学生进行模仿。模仿成功后，教师需要讲解实现的基本原理并给出延伸任务，让学生设计更复杂的音乐。事实上，学生只需简单地修改数组就可以播放出不同的音乐。
创意整合类¶
该模式主要用于具有一定Mixly基础的学生针对某一技术的创意整合应用，其具体步骤如下：
- 由教师创设情境，并提出一个特定的功能需求；
- 启发学生思考，得出实现功能的基本思路；
- 教师给出功能的具体实现模块，学生导入并体验；
- 激发学生创新，结合本模块和先前知识给出创意应用。
下面以《语音温度计》为例描述这一过程。本课的目标是实现低成本的人机交互。首先，教师抛出问题：如何才能让用户知道Arduino中的结果数据?学生一般会给出各种各样的答案，教师在给出合理的正向反馈后分析各种答案的可行性，并引导学生提出通过蜂鸣器播报数据的方案。在此基础上，给出相应的扩展库让学生尝试使用（一般不建议让学生理解该库的实现原理，只需会用即可）。然后，教师需要激发学生思考如何利用该库完成创新应用。图4-2给出了一个语音温度计的Mixly实现（LM35和A0相连，蜂鸣器和10号管脚相连），图4-3则是语音播报库的具体实现。
协同合作类¶
该模式主要用于Mixly专业学习者协同完成综合性任务，其具体步骤如下： * 学生以小组为单位，通过协商得出要做的综合任务目标； * 教师在听取学生的汇报后，给出项目的可行性评估及实现建议； * 学生在教师的帮助下完成基于模块的任务分工并实现最初的设计； * 小组汇总程序、进行调试，并完成最终成果的展示。
下面以在中学讲授《创意电子》课程的一个小组综合项目为例，描述这一过程。本课的目标是使学生综合运用元件和所学知识开发出一个创意作品。此前，教师应讲解在复杂的程序设计中代码模块化的意义，并给出一些具体的例子。在此基础上，学生自愿结为两人小组，提出创意。此处仅以其中一组学生设计并实现的温控报警散热器为例，描述后续过程。小组成员提出，使用温度传感器、蜂鸣器、LED灯、数码管等元件制作一个具有显示温度和报警功能的散热器。学生描述功能并进一步对其进行分解，除了使用到教师提供的一位共阳数码管库外，还构建了呈现彩色灯（colorRGB）、电扇开关控制（fan）、声光报警（ring）、获取温度（getTem）四个函数。 开发过程灵活使用了Mixly的导入/导出库功能：一位同学负责物理连接和四个子函数的编写并使用“导出库”功能将其导出成库文件，另一位同学负责基于功能描述设计整体逻辑并在导入该文件后完成主函数的编写。图4-4、图4-5分别是该作品的库文件代码和主程序代码，图4-6是该作品的实物图。
自定义公司库¶
Mixly方便各大硬件厂商技术人员编写自己公司产品的库以供用户使用。编写库的人员只需具备最基础的程序设计知识，了解公司库编写的规则，即可完成公司库的编写。 ### 一个完整的公司库的目录 下面是一个名为xxx的公司库的完整目录： .. image:: images/26/26-1.png
该目录下不是所有的文件都是必须的，视公司库的具体情况而定。 下面就对每一个目录进行说明。
block和generator¶
block和generator文件夹下分别有一个JS文件，一般是同名的，比如xxx.js。block/xxx.js文件定义了你定制的图形化模块的样子。 generator/xxx.js文件定义了每一个图形化模块对应的Arduino代码。比如下图就是“延时”的图形化模块的样子及其对应的Arduino代码：
block和generator目录通常是必不可少的，因此保证block/xxx.js和generator/xxx.js的正确性是成功定制公司库的关键。 比如“延时”模块的两部分JS代码分别如下：
对于这两个JS文件如何书写，在软件的blockly/blocks和blockly/generators/arduino目录下有大量的例子，基本包含了全部类型的图形化模块的定制方法。如果您想更深入的了解这些代码，您可以访问Google的blockly源码进行更加深入的研究。
hardware目录¶
hardware目录不是必需的目录，通常在公司使用了自己的Arduino板子（即官方的Arduino IDE没有我们所需要的板子）时，才需要hardware目录，该目录包含了一些跟硬件相关的信息，比如板子信息，管脚信息等等。因此，需要比较专业的技术人员进行定制此目录。最后是一个以公司名（比如xxx）命名的文件夹形式存在，直接拷贝至hardware目录下即可。
xxx目录¶
xxx目录是自己的Arduino库，xxx一般以公司名命名，里面包含一些.cpp和.h文件，这个目录也不是必需的，一般在生成的代码中有#include <xxx.h>时需要。
companypin目录¶
companypin目录定义了公司所需板子的管脚对应关系，该目录也是非必需的，通常在公司使用了全新的Arduino板子时才需要。 下面以lubot的新板子Lubot MK为例：
我们想为这块板子定义新的管脚对应关系，先在companypin目录下建立子文件夹lubot（通常以公司名命名），再建立pin.js文件，打开pin.js文件，管脚定义如下图所示（包括数字管脚、模拟管脚、PWM管脚、中断管脚以及Serial选择和默认波特率）：
language目录¶
![]如果想让公司库支持多国语言，就需要language目录，这个也是非必需的。 先在language目录下建立子文件夹xxx（通常以公司名命名），再在xxx文件夹下建立多国语言文件。如下图所示：分别是英语、西班牙语、简体中文、繁体中文。在这些多国语言的js文件中定义了一些JS常量。
下面讲解如何定义这些JS文件，还是以“延时”模块为例，下面分别是英语、西班牙语、简体中文、繁体中文对应的样子：
再来看如何在语言文件中定义对应的文字。
最后在block/xxx.js文件中引用即可： .. image:: images/26/26-16.png
media目录¶
media目录下是一些媒体文件，主要是图片，这个目录是非必需的。只有当模块需要使用图片时才需要该文件夹。比如下面这个模块里面就嵌入了一张图片： .. image:: images/26/26-17.png
所有的媒体文件放在media/xxx下即可，xxx是子文件夹，通常以公司名命名 xxx.xml文件 ————— xxx.xml文件是一个非常重要的文件，它是必不可少，通常以公司名命名。在这个文件中定义了所有需要呈现的模块，以及整个库中相关文件的路径（即前面提过的这些文件目录）。 下面是一个空例子，可以基于这个例子进行修改。
把写好的库导入Mixly¶
当我们把整个库写好之后，就可以把写好的库导入到Mixly中去了。打开Mixly软件（版本要求0.964及以上）。点击“导入库” 找到xxx.xml文件。 .. image:: images/26/26-19.png
点击打开就完成整个公司库的导入（前提是公司库必须正确）。
第三方库开发¶
Mixly特设了第三方拓展功能。方便各大硬件厂商技术人员编写自己公司产品的库以供用户使用。截止Mixly0.97版本，现第三方扩展有：DFROBOT、SEEEDSTUDIO、MAKEBLOCK、MBOT机器人、SENSE盒子、SENSE机器人、LuBot、Micoduino、Nova。
FAQ¶
下面是用户常见的一些问题及解决方案。
- 同一个库在0.995上可以使用，但在0.996上使用不了
Note
解决方法：这是由于blockly核心升级导致的，新版的blockly不再向前兼容。
可采用如下两种方法：
- 方法1：采用1.0以上版本。
- 方法2：将旧版库里block/XX.js中全局替换appendTitle为appendField，将generator/XX.js中全局替换getTitleValue为getFieldValue
- arduino系列板子，点击上传后出现`avrdude: stk500v2_ReceiveMessage(): timeout`
Note
解决方法：按下列可能方法依次检查。
- 方法1： 板子下拉框中选的板子型号和实际计算机连接的板子型号不对；
- 方法2： 串口下拉框选择不对，可通过设备管理器查看板子对应的是哪个串口；
- 方法3： 板子与电脑接口松动。可尝试拔了板子，再重新插上；
- 方法4： 数据线坏了，可尝试换数据线；
- 方法5： 板子损坏，可尝试换新板子；
- Mixly 支持在哪些操作系统编程？
Note
- 目前Mixly软件支持在WIN7/10,MacOS上运行。
- 早期版本 Mixly0.995支持在Windows XP上运行。
- Mixly软件不支持在安卓手机、安卓平板、苹果手机、苹果平板等移动设备上运行。
- Mixly软件也不支持在树莓派上运行。
- Mixly 支持给哪些硬件进行编程？
Note
参考 支持板卡 章节。
- Mixly 支持使用哪些语言进行编程？
Note
- Mixly本身采用图形化编程，但实际是将图形化程序转化为代码后再上传到开发板。
- 因此，从代码上来说，Mixly支持Arduino C语言, microPython 语言编程以及Pyhton。
Arduino AVR 编程¶
Arduino AVR编程¶
输入/输出¶
输入/输出所包含的指令主要分为四部分：控制管脚的输入输出（按信号类型可分为数字信号和模拟信号）、中断、脉冲长度及ShiftOut。
- 输入输出：数字输入、数字输出、模拟输入、模拟输出
- 中断控制：定义中断，取消中断
- 脉冲长度
- 移位输出
数字输出¶
1 2 | digitalWrite(0,HIGH);//输出高电平
digitalWrite(0,LOW);//输出低电平
|
描述¶
给一个数字引脚写入HIGH或者LOW。
参数¶
- 管脚: 引脚编号（如1,5,10，A0，A3）
- 值: 高 或 低
范例¶
将13号端口设置为高电平，延迟一秒，然后设置为低电平，再延迟一秒，如此往复。
1 2 3 4 5 6 7 8 9 | void setup(){
pinMode(13, OUTPUT);
}
void loop(){
digitalWrite(13,HIGH);
delay(1000);
digitalWrite(13,LOW);
delay(1000);
}
|
Attention
数字13号引脚难以作为数字输入使用，因为大部分的控制板上使用了一颗LED与一个电阻连接到他。如果启动了内部的20K上拉电阻，他的电压将在1.7V左右，而不是正常的5V，因为板载LED串联的电阻把他使他降了下来，这意味着他返回的值总是LOW。如果必须使用数字13号引脚的输入模式，需要使用外部上拉下拉电阻。
Attention
模拟引脚也可以当做数字引脚使用，使用方法是管脚设置为A0，A1，A2等。
数字输入¶
1 | digitalRead(0);
|
描述¶
读取指定引脚的值，HIGH或LOW。
参数¶
- 管脚: 引脚编号（如1,5,10,A0,A3）
返回¶
HIGH 或 LOW
范例¶
读取数字0号引脚的值，并通过串口打印出来。
1 2 3 4 5 6 7 | void setup(){
Serial.begin(9600);
pinMode(0, INPUT);
}
void loop(){
Serial.println(digitalRead(0));
}
|
Attention
如果引脚悬空，digitalRead()会返回HIGH或LOW（随机变化）。
模拟输入¶
1 | analogRead(A0);
|
描述¶
从指定的模拟引脚读取数据值。
Arduino板包含一个6通道（Mini和Nano有8个通道，Mega有16个通道），10位模拟数字转换器。这意味着它将0至5伏特之间的输入电压映射到0至1023之间的整数值。
参数¶
- 管脚: 引脚编号（如A0,A1,A2,A3）不同的开发板模拟输入引脚数量不一样。
返回¶
从0到1023的整数值
范例¶
读取模拟A0引脚的值，并通过串口打印出来。
1 2 3 4 5 6 | void setup(){
Serial.begin(9600);
}
void loop(){
Serial.println(analogRead(A0));
}
|
Attention
如果模拟输入引脚没有连入电路，由analogRead()返回的值将根据多项因素（例如其他模拟输入引脚，你的手靠近板子等）产生波动。
模拟输出¶
1 | analogWrite(3,100);
|
描述¶
从一个引脚输出模拟值（PWM）。 可用于让LED以不同的亮度点亮或驱动电机以不同的速度旋转。
参数¶
- 管脚:引脚编号（如3,5,6,9,10,11）不同的开发板模拟输入引脚数量不一样。
- 赋值:0（完全关闭）到255（完全打开）之间。
范例¶
控制LED实现呼吸灯效果。
1 2 3 4 5 6 7 8 9 10 11 12 | void setup(){
}
void loop(){
for (int i = 0; i <= 255; i = i + (1)) {
analogWrite(10,i);
delay(10);
}
for (int i = 255; i >= 0; i = i + (-1)) {
analogWrite(10,i);
delay(10);
}
}
|
Attention
analogWrite函数与模拟引脚、analogRead函数没有直接关系。 在大多数Arduino板（ATmega168或ATmega328），只有引脚3，5，6，9，10和11可以实现该功能。 在Arduino Mega上，引脚2到13可以实现该功能。
中断指令¶
1 2 3 4 5 6 7 8 | void attachInterrupt_fun_2() {
}
void setup(){
pinMode(2, INPUT);
}
void loop(){
attachInterrupt(digitalPinToInterrupt(2),attachInterrupt_fun_2,RISING);
}
|
描述¶
当发生外部中断时，调用一个指定函数。当中断发生时，该函数会取代正在执行的程序。
大多数的Arduino板有两个外部中断：0（数字引脚2）和1（数字引脚3）。
Arduino Mege有四个外部中断：数字2（引脚21），3（20针），4（引脚19），5（引脚18）。
ESP8266 、ESP32系列有更多中断。
参数¶
管脚: 引脚编号（如2,3）不同的开发板中断引脚不一样。
模式：
改变：当引脚电平发生改变时，触发中断
上升：当引脚由低电平变为高电平时，触发中断
下降：当引脚由高电平变为低电平时，触发中断
范例¶
利用2号引脚中断，控制13号引脚的LED亮灭。
1 2 3 4 5 6 7 8 9 10 11 12 13 | volatile boolean state;
void attachInterrupt_fun_2() {
state = !state;
digitalWrite(13,state);
}
void setup(){
state = false;
pinMode(2, INPUT);
pinMode(13, OUTPUT);
attachInterrupt(digitalPinToInterrupt(2),attachInterrupt_fun_2,RISING);
}
void loop(){
}
|
Attention
当中断函数发生时，delay()和millis()的数值将不会继续变化。当中断发生时，串口收到的数据可能会丢失。你应该声明一个变量来在未发生中断时储存变量。
脉冲长度¶
1 2 | pulseIn(0, HIGH);
pulseIn(0, HIGH, 1000000);
|
描述¶
读取一个引脚的脉冲（HIGH或LOW）。
例如，如果value是HIGH，pulseIn()会等待引脚变为HIGH，开始计时，再等待引脚变为LOW并停止计时。返回脉冲的长度，单位微秒。如果在指定的时间内无脉冲，函数返回。 此函数的计时功能由经验决定，长时间的脉冲计时可能会出错。计时范围从10微秒至3分钟。（1秒=1000毫秒=1000000微秒）
参数¶
- 管脚:你要进行脉冲计时的引脚号（int）。
- 状态:要读取的脉冲类型，HIGH或LOW（int）。
- 超时 (可选）:指定脉冲计数的等待时间，单位为微秒，默认值是1秒（unsigned long）。
返回¶
脉冲长度（微秒），如果等待超时返回0（unsigned long）
范例¶
读取6号引脚脉冲时长。
1 2 3 4 5 6 7 | void setup(){
Serial.begin(9600);
pinMode(6, INPUT);
}
void loop(){
Serial.println(pulseIn(6, HIGH));
}
|
管脚模式¶
1 | pinMode(0, INPUT);
|
描述¶
设置指定管脚的模式。
参数¶
- 管脚: 引脚编号（如2,3）不同的开发板中断引脚不一样。
- 模式: 要将管脚设置成的模式，包括输入、输出、上拉输入。
ShiftOut¶
1 2 | shiftOut(0,0,MSBFIRST,0);//高位先入
shiftOut(0,0,LSBFIRST,0);//低位先入
|
描述¶
将一个数据的一个字节一位一位的移出。从最高有效位（最左边）或最低有效位（最右边）开始。依次向数据脚写入每一位，之后时钟脚被拉高或拉低，指示刚才的数据有效。
参数¶
- 数据管脚：输出每一位数据的引脚(int)
- 时钟管脚：时钟脚，当数据管脚有值时此引脚电平变化(int)
- 顺序：输出位的顺序，最高位优先或最低位优先
- 数值: 要移位输出的数据(byte)
管脚中断¶
1 | PCintPort::attachInterrupt(0,attachPinInterrupt_fun_0,RISING);
|
描述¶
当发生外部中断时，调用一个指定函数。当中断发生时，该函数会取代正在执行的程序。
本模块为模拟中断，支持所有管脚使用。
参数¶
管脚: 引脚编号（如2,3）不同的开发板中断引脚不一样。
- 模式：
改变：当引脚电平发生改变时，触发中断
上升：当引脚由低电平变为高电平时，触发中断
下降：当引脚由高电平变为低电平时，触发中断
范例¶
利用中断，控制13号引脚的LED亮灭。
Attention
当中断函数发生时，delay()和millis()的数值将不会继续变化。当中断发生时，串口收到的数据可能会丢失。你应该声明一个变量来在未发生中断时储存变量。
多功能按键¶
1 2 3 4 5 6 7 8 9 | OneButton button0(0,true);
void attachClick0() {
}
void setup(){
button0.attachClick(attachClick0);
}
void loop(){
button0.tick();
}
|
描述¶
设置特定管脚连接的按钮为多功能按钮，并确定不同模式下执行不同的程序。
参数¶
- 多功能按键: 引脚编号（如1,5,10，A0，A3）
- 模式: 单击 双击 长按开始 长按中 长按结束
范例¶
将2号端口连接的按钮设置为多功能按钮，单击时串口提示“one Click”
1 2 3 4 5 6 7 8 9 10 11 | OneButton button2(2,true);
void attachClick2() {
Serial.println("one Click");
}
void setup(){
button2.attachClick(attachClick2);
Serial.begin(9600);
}
void loop(){
button2.tick();
}
|
控制¶
控制类别中包括了时间延迟、条件执行、循环执行、获取运行时间、初始化、Switch执行等 控制模块中主要执行的内容是对程序结构进行的相应控制。
1.初始化¶
1 2 | pinMode(3, OUTPUT);
digitalWrite(3,HIGH);
|
1.1 描述¶
在Arduino中程序运行时将首先调用 setup()函数。 用于初始化变量、设置针脚的输出输入类型、配置串口、引入类库文件等等。
1.3 范例2¶
在初始化时定义中断函数。
1 2 3 4 5 6 7 8 9 10 | void attachInterrupt_fun_2() {
digitalWrite(13,HIGH);
}
void setup(){
pinMode(2, INPUT);
pinMode(13, OUTPUT);
attachInterrupt(digitalPinToInterrupt(2),attachInterrupt_fun_2,RISING);
}
void loop(){
}
|
Attention
每次 Arduino 上电或重启后，setup 函数只运行一次。
2.while 循环¶
2.1 描述¶
while循环会无限的循环，直到括号内的判断语句变为假。 必须要有能改变判断语句的东西，要不然while循环将永远不会结束。你可以使用一个传感器的值，或者一个变量来控制什么时候停止该循环。
2.2 参数¶
- 满足条件：为真或为假的一个条件。
2.3 范例¶
当温度高于30度时，亮灯，否则灭灯。
1 2 3 4 5 6 7 8 9 | void setup(){
pinMode(13, OUTPUT);
}
void loop(){
while (analogRead(A0)*0.488 > 30) {
digitalWrite(13,HIGH);
}
digitalWrite(13,LOW);
}
|
3.延时¶
1 | delay(1000);
|
3.1 描述¶
使程序暂定设定的时间（单位毫秒）。（一秒等于1000毫秒）。
3.2 参数¶
- 毫秒：暂停的毫秒数。
3.3 范例¶
13号引脚灯亮1秒，灭1秒，往复循环。
1 2 3 4 5 6 7 8 9 | void setup(){
pinMode(13, OUTPUT);
}
void loop(){
digitalWrite(13,HIGH);
delay(1000);
digitalWrite(13,LOW);
delay(1000);
}
|
Attention
虽然创建一个使用delay()的闪烁LED很简单，并且许多例子将很短的delay用于消除开关抖动。
但delay()确实拥有很多显著的缺点。在delay函数使用的过程中，读取传感器值、计算、引脚操作均无法执行，因此，它所带来的后果就是使其他大多数活动暂停。大多数熟练的程序员通常避免超过10毫秒的delay(),除非arduino程序非常简单。
利用定时器，就可以解决这个问题，可以避免由于delay()带来的CPU暂停，也能很好地实现每隔一定时间执行动作。
4.如果(if)¶
1 2 | if (false) {
}
|
4.1 描述¶
if 语句与比较运算符一起用于检测某个条件是否达成，如某个传感器的值是否等于某个值。
4.2 参数¶
- 条件：比较表达式
4.4 范例1¶
当连接在2号引脚的按键按下时，点亮13号引脚的灯。
1 2 3 4 5 6 7 8 9 | void setup(){
pinMode(2, INPUT);
pinMode(13, OUTPUT);
}
void loop(){
if (digitalRead(2) == 1) {
digitalWrite(13,HIGH);
}
}
|
如果判断的条件大于等于1时，可以省略等于判断，因为只要 该表达式的结果不为0，则为真。
所以，上面的写法与下面的写法等效。
1 2 3 4 5 6 7 8 9 | void setup(){
pinMode(2, INPUT);
pinMode(13, OUTPUT);
}
void loop(){
if (digitalRead(2)) {
digitalWrite(13,HIGH);
}
}
|
4.5 范例2¶
当连接在2号引脚的按键按下时，点亮13号引脚的灯;当按键松开时，灯灭。
1 2 3 4 5 6 7 8 9 10 11 | void setup(){
pinMode(2, INPUT);
pinMode(13, OUTPUT);
}
void loop(){
if (digitalRead(2)) {
digitalWrite(13,HIGH);
} else {
digitalWrite(13,LOW);
}
}
|
Attention
另外一种进行多种条件分支判断的语句是switch case语句。
5.如果(switch)¶
1 2 | switch (NULL) {
}
|
5.1 描述¶
和if语句相同，switch…case通过设定的在不同条件下执行的代码控制程序的流程。
特别地，switch语句将变量值和case语句中设定的值进行比较。当一个case语句中的设定值与变量值相同时，这条case语句将被执行。
关键字break可用于退出switch语句，通常每条case语句都以break结尾。如果没有break语句，switch语句将会一直执行接下来的语句（一直向下）直到遇见一个break，或者直到switch语句结尾。
5.2 参数¶
- var: 用于与下面的case中的标签进行比较的变量值
- label: 与变量进行比较的值
5.4 范例¶
当连接在2号引脚的按键按下时，点亮13号引脚的灯，否则13号引脚的灯灭
1 2 3 4 5 6 7 8 9 10 11 | void setup(){
pinMode(2, INPUT);
pinMode(13, OUTPUT);
}
void loop(){
switch (true) {
case digitalRead(2):
digitalWrite(13,HIGH);
break;
}
}
|
Attention
每个switch可以有多个case，但是最多不超过一个default，当不满足任何一个case时，执行default中的程序。
6.for循环¶
1 2 | for (int i = 1; i <= 10; i = i + (1)) {
}
|
6.1 描述¶
for循环用于重复执行一段的程序。通常使用一个增量计数器计数并终止循环。
for循环用于重复性的操作非常有效，通常与数组结合起来使用来操作数据、引脚。
6.2 参数¶
- 变量名：用于记录for循环次数的变量名。
- 起始值：循环的计数起始值，一般从0开头，也可以从其他数值开始。
- 终点值：循环的计数终点值。
- 步长：每次循环的步长，一般为1，也可以是其他整数。
6.4 范例¶
将连接在3号引脚的灯制作成呼吸灯，每一次亮度变化之间间隔50毫秒
1 2 3 4 5 6 7 8 9 10 11 12 | void setup(){
}
void loop(){
for (int i = 0; i <= 255; i = i + (1)) {
analogWrite(3,i);
delay(50);
}
for (int i = 255; i >= 0; i = i + (-1)) {
analogWrite(3,i);
delay(50);
}
}
|
Attention
for循环中定义的变量有名字，可以用字母i,j,k或单词red,state等有意义的词语表示。
7.跳出循环¶
1 | break;
|
7.1 描述¶
跳出循环用于终止一段重复的程序，一般使用时作为条件语句的执行部分，当循环中的变量满足某个条件时，执行跳出循环语句。
跳出循环在处理循环中的特殊情况时十分有用。
7.2 参数¶
- 操作：可以选择跳出循环和跳到下一个循环两种操作，结果不同。
7.3 范例¶
引脚3上的数字从0到255逐一增加，每一次增加之间间隔50毫秒，当数字增加到150时停止增加
1 2 3 4 5 6 7 8 9 10 11 12 | void setup(){
pinMode(3, INPUT);
}
void loop(){
for (int i = 0; i <= 255; i = i + (1)) {
if (digitalRead(3) == 150) {
break;
}
analogWrite(3,i);
delay(50);
}
}
|
Attention
注意跳到下一个循环的使用，可以方便的将循环中不需要的步骤跳过。
8.系统运行时间¶
1 2 | millis();
micros();
|
8.1 描述¶
返回自硬件启动或重启以来的时间值。
8.2 返回¶
自硬件启动或重启以来的时间，毫秒数或者微秒数。
8.3 范例¶
自动换行打印系统运行时间
1 2 3 4 5 6 7 8 9 | void setup(){
Serial.begin(9600);
pinMode(2, INPUT);
}
void loop(){
if (digitalRead(2)) {
Serial.println(millis());
}
}
|
9.MsTimer2 定时器¶
1 | MsTimer2::set(500, msTimer2_func);
|
9.1 描述¶
每隔设置的毫秒数执行相应的程序
9.2 范例¶
利用定时器控制13号引脚LED每隔1秒亮灭一次。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | #include <MsTimer2.h>
volatile boolean state;
void msTimer2_func() {
state = !state;
digitalWrite(13,state);
}
void setup(){
state = false;
pinMode(13, OUTPUT);
MsTimer2::set(1000, msTimer2_func);
MsTimer2::start();
}
void loop(){
}
|
Attention
利用定时器可以提高硬件的工作效率。
但在一个程序中只能使用一个MsTimer2定时器，如果要实现多个时间的定时，可以配合变量计数来完成。
12.简单定时器¶
1 2 3 4 5 6 7 8 9 | SimpleTimer timer;
void Simple_timer_1() {
}
void setup(){
timer.setInterval(1000L, Simple_timer_1);
}
void loop(){
timer.run();
}
|
12.1 描述¶
设置不同的简单定时器，每隔指定秒数执行相应的程序常用于多任务处理。
12.2 范例¶
D12,D13分别连接LED灯，每隔200ms，D12引脚LED灯切换亮灭； 每隔300ms,D13引脚LED灯切换亮灭；
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | SimpleTimer timer;
void Simple_timer_1() {
digitalWrite(12,(!digitalRead(12)));
}
void Simple_timer_2() {
digitalWrite(13,(!digitalRead(13)));
}
void setup(){
pinMode(12, OUTPUT);
timer.setInterval(200L, Simple_timer_1);
pinMode(13, OUTPUT);
timer.setInterval(300L, Simple_timer_2);
}
void loop(){
timer.run();
}
|
13.允许中断¶
1 | interrupts();
|
13.1 描述¶
允许输入/输出模块中管脚中断的运行
13.2 范例¶
使用按钮模拟开关，每次按下，LED灯切换亮灭
1 2 3 4 5 6 7 8 9 10 11 | void attachInterrupt_fun_2() {
digitalWrite(10,(!digitalRead(10)));
}
void setup(){
pinMode(2, INPUT);
pinMode(10, OUTPUT);
interrupts();
attachInterrupt(digitalPinToInterrupt(2),attachInterrupt_fun_2,RISING);
}
void loop(){
}
|
14.禁止中断¶
1 | noInterrupts();
|
14.1 描述¶
禁止输入/输出模块中管脚中断的运行
14.2 范例¶
在允许中断范例的基础上，尝试禁止中断
1 2 3 4 5 6 7 8 9 10 11 | void attachInterrupt_fun_2() {
digitalWrite(10,(!digitalRead(10)));
}
void setup(){
pinMode(2, INPUT);
pinMode(10, OUTPUT);
noInterrupts();
attachInterrupt(digitalPinToInterrupt(2),attachInterrupt_fun_2,RISING);
}
void loop(){
}
|
15.SCoop Task¶
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | defineTask(scoopTask1)
void scoopTask1::setup()
{
}
void scoopTask1::loop()
{
}
void setup(){
mySCoop.start();
}
void loop(){
yield();
sleep(1000);
}
|
15.1 描述¶
SCoop模块用于执行多线程任务，最多支持8个任务。
15.2 范例¶
利用SCoop，控制13号引脚LED灯以2秒的频率闪烁，同时控制12号引脚的LED灯以200毫秒的频率闪烁。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 | #include "SCoop.h"
defineTask(scoopTask1)
void scoopTask1::setup()
{
pinMode(13, OUTPUT);
}
void scoopTask1::loop()
{
digitalWrite(13,HIGH);
sleep(1000);
digitalWrite(13,LOW);
sleep(1000);
}
defineTask(scoopTask2)
void scoopTask2::setup()
{
pinMode(12, OUTPUT);
}
void scoopTask2::loop()
{
digitalWrite(12,HIGH);
sleep(100);
digitalWrite(12,LOW);
sleep(100);
}
void setup(){
pinMode(13, OUTPUT);
mySCoop.start();
pinMode(12, OUTPUT);
}
void loop(){
yield();
}
|
数学¶
该部分主要完成数学变换功能，具体包括数字映射、数字约束、数学运算、取整、随机、三角函数。
1.数字常量¶
1 | 0;
|
1.1 描述¶
数字常量包括 整数常量和浮点常量。
Attention
整数常量是直接在程序中使用的数字，如123。默认情况下，这些数字被视为int类型。通常情况下，整数常量默认为十进制，但可以加上特殊前缀表示为其他进制。如：B0111，表示二进制；0173,表示八进制；0x7B，表示十六进制。
浮点常量也可以直接中程序中使用，如12.3。默认情况下，这些数字被视为float类型。也可以使用科学计数法表示浮点数。如：2.34E5代表2.34 * 10^5，其实际值为234000；67E-12代表67.0 * 10^-12，其实际值为0.000000000067。
数学运算¶
描述¶
数学运算中包括加、减、乘、除、取模、幂运算。 这些运算将会返回两个操作数的和,差,乘积,商，取模、幂。
2.2 参数¶
常量或变量
2.3 返回值¶
两个操作数的和,差,乘积,商,取模,幂。
Attention
- 这些运算是根据操作数的数据类型来计算的,比如 9和4都是int类型,所以9/4结果是2。
- 如果想要两个整数相除得到小数，就需要将整数转换成小数。如9.0/2.0=4.5 。
- 这也就代表如果运算结果比数据类型所能容纳的范围要大的话，就会出现溢出。例如. 1加上一个整数 int类型 32,767 结果变成-32,768。
- 如果操作数是不同类型的,结果是“更大”的那种数据类型。如果操作数中的其中一个是 float类型或者double类型, 就变成了浮点数运算。
3.位运算¶
1 | (0&0);
|
3.1 描述¶
按位操作符对变量进行位级别的计算。
3.3 按位或(|)¶
按位或操作符是|。
和&操作符类似,|操作符对两个变量的为一位都进行运算,只是运算规则不同。
3.3.1 描述¶
只要两个位有一个为1则结果为1，否则为0。 如：0011|0101=0111
3.3.2 范例¶
在Arduino中，int类型为16位，所以在两个int表达式之间使用&会进行16个并行按位或计算。
1 2 3 4 5 6 7 8 9 10 11 12 13 | volatile int a;
volatile int b;
volatile int c;
void setup(){
a = 92;
b = 101;
c = (a|b);
}
void loop(){
}
|
3.4 按位异或(^)¶
按位异或是一个不常见的操作符，也叫做XOR（通常读作”eks-or“）。
按位异或操作符用 ^ 表示。
3.4.1 描述¶
按位异或是如果两个位值相同则结果为0，否则为1。 如：0011^0101=0110
3.5 左移位运算(<<)¶
左移位运算可使左运算元中的某些位移动右运算元中指定的位数。
3.5.1 范例¶
1 2 3 4 5 6 7 8 | volatile int a;
volatile int b;
void setup(){
a = 5;
b = (a<<3);
}
void loop(){
}
|
1 2 3 4 5 6 7 8 | volatile int a;
volatile int b;
void setup(){
a = 5;
b = (a<<14);
}
void loop(){
}
|
如果你确定位移不会引起数据溢出，你可以简单的把左移运算当做对左运算元进行2的右运算元次方的操作。
3.6 右移位运算(>>)¶
右移位运算与左移位运算类似。
4.三角函数及其他¶
4.2 cos函数¶
计算一个角度的余弦值（用弧度表示）。返回值在 -1 和 1 之间。
4.2.1 参数¶
弧度制的角度（float）
4.2.2 返回值¶
角度的正弦值（double）
4.2.3 范例¶
绘制SIN-COS的函数图像,程序上传后，打开串口监视器,并切换到绘图模式
1 2 3 4 5 6 7 8 9 10 11 | void setup(){
Serial.begin(9600);
}
void loop(){
for (int i = 0; i <= 360; i = i + (1)) {
Serial.print((sin(i / 180.0 * 3.14159) * 256 + 512));
Serial.print(",");
Serial.println((cos(i / 180.0 * 3.14159) * 256 + 512));
delay(200);
}
}
|
5.数学运算2¶
5.1 取整（四舍五入）(round)¶
返回给定值的四舍五入取整值。如round(4.1)=4;round(5.6)=6。
5.1.1 参数¶
数值或变量。
5.1.2 返回值¶
给定值的四舍五入取整值
5.2 取整（取上限）(ceil)¶
返回给定值的下一个整数，如果输入的本身就是整数，则返回自身。如ceil(4.1)=5;ceil(5.6)=6,ceil(7)=7。
5.2.1 参数¶
数值或变量。
5.2.2 返回值¶
给定值的下一个整数或自身。
8.随机数(random)¶
描述¶
使用随机数模块可以产生一个给定范围之间的随机数。
参数¶
min - 随机数的最小值，随机数将包含此值。 （此参数可选）
max - 随机数的最大值，随机数不包含此值。
返回¶
min和max-1之间的随机数（ 数据类型为long ）
范例¶
随机数不包括最大数，如 1—7 随机数只有 1、2、3、4、5、6。
1 2 3 4 5 6 7 8 | void setup(){
Serial.begin(9600);
randomSeed(997);
}
void loop(){
Serial.println((random(1, 100)));
delay(100);
}
|
9.约束(constrain)¶
描述¶
约束是将数值限制在最小值与最大值之间，所有小于最小值的数值被赋值为最小值，同理，所有大于最大值的数被赋值为最大值。
参数¶
x：要被约束的数字，所有的数据类型适用。
a：该范围的最小值，所有的数据类型适用。
b：该范围的最大值，所有的数据类型适用。
返回值¶
x：如果 x是介于 a 和 b之间
a：如果 x小于a
b：如果 x大于b
范例¶
A0连接电位器，将看到LED亮灭随电位器的旋转约束在0-255之间不同的亮度
1 2 3 4 5 | void setup(){
}
void loop(){
analogWrite(11,(constrain(((long) (analogRead(A0)) % (long) (3)) * 50, 0, 255)));
}
|
10.映射(map)¶
描述¶
约束是将数值限制在最小值与最大值之间，所有小于最小值的数值被赋值为最小值，同理，所有大于最大值的数被赋值为最大值。
参数¶
x：要被约束的数字，所有的数据类型适用。
a：该范围的最小值，所有的数据类型适用。
b：该范围的最大值，所有的数据类型适用。
返回值¶
x：如果 x是介于 a 和 b之间
a：如果 x小于a
b：如果 x大于b
范例¶
A0接电位器,串口输出20-180区间的数值
1 2 3 4 5 6 7 | void setup(){
Serial.begin(9600);
}
void loop(){
Serial.println((map(analogRead(A0), 0, 1023, 20, 180)));
delay(500);
}
|
逻辑¶
逻辑模块中的指令大多是逻辑运算处理内容，具体可分为：条件判断、逻辑运算、？运算。
比较运算符¶
1 | 0 == 0;
|
描述¶
Note
比较运算符适用于比较两个值的运算符号，用比较运算符比较两个值时，结果是一个逻辑值，不是TRUE就是FALSE。
等于(=)¶
等于用在变量之间、变量和自变量之间以及其他类型的信息之间的比较，判断符号两侧的数据值是否相等，要求两侧数据类型相同时才能比较。
规则是：如果两个数据值相等，数据类型相同，则结果为TRUE，否则输出FALSE。
范例¶
1=1，返回True；1=“1”，不成立
1 2 3 4 5 6 7 8 9 10 | void setup(){
Serial.begin(9600);
if (1 == 1) {
Serial.print("True");
}
}
void loop(){
0 == "1";
1;
}
|
小于(＜)¶
小于符号进行有顺序的比较，如果符号左边的数据值小于右边的数据值，则返回TRUE，否则返回FALSE。
小于等于(≤)¶
小于等于符号与小于符号类似，多出一种返回TRUE的情况，如果符号左边的数据值小于等于右边的数据值，则返回TRUE，否则返回FALSE。
大于(>)¶
大于符号进行有顺序的比较，如果符号左边的数据值大于右边的数据值，则返回TRUE，否则返回FALSE。
大于等于(≥)¶
大于等于符号与大于符号类似，多出一种返回TRUE的情况，如果符号左边的数据值大于等于右边的数据值，则返回TRUE，否则返回FALSE。
范例¶
在A0连接电位器，D9连接LED。转动电位器，大于600灯一直亮，在400和600之间，灯灭，小于400灯闪。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | void setup(){
Serial.begin(9600);
pinMode(9, OUTPUT);
}
void loop(){
Serial.println(analogRead(A0));
delay(1000);
if (analogRead(A0) >= 600) {
digitalWrite(9,HIGH);
} else if (analogRead(A0) <= 400) {
digitalWrite(9,HIGH);
delay(200);
digitalWrite(9,LOW);
delay(200);
} else {
digitalWrite(9,LOW);
}
}
|
逻辑运算符¶
1 | false && false;
|
描述¶
Note
逻辑运算符用于判定变量或值之间的逻辑。
且¶
且的含义同逻辑运算符与，只有当符号两边的表达式均为真时，才被判断为真，否则为假。
或¶
或也是逻辑运算符的一种，只有当两边的表达式均为假时，才被判断为假，否则为真。
范例¶
光控按钮灯:A0连接光线传感器，D4连接LED，D3连接按钮,当A0<50光线暗）并按钮被被下时，LED为高电平;否则，LED为低电电平
1 2 3 4 5 6 7 8 9 10 11 | void setup(){
pinMode(3, INPUT);
pinMode(4, OUTPUT);
}
void loop(){
if (analogRead(A0) < 50 && digitalRead(3)) {
digitalWrite(4,HIGH);
} else {
digitalWrite(4,LOW);
}
}
|
文本¶
文本的具体内容为代码的文本输出功能，具体包括：文本连接、文本转数字、数字转文本。
所有文本内容可通过串口监视器或外接显示屏打印。
字符¶
1 | 'a';
|
描述¶
字符常量。
参数¶
- 字符: 需要输入的字符。
范例¶
只执行一次串口输出积木块。
1 2 3 4 5 6 | void setup(){
Serial.begin(9600);
}
void loop(){
Serial.println(analogRead(A0));
}
|
Attention
只能输入一个字符，输入超过一个字符时会自动选择第一个字符进行输入，空格也可以作为字符输入。
获取字符串中的一部分¶
1 | String("substring").substring(0,3);
|
描述¶
获取字符串第x到y的字符串。
范例¶
截取字符串中的一部分。
1 2 3 4 5 6 7 | void setup(){
Serial.begin(9600);
}
void loop(){
Serial.println(String("I Love Mixly").substring(7,12));
while(true);
}
|
转化大小写¶
1 | String.toUpperCase();
|
描述¶
将指定的字符串变量的小写字母全部转化为大写字母或将大写字母全部转化为小写字母.
参数¶
- 第一个字符串:需要转化的字符串变量。
- 转化方向：确定是将小写字母转化为大写字母还是将大写字母转化为小写字母。
范例¶
将字符串变量里的小写字母全部转化为大写字母。
1 2 3 4 5 6 7 8 9 10 11 | String wenzi;
void setup(){
Serial.begin(9600);
wenzi = " ";
}
void loop(){
wenzi = " I like Mixly! ";
Serial.println(wenzi);
wenzi.toUpperCase();
while(true);
}
|
字符串变量替换¶
1 | String.replace("s", "Q");
|
描述¶
将指定的字符或字符串替换为指定的字符或字符串.
参数¶
- 第一个字符串:原有的字符串。
- 第二个字符串:需要进行替换的字符或字符串。
- 第三个字符串:用来进行替换的字符或字符串。
范例¶
将字符串变量a中的“l”全部替换为“a”。
1 2 3 4 5 6 7 8 9 10 | String a;
void setup(){
a = "hello";
Serial.begin(9600);
}
void loop(){
a.replace("l", "a");
Serial.println(a);
while(true);
}
|
消除非可视字符¶
1 | String.trim();
|
描述¶
截取字符串中间的非空白字符.
参数¶
- 字符串变量
范例¶
消除非可视字符将删除字符串首尾的非可视字符。
1 2 3 4 5 6 7 8 9 10 11 12 | String wenzi;
void setup(){
Serial.begin(9600);
wenzi = " ";
}
void loop(){
wenzi = " I like Mixly! ";
Serial.println(wenzi);
wenzi.trim();
Serial.println(wenzi);
while(true);
}
|
判断字符串的开头或结尾¶
1 | String("substring").startWith("substring");
|
描述¶
判断第一个字符串是否以第二个字符串为开头或结尾，若是则返回1，否则返回0.
参数¶
- 第一个字符串:需要进行判断的字符串。
- 第二个字符串:用来进行判断的字符串。
范例¶
substring以sub开头而不以ub开头。
1 2 3 4 5 6 7 8 | void setup(){
Serial.begin(9600);
}
void loop(){
Serial.println(String("substring").startsWith("sub"));
Serial.println(String("substring").startsWith("ub"));
while(true);
}
|
转ASCII字符(char())¶
1 | char(223);
|
描述¶
将数字转成ASCII字符。
参数¶
- 数字: ASCII字符对应的数字。
返回¶
数字所对应的ASCII字符。
范例¶
用转ASCII字符积木块加空格。
1 2 3 4 5 6 | void setup(){
Serial.begin(9600);
}
void loop(){
Serial.println(analogRead(A0));
}
|
获取字符串长度(String().length())¶
1 | String("hello").length();
|
描述¶
通过String().length()方法获得字符串的长度，值为组成字符串的字母数。
参数¶
- 字符串: 需要获取长度的字符串。
返回¶
字符串的字符个数，一个中文算三个字符。
数组¶
数组是为了便于代码编写时所采用的一种数字块。具体包括：定义数组、取数组值、改数组值。
数组像一个大盒子，可以储存一定个数的数字（第一个指令）或字符串（第二个指令）。在课程中的音乐盒一课，我们就用到了数组。
如上图，tonelist, musiclist, highlist, rhythmlist分别储存了歌曲《两只老虎》的基本频率（即哆来咪等七音的对应频率），频率变化（即两只老虎的简谱数字），每个音的音名CDEFGAB以及每个音的时值（长短）。 《两只老虎》共有三十二个音，因此使用了一个从1到32的循环语句以此读取第一个音的频率变化（简谱，并通过.. image:: images/06Lists/array3.png语句可读取简谱的基本频率），随后与获取highlist里的对应音高并按thythmlist里的时值进行相应延时。 该代码将《两只老虎》的指令放到了一个名为playmusic的函数内，并通过执行 playmusic调用该函数。关于函数的内容，我们将在下面函数部分具体详解。
创建mylist数组1¶
1 | int mylist[]={0, 0, 0};
|
描述¶
初始化一个数组。
参数¶
- 数组类型: 选择创建的数组类型，包括整数、长整数、小数、字符、字节、char、字符串。
- 数组名称：为创建的数组输入一个名字。
创建mylist数组2¶
1 | int mylist[3]={0,0,0};
|
描述¶
初始化一个数组。
参数¶
- 数组类型: 选择创建的数组类型，包括整数、长整数、小数、字符、字节、char、字符串。
- 数组名称：为创建的数组输入一个名字。
- 数组长度：指定数组的长度。
获取数组mylist长度¶
1 | sizeof(mylist)/sizeof(mylist[0]);
|
描述¶
获取数组的长度。
参数¶
- 数组名称: 需要获取长度的数组名称。
范例¶
获取CHINA数组的长度。
1 2 3 4 5 6 7 8 | int CHINA[]={'C', 'H', 'I', 'N', 'A'};
void setup(){
Serial.begin(9600);
}
void loop(){
Serial.println(sizeof(CHINA)/sizeof(CHINA[0]));
while(true);
}
|
获取数组mylist第N项¶
1 | mylist[(int)(N - 1)];
|
描述¶
获取指定数组的第N项。
参数¶
- 数组名称: 需要获取内容的数组名称。
- 变量N: 需要获取数组的第N项。
范例¶
串口输出字符型数组元素。
1 2 3 4 5 6 7 8 9 10 | char CHINA[]={'C', 'H', 'I', 'N', 'A'};
void setup(){
Serial.begin(9600);
}
void loop(){
for (int i = (1); i <= (sizeof(CHINA)/sizeof(CHINA[0])); i = i + (1)) {
Serial.print(CHINA[(int)(i - 1)]);
}
while(true);
}
|
数组mylist第N项赋值¶
1 | mylist[(int)(N - 1)] = 0;
|
描述¶
为指定数组的第N项赋予特定的值。
参数¶
- 数组名称: 需要获取内容的数组名称。
- 变量N: 需要赋值数组的第N项。
- 赋值内容: 需要替换的内容。
范例¶
串口输出字符型数组元素。
1 2 3 4 5 6 7 8 9 10 11 | char CHINA[]={'C', 'H', 'I', 'N', 'A'};
volatile int N;
void setup(){
N = 2;
Serial.begin(9600);
}
void loop(){
CHINA[(int)(N - 1)] = 'C';
Serial.print(CHINA[(int)(N - 1)]);
while(true);
}
|
创建二维数组array¶
1 | int array[2][2]={{0,0},{0,0}};
|
描述¶
初始化一个二维数组。
参数¶
- 数组类型: 选择创建的数组类型，包括整数、长整数、小数、字符、字节、char、字符串。
- 数组名称：为创建的数组输入一个名字。
- 数组行数
- 数组列数
- 字符串：创建二维数组的来源。
获取数组array第M行第N列¶
1 | array[M-1][N-1];
|
描述¶
获取数组array第M行第N列的内容。
参数¶
- 数组名称：为创建的数组输入一个名字。
- 数组行数
- 数组列数
范例¶
串口输出二维数组元素。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | int array[3][3]={{1,2,3},{4,5,6},{7,8,9}};
void setup(){
Serial.begin(9600);
}
void loop(){
for (int i = 1; i <= 3; i = i + (1)) {
for (int j = 1; j <= 3; j = j + (1)) {
Serial.print(String(array[i-1][j-1]) + String(","));
if ((long) (j) % (long) (3) == 0) {
Serial.println("");
}
}
}
while(true);
}
|
变量¶
依据变量类型可分为：浮点变量、整型变量、布尔变量、字符串变量。根据变量的值又可分为高或低、真或假。
在运算中，变量是一个使用非常频繁的指令。比如在2.1.7.2使用红外接收管和遥控器的相关代码中，ir_item就是一个变量。 在使用变量时，如果用户在程序建构区内已新建了一个变量（例如使用循环语句i变量），变量模块将自动生成了一个相对应的系统变量i，用户直接使用即可。
函数¶
在函数部分，主要分为定义函数和执行函数，需注意，当用户自定义一个函数时，执行函数的代码是系统生成的。
比如让LED点亮这个代码，当我把它放到函数blink中后，系统会自动生成执行 blink代码。
另外需要注意，如果使用函数指令，必须运行执行 blink才可以。如果只自定义函数blink而不执行，LED是不会有任何反应的。
串口¶
传感器¶
传感模块：超声波、DHT11、DS18B20（新增）
在传感器部分，我们将一些最常见的传感器相关指令进行编库，比如超声波测距模块，学生在使用超声波进行测距时，可直接运用该模块，只需将Trig与Echo管脚填好即可，这大大节省了学生的编程时间，这将更有助于使学生将更多的精力集中在创意实践上而非抓耳挠腮地编程。
显示器¶
通信¶
通信是为了方便人与计算机交互而采用的一种特殊通信方式。具体包括：串口通信(新增串口选择和波特率设置)、红外通信、I2C通信、SPI通信（新增）。
串口通信¶
串口通信功能学生可在串口监视器中查看。这一功能对于学生检查自己代码以及监视传感器数据提供了便利条件。 假设学生将LM35的温度传感器接到模拟管脚A0口，学生可通过 .. image:: images/13Communicate/commu4.png 指令观察当前室温。随后可能会提出疑问：当前室温怎么可能是58？这将引发学生进一步的思考造成该数据的可能性。
I2C通信¶
I2C（Inter－Integrated Circuit）是同步通信的一种特殊形式，具有接口线少，控制方式简单，器件封装形式小，通信速率较高等优点。Mixly支持I2C的读取和写入，并且支持基于I2C协议的执行器。
SPI通信¶
SPI是串行外设接口（Serial Peripheral Interface）的缩写。SPI，是一种高速的，全双工，同步的通信总线，并且在芯片的管脚上只占用四根线，节约了芯片的管脚，同时为PCB的布局上节省空间，提供方便，拥有简单易用的特性。用户可以使用Mixly向SPI传输数据。
网络¶
Factory¶
Factory中的模块可以方便用户编写Mixly中不支持的传感器功能。 .. image:: images/16Factory/factory.png
将以RTC1307库为例，介绍利用factory中的模块，在Mixly快速使用Arduino标准库。
准备工作¶
1.从github.com等网站下载ds1307RTC Arduino库。 2.将库文件解压到Mixly/arduino-1.x.x/portable/sketchbook/libraries目录中。 3.打开Mixly自带的arduino IDE（路径Mixlyarduino-1.x.xarduino.exe），在软件中打开 库目录下的example范例，编译并上传，测试能否正常使用。如果不能正常使用，则需要更换库或者检查硬件问题。
重写程序¶
打开范例程序Mixly/arduino-1.x.x/portable/sketchbook/libraries/DS1307RTC/examples/ReadTime/ReadTest/ReadTest.ino，先分析程序，并适当简化程序。
源程序如下：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 | #include <Wire.h>
#include "TimeLib.h"
#include "DS1307RTC.h"
void setup() {
Serial.begin(9600);
while (!Serial) ; // wait for serial
delay(200);
Serial.println("DS1307RTC Read Test");
Serial.println("-------------------");
}
void loop() {
tmElements_t tm;
if (RTC.read(tm)) {
Serial.print("Ok, Time = ");
print2digits(tm.Hour);
Serial.write(':');
print2digits(tm.Minute);
Serial.write(':');
print2digits(tm.Second);
Serial.print(", Date (D/M/Y) = ");
Serial.print(tm.Day);
Serial.write('/');
Serial.print(tm.Month);
Serial.write('/');
Serial.print(tmYearToCalendar(tm.Year));
Serial.println();
} else {
if (RTC.chipPresent()) {
Serial.println("The DS1307 is stopped. Please run the SetTime");
Serial.println("example to initialize the time and begin running.");
Serial.println();
} else {
Serial.println("DS1307 read error! Please check the circuitry.");
Serial.println();
}
delay(9000);
}
delay(1000);
}
void print2digits(int number) {
if (number >= 0 && number < 10) {
Serial.write('0');
}
Serial.print(number);
}
|
简化程序如下：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 | #include <Wire.h>
#include "TimeLib.h"
#include "DS1307RTC.h"
void setup() {
Serial.begin(9600);
}
void loop() {
tmElements_t tm;
if (RTC.read(tm)) {
Serial.print(tm.Hour);
Serial.print(':');
Serial.print(tm.Minute);
Serial.print(':');
Serial.print(tm.Second);
Serial.print(tm.Day);
Serial.print('/');
Serial.print(tm.Month);
Serial.print('/');
Serial.print(tmYearToCalendar(tm.Year));
}
delay(1000);
}
|
Factory模式下模块：
编写完成后，编译并上传，进行测试。测试利用factroy编写的程序效果是否与arduino IDE编写相同。
工具¶
Arduino ESP8266编程¶
MicroPython 编程¶
MicroPython 编程¶
输入/输出¶
输入/输出所包含的指令主要分为四部分：初始化管脚、控制管脚的输入输出、获取输入值、中断管脚。
管脚的输入输出按信号类型可分为数字信号和模拟信号，在MicroPython中，模拟输出有PWM（脉冲宽度调制）和DAC（数模转换器）两种输出方式。
获取输入值可获取数字输入、模拟输入和触摸传感器的值。
- 初始化：数字输出
- 输入输出：数字输入、数字输出、模拟输入、PWM模拟输出、DAC模拟输出
- 中断控制：定义中断
- 【待完善】
控制¶
数学¶
该部分主要完成数学运算相关的功能，具体包括数字、常数、三角函数、各种数学、位和逻辑计算、取整、取最大值、随机数、进制转换、约束和映射模块。
1.数字常量¶
1.1描述¶
数字常量包括：整数常量和浮点常量。
Attention
整数常量是直接在程序中使用的数字，如123。默认情况下，这些数字被视为int类型。通常情况下，整数常量默认为十进制，但可以加上特殊前缀表示为其他进制。如：0b111，表示二进制；0o73,表示八进制；0x7B，表示十六进制。
浮点常量也可以直接中程序中使用，如12.3。默认情况下，这些数字被视为float类型。也可以使用科学计数法表示浮点数。如：2.34E5代表2.34 * 10^5，其实际值为234000；67E-12代表67.0 * 10^-12，其实际值为0.000000000067。
3.三角函数及其他¶
5.对数函数与幂函数¶
6.算术运算¶
6.1 描述¶
算术运算中包括加(+)、减(-)、乘(×)、除(÷)、取模(%)、取整除(//)和幂运算(**)。这些运算将会返回两个操作数的和，差，积，商，模、商的整数部分和幂值。
Attention
- 这些运算是根据操作数的数据类型来计算的,比如 9和4都是int类型,所以9/4结果是2。
- 如果想要两个整数相除得到小数，就需要将整数转换成小数。如9.0/2.0=4.5 。
- 这也就代表如果运算结果比数据类型所能容纳的范围要大的话，就会出现溢出。例如： 1加上一个整数 int类型 32,767 结果变成-32,768。
- 如果操作数是不同类型的,结果是“更大”的那种数据类型。如果操作数中的其中一个是 float类型或者double类型, 就变成了浮点数运算。
- 取整除运算将会返回商的整数部分，向下取整。
6.2 参数¶
常量或变量
6.3 返回值¶
两个操作数的和，差，积，商，模、商的整数部分和幂值。
7.位运算¶
Note
按位运算符是把数字看作二进制来进行计算。
7.1 按位与(&)¶
7.1.1 描述¶
按位与操作符为一个&符，用在两个整型变量之间。按位与运算符对两侧的变量的每一位都进行运算。
规则是：如果两个运算元都是1，则结果为1，否则输出0。
Hint
如： 0011&0101=0001
7.2 按位或(|)¶
7.2.1 描述¶
按位或操作符是|。
和&操作符类似,|操作符对两个变量的为一位都进行运算,只是运算规则不同。
按位或规则：只要两个位有一个为1则结果为1，否则为0。
Hint
如：0011|0101=0111
7.3 右移位运算(>>)¶
8.赋值运算¶
8.1 描述¶
赋值运算中包括赋值加(+=)、赋值减(-=)、赋值乘(×=)、赋值除(÷=)、赋值取模(%=)、赋值取整除(//=)和赋值幂运算(**=)。
赋值运算符的左边为变量，右边为操作数。赋值运算符将左边的变量本身和右边的操作数分别作为算术运算的操作数，返回两个操作数的和，差，积，商，模、商的整数部分和幂值，并将返回值赋值给左边的变量。
Attention
- 这些运算是根据操作数的数据类型来计算的,比如 9和4都是int类型,所以9/4结果是2。
- 如果想要两个整数相除得到小数，就需要将整数转换成小数。如9.0/2.0=4.5 。
- 这也就代表如果运算结果比数据类型所能容纳的范围要大的话，就会出现溢出。例如： 1加上一个整数 int类型 32,767 结果变成-32,768。
- 如果操作数是不同类型的,结果是“更大”的那种数据类型。如果操作数中的其中一个是 float类型或者double类型, 就变成了浮点数运算。
- 取整除运算将会返回商的整数部分，向下取整。
8.2 参数¶
赋值运算符左边的参数为变量，右边的参数可以为常亮或者变量。
9.近似运算¶
15.约束(constrain)¶
15.1 描述¶
约束是将数值限制在最小值与最大值之间，所有小于最小值的数值被赋值为最小值，同理，所有大于最大值的数被赋值为最大值。
15.2 参数¶
参数一：要被约束的数字，所有的数据类型适用。
参数二：该范围的最小值，所有的数据类型适用。
参数三：该范围的最大值，所有的数据类型适用。
15.3 返回值¶
如果参数一介于参数二和参数三之间，返回参数一；
如果参数一大于参数三，返回参数三；
如果参数一小于参数二，返回参数二；
16.映射(map)¶
Hint
映射指两个元素的集之间元素相互“对应”的关系。
就像把一张地图幻灯片（尺寸255）投影到大屏幕上（尺寸1023）一样，虽然两者尺寸大小不同，但不改变地图内部的比例和相对位置。
两者之间数据形成一一对应的关系。
16.1 描述¶
映射运算将参数值在前一个元素集中的位置按照两个元素集的映射方式，得出在后一个元素集中对应位置的值。
16.2 参数¶
参数一：需要求映射的值；
参数二和参数三：映射的起始元素集范围；
参数四和参数五：映射的终点元素范围。
16.3 返回值¶
返回参数一从起始元素集映射到终点元素集的值。
1 2 3 4 | def mixly_mapping(v, al, ah, bl, bh):
return bl + (bh - bl) * (v - al) / (ah - al) //Mixly中的映射函数
mixly_mapping(50, 0, 100, 0, 1000) //调用映射函数，返回值为500.0
|
Hint
参考上述代码举例，可以了解到：起始集合为[0,100]，终点集合为[0,1000]，两个集合的右边界减去左边界，再用终点集合的边界差除以起始集合的边界差，得到10，即起始集合到终点集合的映射为放大10倍。
参数一50在起始集合中的位置位于左边界加50，则在终点集合中的位置应当位于左边界加500，而经过乘除运算后数据类型变为float，所以上述举例中的返回值为500.0。
请再结合以下举例理解映射运算。
1 2 3 4 5 6 7 | mixly_mapping(65, 50, 100, 50, 1000) //调用映射函数，返回值为335.0
mixly_mapping(35, 50, 100, 50, 1000) //调用映射函数，返回值为-235.0
mixly_mapping(50, 0, 1000, 0, 100) //调用映射函数，返回值为5.0
mixly_mapping(60, 50, 80, 56, 74) //调用映射函数，返回值为62.0
|
逻辑¶
Note
逻辑模块中的指令大多是逻辑运算处理内容，具体可分为：比较运算、范围判断、逻辑运算、代表非、真、假、空的块、？运算、列表存在判断和列表相等判断。
1.比较运算符¶
Note
在Python中，比较运算符是用于比较两个对象的运算符号，结果是一个Boolean逻辑值，为True或者False。
1.1 等于(=)¶
1.1.1 描述¶
等于符号用两个对象之间的比较，判断符号两侧的对象的数据值和数据类型是否相等。
1.1.2 规则¶
如果两个数据值相等，且数据类型相同，则结果为True，否则结果为False。
Attention
Python中的对象有三个属性：
1.id:身份标识，是对象在内存中的地址，python中用函数id(x)返回对象 x 在内存中的地址
2.type:数据类型，python中用函数type(x)返回对象 x 的数据类型
3.value:值
Python中，比较运算符除”==”外还有”is”，他们的区别是：
“==” 是对两个对象的 value 和 type 进行比较，比较两个对象的值和数据类型是否相等
“is” 是对两个对象的 id 进行比较 ，比较两个对象的内存地址是否相等
Mixly中比较运算符模块中的”=”，使用的是Python中的”==”，可以从代码中查看：
1.1.3 示例¶
返回结果：
True False False
1.2 不等于(≠)¶
1.2.1 描述¶
不等于符号使用方法与等于符号相同，返回与等于符号相反的结果。
1.2.2 规则¶
符号两边的对象值和数据类型相等时，结果False，否则结果为True。
1.2.3 示例¶
返回结果：
False True True
3.逻辑运算符¶
4.否定运算符¶
4.1 描述¶
否定运算符（非）(not)用于对象或表达式前面，结果与原对象或表达式逻辑值相反。即原逻辑值为True，则结果为False；若原逻辑值为False，则结果为True。
4.2 示例¶
返回结果：
True True False
5.逻辑值¶
5.1 描述¶
MicroPython中的逻辑值包含真(True)，假(False)。逻辑值可以直接参与逻辑运算，得出的运算结果也是逻辑值。
5.2 示例¶
返回结果：
False True False
6.空值(None)¶
6.1 描述¶
- None是一个特殊的常量。
- None和False不同。
- None不是0。
- None不是空字符串。
- None和任何其他的数据类型比较永远返回False。
6.2 示例¶
返回结果：
True False False False False False
7. ？：模块¶
7.1 描述¶
对于条件表达式模块 a ? x : y，先计算条件 a 的逻辑结果，然后进行判断。 如果 a 的值为True，则计算表达式 x 的值，模块的值即为 x 的值； 否则，计算表达式 y 的值，模块的值即为 y 的值。
7.2 参数¶
- a: 判断条件，先计算判断条件的值
- x: 当判断条件的值为True，模块的值即为x的值
- y: 当判断条件的值为False，模块的值即为y的值
Hint
- 一个条件表达式不会既计算 x ，又计算 y 。
- 条件运算符是右结合的，也就是说，从右向左分组计算。例如，a ? b : c ? d : e 将按 a ? b : (c ? d : e) 执行。
- 实际上，MicroPython中没有 ? : 语句，这实际上是通过 if 条件语句实现的。
7.3 示例¶
这一段代码可以在 a 和 b 中选择出较大数字。
返回结果：
5
8.元素存在判断¶
8.1 参数¶
元素：可以是各种常量和变量对象，包括数列。
数列：需要被判断是否存在某元素的数列；是多维数列时要求前一参数是对应维度的数列。
此模块的值为逻辑值，当参数元素存在于数列中时，此模块值为True；当参数元素不存在于数列中时，此模块值为False。
8.2 示例¶
返回结果：
True False
9.数列相等判断¶
9.1 描述¶
此模块的两个参数均为数列对象，模块的值为逻辑值，当前后两数列相等时，此模块值为True；当前后两数列不相等时，此模块值为False。
Attention
此模块使用的是”is”进行相等判断。还记得之前讲过的Python对象的三个属性和”==”与”is”判断的区别吗？
Python中的对象有三个属性：
1.id:身份标识，是对象在内存中的地址，python中用函数id(x)返回对象 x 在内存中的地址
2.type:数据类型，python中用函数type(x)返回对象 x 的数据类型
3.value:值
Python中，比较运算符除”==”外还有”is”，他们的区别是：
“==” 是对两个对象的 value 和 type 进行比较，比较两个对象的值和数据类型是否相等
“is” 是对两个对象的 id 进行比较 ，比较两个对象的内存地址是否相等
所以此模块判断的也是判断前后两个数列的内存地址是否相等，请结合一下示例进一步了解。
9.2 示例¶
返回结果：
False True
文本¶
Note
文本分类下的模块主要包含文本输出、文本处理和字符串内容检索等功能。具体包括：文本连接、文本转换、获取长度、格式化字符串等。
所有文本内容都可通过串口打印或外接显示屏输出。
1.字符串¶
1.1 描述¶
Mixly中包含单行文本和多行文本。 单行文本内容可以是一个字符、单词也可以是一行文本。 多行文本内容会保留输入的换行。
1.2 示例¶
Python中的单行文本由双引号或者单引号包围，多行文本由连续使用的三个单引号包围。
2.字符串连接¶
2.1 描述¶
字符串连接模块可以连接单行文本和多行文本，也可以嵌套使用。此模块在连接的文本之间不会添加任何分隔符号。
2.2 示例¶
你也可以在单行文本或者多行文本中使用转义字符 “\n” 来进行换行。
源代码：
输出结果：
HelloMixly Hello Mixly HelloMixlyLoveMixly HelloMixly 1.0 Hello WorldMixly Hello World Mixly
3.字符串转换¶
3.1 字符串转换为其他类型¶
3.1.2 示例¶
源代码：
输出结果：
123 1.23 b'123' b'1.23' b'Mixly'
3.2 数字转换为字符串¶
3.2.1 描述¶
此模块可以将数字转换为字符串。
3.2.2 示例¶
源代码：
输出结果：
123 1.23 100
4.获取字符串长度¶
4.1 描述¶
此模块可以返回一个字符串的长度或者列表、元组、集合的元素数量。对于字符串，一个英文字母、一个符号（比如空格）、一个汉字长度均为1。
4.2 返回值¶
此模块返回的长度为int类型的数据格式。
4.3 示例¶
源代码：
输出结果：
5 11 13 3 4 5
5.字符串判断¶
5.1 描述¶
此模块可以判断前后两个字符串是否相等，也可以判断某字符串是否以某字符或字符串开始或结尾。若相等或以指定字符串开始或结尾，则返回True，否则返回False。
Attention
- 此模块的判断都是严格区分大小写的。
- 可以判断某字符串是否以另一字符串开始或结尾。
5.2 示例¶
源代码：
输出结果：
True False False False True True
6.字符串截取¶
6.1 根据索引截取字符¶
6.1.1 描述¶
此模块可以在字符串中根据索引返回对应的字符。
Attention
- 点击了解 附录：字符串索引方向。
- 在字符串中截取字符，索引的范围为字符串长度的相反数到字符串的长度减1，如五个字符的字符串索引范围为[-5, 4]，超出此范围的索引会报错。
6.1.2 示例¶
源代码：
输出结果：
M x y M x y
6.2 根据索引范围截取字符串¶
6.2.1 描述¶
此模块可以在字符串中根据索引返回对应的字符串。
Attention
- 所截取出的字符串中，包含前一个索引对应的字符，但不包含后一个索引对应的字符。
- 点击了解 附录：字符串索引方向。
- 在字符串中截取字符串，索引的范围为字符串长度的相反数到字符串的长度（因为不包含后一索引对应的字符，所以不用减1），如五个字符的字符串索引范围为[-5, 5]，超出此范围的索引会报错。
6.2.2 示例¶
源代码：
输出结果：
北京师范大学 米思齐团
7.字符串编/解码¶
7.2 示例¶
源代码：
输出结果：
b'Mixly' Mixly b'\xe7\xb1\xb3\xe6\x80\x9d\xe9\xbd\x90' 米思齐 b'\xc3\xd7\xcb\xbc\xc6\xeb' 米思齐
8.字符串内容转换¶
8.1 描述¶
此模块可以对指定字符串进行指定类型的转换。转换类型包括将各单词首字母转换为大写，将句子首字母转换为大写，将字符串中所有字母的大小写对调，以及将所有字母转换为小写字母。
Attention
- 将各单词首字母转换为大写功能需要各个单词间有分隔符（空格，逗号均可），若没有分隔符则视为同一个单词。
- 将句子首字母转换为大写实际上是将整个字符串第一个字母转换为大写，后面的句子并不会转换。
8.2 示例¶
源代码：
输出结果：
Hello Mixly! Hello mixly! i love mixly! hELLO mIXLY! hello mixly!
9.字符串填充对齐¶
9.2 示例¶
源代码：
输出结果：
Hello,mixly*************************************** ******************I love mixly!******************* **************************************Happy mixly! Hello,mixly I love mixly! Happy mixly!
10.字符串搜索¶
10.1 描述¶
此模块可以检查字符串中是否包含指定字符或者字符串，如果包含则返回字符或字符串首字符的索引值，否则返回-1。
Attention
- 如果有多个检索结果，则返回第一个检索结果的索引。
- 字符串各个字符的索引从0开始，也就是说第一个字符的索引为0，第九个字符的索引为8，以此类推。
- 可以在字符串中检索字符和字符串。
- 检索时是严格匹配大小写的。
10.2 示例¶
源代码：
输出结果：
2 2 6 -1
11.序列连接成字符串¶
11.1 描述¶
此模块可以使用指定的连接字符或字符串将序列（列表、元组、集合等）的各个元素连接起来形成并返回一个字符串。
Attention
- 需要连接的序列（列表、元组、集合等）的每一个元素必须是字符串的数据类型。
- 集合（{}）是无序序列，所以每次对集合进行连接返回的字符串是随机的。
11.2 示例¶
源代码：
输出结果：
Beijing Normal University Mixly-Mixpy-MixGo MixGo--Mixly--Mixpy # 此项由于是连接集合，所以每一次输出的结果是随机的
12.字符串内容替换¶
12.2 示例¶
源代码：
输出结果：
Hello,mixpy Hello,mixly 北京师范大学Mixly团队 HeAAo,mixAy
13.字符串分割¶
13.2 示例¶
源代码：
输出结果：
['I', 'love', 'mixly!'] ['He', '', 'o mix', 'y!'] ['Hello mixly!'] ['北京师范大学', '齐团队']
14.字符串消除空格¶
14.1 描述¶
此模块可以消除字符串两侧或者单独删除左、右侧的空格，返回处理后的字符串。
14.2 示例¶
源代码：
输出结果：
I love mixly I love mixly I love mixly
15.字符串格式化¶
15.1 描述¶
此模块可以在字符串中格式化传递参数。需要传递参数的地方使用”{}”标记，你可以点击模块上的蓝色齿轮添加多个参数。
Attention
- 传递的参数可以是各种数据类型。
- 后面参数排列的顺序对应”{}”标记的顺序。
15.2 示例¶
源代码：
输出结果：
Random No. is 62 我在重庆，我爱Mixly！
16.字符串表达式执行¶
16.2 示例¶
源代码：
输出结果：
2 4 3 False 15 True
附录：字符串索引方向¶
Attention
- 有正反两种索引方式。
- 正向索引中，字符串各个字符的索引从0开始，也就是说第一个字符的索引为0，第九个字符的索引为8，以此类推。
- 反向索引中，字符串各个字符的索引从字符串长度的相反数开始，也就是说，对于一个长度为5的字符串，第一个（倒数第五个）字符的索引为-5，倒数第一个（最后一个）字符的索引为-1，倒数第二个字符的索引为-2，以此类推。
- 阅读完毕后，在浏览器中后退可回到之前的浏览位置。
Note
序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字——它的位置，也称为索引：第一个索引是0，第二个索引是1，依此类推。
Python有多种内置的序列类型，但最常见的是列表、元组、字典和集合。
序列都可以进行的操作包括索引，切片，加，乘，检查成员等。
此外，Python已经内置确定序列的长度以及确定最大和最小的元素等方法。
列表¶
Note
列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。
列表的数据项不需要具有相同的数据类型。
Mixly中有很多用于列表操作的模块，如下：
1.列表初始化¶
1.1 描述¶
Mixly中有两种初始化列表的方式：
- 第一种，你需要输入列表名称，将代表各种数据的模块连接到初始化模块上，你也可以点击蓝色齿轮增加元素数量。
- 第二种，你也需要输入列表名称，然后直接在方括号中输入各种数据，各个元素使用英文逗号分隔即可。
在使用列表初始化模块后，你可以在”变量”模块分类中根据你输入的列表名称找到代表此列表的模块。
Attention
- 列表的各个元素类型不要求相同，可以是数字、布尔值和字符串，也可以是另一个列表。
- 列表中的字符串元素都是由引号包围的，若其他数据类型使用引号包围也将会被视为字符串类型。
1.2 示例¶
源代码：
输出结果：
['Mixly', 1.0, True, [1, 2, 3, 4, 5]]
2.列表元素获取¶
2.1根据索引获取元素¶
2.1.1 描述¶
此模块可以在列表中根据索引返回对应的元素。
Attention
- 字符串其实也是一种序列，所以列表获取元素和字符串截取字符是同理的。
- 点击查看 附录1：序列索引方向。
- 在列表中获取单个元素，索引的范围为列表元素数量的相反数到列表元素数量减1，如五个元素的列表索引范围为[-5, 4]，超出此范围的索引会报错。
2.1.2 示例¶
源代码：
输出结果：
Mixly MixGo
2.2 根据索引范围获取多个元素¶
2.2.1 描述¶
此模块可以在列表中根据索引返回对应的多个元素组成的子列表。
Attention
- 所截取出的子列表中，包含前一个索引对应的元素，但不包含后一个索引对应的元素。
- 点击查看 附录1：序列索引方向。
- 在列表中获取多个元素，索引的范围为列表元素数量的相反数到列表元素数量（因为不包含后一索引对应的元素，所以不用减1），如五个元素的列表索引范围为[-5, 5]，超出此范围的索引会报错。
2.2.2 示例¶
源代码：
输出结果：
['Mixly', 'Mixpy'] ['MixGo', 'Mixly Group']
3.获取列表信息¶
3.1 描述¶
此模块可以返回一个列表的长度（元素数量）。 还可以返回数字列表的总和、最大值、最小值、平均数、中位数、众数和标准差。
Attention
- 此模块返回的长度为int类型的数据格式。
- 此模块只能返回数字列表的总和、最大值、最小值、平均数、中位数、众数和标准差，若列表中包含其他数据类型的元素，则会报错。
- 此模块返回的平均数和标准差因为经过除法运算，所以返回的是float类型的数据格式。
- 当给定的数字列表中有多个众数时，将会返回由这多个众数组成的列表。
- 由于Mixly中此模块使用的math包中不包含计算平均数、中位数、众数和标准差的方法，所以会定义计算这几种数据的方法并调用。
3.2 示例¶
源代码：
输出结果：
4 5 25 9 1 5.0 5 [1, 3, 5, 7, 9] 2.8284271247461903
4.列表元素查询¶
4.1 描述¶
此模块可以在给定的列表中查询某个值，选择”位置”将返回第一个匹配元素的索引，选择”个数”将返回匹配元素的数量。
Attention
- 查询的值可以是任意的数据类型
- 在查询匹配元素的索引时，若列表中无匹配元素，则会报错。
- 在查询匹配元素的数量时，若列表中无匹配元素，则会返回0。
4.2 示例¶
源代码：
输出结果：
4 3 3
5.列表元素赋值¶
5.2 示例¶
源代码：
输出结果：
[1, 2, 'Mixly', 4, 5]
6.列表插入元素¶
6.1 描述¶
此模块可以在给定的列表中给定的索引位置插入元素。
Attention
- 此模块没有返回值。
- 插入元素之后的所有元素将会依次往后移动一个位置。
- 若插入时给定的索引超出了原列表的长度，则会默认添加到列表的末尾。
- 给定的索引可以为负值，规则参考 附录1：序列索引方向。
6.2 示例¶
源代码：
输出结果：
[1, '目的索引为1', 2, 3, '目的索引为-3', 4, 5, '目的索引为10']
7.列表添加元素¶
7.1 描述¶
此模块可以在给定的列表后添加一个或者一组元素。
“增加”会将添加的对象视为一个元素，”扩展增加”会将添加的对象视为一个序列，将序列的元素分别添加到给定列表的末尾。
Attention
- 此模块没有返回值。
- 增加使用的是append()方法，会将参数视为一个元素添加到末尾。
- 扩展增加使用的是extend()方法，参数必须是序列（包括列表、元组、集合、字符串等）对象，如果是非序列对象，则会报错。
7.2 示例¶
源代码：
输出结果：
[1, 2, 3, 4, 5, 'Mixly'] # 在序列后增加"Mixly" [1, 2, 3, 4, 5, 'M', 'i', 'x', 'l', 'y'] # 在序列后扩展增加"Mixly" [1, 2, 3, 4, 5, [1, 2, 3, 4, 5]] # 在序列后增加[1, 2, 3, 4, 5] [1, 2, 3, 4, 5, 1, 2, 3, 4, 5] # 在序列后扩展增加[1, 2, 3, 4, 5]
8.列表删除元素¶
8.1 描述¶
此模块可以在给定的列表中删除给定索引位置或者给定值的元素。
Attention
- 此模块没有返回值。
- 根据给定的值删除元素只会删除列表中匹配的第一个元素。
- 给定索引位置超出列表长度以及给定值在列表中无匹配元素都会触发报错。
- 给定的索引可以为负值，规则参考 附录1：序列索引方向。
8.2 示例¶
源代码：
输出结果：
[1, 2, 4, 5] [1, 2, 4, 5] [1, 2, 2, 5]
9.列表删除并获取元素¶
9.2 示例¶
源代码：
输出结果：
4 [1, 2, 3, 5]
10.列表元素排序¶
10.1 描述¶
此模块可以将给定的列表按照数字或首字母进行升序或者降序排列，并返回排好序的列表。
Attention
- Mixly中定义了新的方法来对列表进行排序。
- 此模块并不会改变原序列元素的顺序。
- 此模块可以将各种数字类型的元素混合排列。
- 此模块按照首字母区分大小写排列会分别对大写和小写进行给定顺序排列，且小写总在大写后，即升序排列小写在大写后，降序排列小写在大写前。
- 此模块还可以对同时含有数字和字符串的列表进行排序。若按照数字排序，则只会对列表内的数字排序，字符串会按照原来的顺序，在所有数字后；若按照字母排序，则同时会对数字和字符串进行排序，对字符串的排序规则与上一条相同，且所有字符串在所有数字后。
- 此模块还可以对多维列表进行排序，由于很少使用，感兴趣的读者可以自行探究，也可以直接探究Mixly中排序方法的定义。
10.2 示例¶
源代码：
输出结果：
[6.1, 4.3, 3, 2.5, 1.2] # 按照数字降序排列 [1.2, 2.5, 3, 4.3, 6.1] # 原列表 ['Aplle', 'Cat', 'Dog', 'apple', 'fox'] # 按照首字母升序排列，区分大小写 ['fox', 'apple', 'Dog', 'Cat', 'Aplle'] # 按照首字母降序排列，区分大小写 ['fox', 'Dog', 'Cat', 'apple', 'Aplle'] # 按照首字母降序排列，忽略大小写 ['Aplle', 'apple', 'Cat', 'Dog', 'fox'] # 原列表 [5.2, 4.3, 3, 2.5, 1.2, 'book', 'Door', 'cat'] # 按照数字降序排列 [1.2, 2.5, 3, 4.3, 5.2, 'Door', 'book', 'cat'] # 按照首字母升序排列，区分大小写 [1.2, 2.5, 3, 4.3, 5.2, 'book', 'cat', 'Door'] # 按照首字母升序排列，忽略大小写 ['book', 2.5, 1.2, 3, 5.2, 'Door', 4.3, 'cat'] # 原列表
11.列表逆序¶
11.2 示例¶
源代码：
输出结果：
[5, 4, 3, 2, 1] ['Mixly Group', 'MixGo', 'Mixpy', 'Mixly']
12.列表清空¶
12.2 示例¶
源代码：
输出结果：
[]
13.列表转换¶
13.1 描述¶
此模块可以将给定列表转换为元组或集合并返回。
13.2 示例¶
源代码：
输出结果：
('Mixly', 'Mixpy', 'MixGo', 'Mixly Group') {'Mixly Group', 'Mixpy', 'MixGo', 'Mixly'} # 因为集合是无序序列，所以每一次输出是随机的
14.列表迭代打包¶
14.1 描述¶
此模块可以将给定的迭代列表中的对应元素打包成一个个元组，然后返回由这一个个元组组成的对象。
Attention
- 如果各个迭代的列表元素数量不一致，则按照元素数量最少的列表进行打包。
- 此模块返回的是一个对象，需要将此对象转换为想要的序列格式。
- 若打包迭代的列表数量超过2个，则无法转换为字典，否则会报错。
14.2 示例¶
源代码：
输出结果：
<zip object at 0x10c45e580> # 返回的是一个zip对象 [(0, 0), (1, 1), (2, 2)]示例2：
源代码：
输出结果：
<zip object at 0x102e92400> # 返回的是一个zip对象 [(0, 0), (1, 1), (2, 2), (3, 3)] ((0, 0), (1, 1), (2, 2), (3, 3)) {0: 0, 1: 1, 2: 2, 3: 3} {(1, 1), (3, 3), (2, 2), (0, 0)} <zip object at 0x102e92400> # 返回的是一个zip对象 [('Name', 'Fred', 'Tom', 'Sam'), ('Age', '19', '18', '20'), ('Country', 'China', 'Australia', 'America')] (('Name', 'Fred', 'Tom', 'Sam'), ('Age', '19', '18', '20'), ('Country', 'China', 'Australia', 'America')) {('Country', 'China', 'Australia', 'America'), ('Age', '19', '18', '20'), ('Name', 'Fred', 'Tom', 'Sam')}
附录1：序列索引方向¶
Attention
- 有正反两种索引方式。
- 正向索引中，各个元素的索引从0开始，也就是说第一个元素的索引为0，第九个元素的索引为8，以此类推。
- 反向索引中，各个元素的索引从列表元素数量的相反数开始，也就是说，对于一个元素数量为5的列表，第一个（倒数第五个）元素的索引为-5，倒数第一个（最后一个）元素的索引为-1，倒数第二个元素的索引为-2，以此类推。
Note
序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字——它的位置，也称为索引：第一个索引是0，第二个索引是1，依此类推。
Python有多种内置的序列类型，但最常见的是列表、元组、字典和集合。
序列都可以进行的操作包括索引，切片，加，乘，检查成员等。
此外，Python已经内置确定序列的长度以及确定最大和最小的元素等方法。
元组¶
Note
Python的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号，列表使用方括号。
Mixly中有很多用于元组操作的模块，如下：
1.元组初始化¶
1.1 描述¶
Mixly中有两种初始化元组的方式：
- 第一种，你需要输入元组名称，将代表各种数据的模块连接到初始化模块上，你也可以点击蓝色齿轮增加元素数量。
- 第二种，你也需要输入元组名称，然后直接在小括号中输入各种数据，各个元素使用英文逗号分隔即可。
在使用元组初始化模块后，你可以在”变量”模块分类中根据你输入的元组名称找到代表此元组的模块。
Attention
- 元组的各个元素类型不要求相同，可以是数字、布尔值和字符串，也可以是另一个元组。
- 元组中的字符串元素都是由引号包围的，若其他数据类型使用引号包围也将会被视为字符串类型。
1.2 示例¶
源代码：
输出结果：
('Mixly', 1.0, True, [1, 2, 3, 4, 5], (1, 2, 3, 4, 5)) ('Mixly', 1.0, True, [1, 2, 3, 4, 5], (1, 2, 3, 4, 5))
2.元组元素获取¶
2.1 根据索引获取元素¶
2.1.1 描述¶
此模块可以在元组中根据索引返回对应的元素。
Attention
- 字符串其实也是一种序列，所以元组获取元素和字符串截取字符也是同理的。
- 点击查看 附录1：序列索引方向。
- 在元组中获取单个元素，索引的范围为元组元素数量的相反数到元组元素数量减1，如五个元素的元组索引范围为[-5, 4]，超出此范围的索引会报错。
2.1.2 示例¶
源代码：
输出结果：
Mixly MixGo
2.2 根据索引范围获取多个元素¶
2.2.1 描述¶
此模块可以在元组中根据索引返回对应的多个元素组成的子元组。
Attention
- 所截取出的子元组中，包含前一个索引对应的元素，但不包含后一个索引对应的元素。
- 点击查看 附录1：序列索引方向。
- 在元组中获取多个元素，索引的范围为元组元素数量的相反数到元组元素数量（因为不包含后一索引对应的元素，所以不用减1），如五个元素的元组索引范围为[-5, 5]，超出此范围的索引会报错。
2.2.2 示例¶
源代码：
输出结果：
('Mixly', 'Mixpy') ('MixGo', 'Mixly Group')
3.获取元组信息¶
3.1 描述¶
此模块可以返回一个元组的长度（元素数量）。 还可以返回数字元组的总和、最大值、最小值。
Attention
- 此模块返回的长度为int类型的数据格式。
- 此模块只能返回数字元组的总和、最大值、最小值，若元组中包含其他数据类型的元素，则会报错。
3.2 示例¶
源代码：
输出结果：
5 4 9 1 25
4.删除元组¶
4.2 示例¶
源代码：
输出结果：
('Mixly', 'Mixpy', 'MixGo', 'Mixly Group')
5.元组连接¶
5.2 示例¶
源代码：
输出结果：
(1, 3, 5, 7, 9, 'Mixly', 'Mixpy', 'MixGo', 'Mixly Group', 1, 3, 5, 7, 9) (1, 3, 5, 7, 9) ('Mixly', 'Mixpy', 'MixGo', 'Mixly Group')
6.元组转换¶
6.1 描述¶
此模块可以将给定元组转换为列表或集合并返回。
6.2 示例¶
源代码：
输出结果：
['Mixly', 'Mixpy', 'MixGo', 'Mixly Group'] {'Mixpy', 'MixGo', 'Mixly Group', 'Mixly'} # 因为集合是无序序列，所以每一次输出是随机的 ('Mixly', 'Mixpy', 'MixGo', 'Mixly Group')
附录1：序列索引方向¶
Attention
- 有正反两种索引方式。
- 正向索引中，各个元素的索引从0开始，也就是说第一个元素的索引为0，第九个元素的索引为8，以此类推。
- 反向索引中，各个元素的索引从列表元素数量的相反数开始，也就是说，对于一个元素数量为5的列表，第一个（倒数第五个）元素的索引为-5，倒数第一个（最后一个）元素的索引为-1，倒数第二个元素的索引为-2，以此类推。
字典¶
Note
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值对(key=>value)用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中，格式如下所示：
1 | d = {key1 : value1, key2 : value2 }
|
键必须是唯一的，但值则不必。
值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
Mixly中有很多用于元组操作的模块，如下：
1.字典初始化¶
1.1 描述¶
在初始化字典时，你需要输入字典和各个键的名称，然后将代表各种数据的模块对应地连接到初始化模块上与键对应的地方，你也可以点击蓝色齿轮增加键值对数量。
在初始化字典后，你可以在”变量”模块分类中根据你输入的字典名称找到代表此字典的模块。
Attention
键必须是唯一且不可变的。
1.2 示例¶
源代码：
输出结果：
{'Name': 'Fred', 'Age': 18, 'Country': 'China', 'ID': 1}
2.字典获取所有键¶
2.2 示例¶
源代码：
输出结果：
dict_keys(['Name', 'Age', 'Country', 'ID']) # 'dict_keys' 类对象 <class 'dict_keys'> # 对象的类别 ['Name', 'Age', 'Country', 'ID'] # 转换为列表后
3.字典获取键值¶
3.2 示例¶
源代码：
输出结果：
Fred 18
4.字典添加或修改键值¶
4.2 示例¶
源代码：
输出结果：
Fred Sam Male {'Name': 'Sam', 'Age': 18, 'Country': 'China', 'ID': 1, 'Gender': 'Male'}
5.字典删除键值¶
5.2 示例¶
源代码：
输出结果：
{'Name': 'Fred', 'Age': 18, 'Country': 'China', 'ID': 1} {'Name': 'Fred', 'Age': 18, 'Country': 'China'}
6.字典删除并返回键值¶
6.2 示例¶
源代码：
输出结果：
1 {'Name': 'Fred', 'Age': 18, 'Country': 'China'}
7.字典设置键默认值¶
7.1 描述¶
此模块可以为字典中给定的键设定默认值。 若给定的键存在于字典中，则对应的值不会改变； 若给定的键不存在于字典中，则键值对将会被添加到字典中，且键值为所给的默认值。
Attention
此模块没有返回值。
7.2 示例¶
源代码：
输出结果：
{'Name': 'Fred', 'Age': 18, 'Country': 'China', 'ID': 1} {'Name': 'Fred', 'Age': 18, 'Country': 'China', 'ID': 1, 'Class': 1} {'Name': 'Fred', 'Age': 18, 'Country': 'China', 'ID': 1} {'Name': 'Fred', 'Age': 18, 'Country': 'China', 'ID': 1}
8.字典清空条目¶
8.2 示例¶
源代码：
输出结果：
{'Name': 'Fred', 'Age': 18, 'Country': 'China', 'ID': 1} {}
9.字典转换为列表¶
9.1 描述¶
此模块可以将字典转换为键值对元组作为元素的 ‘dict_items’ 类对象，你可以将其转换为列表对象。
Attention
此模块返回的是一个名叫 ‘dict_items’ 类的对象，你可以将其转换为列表对象。
9.2 示例¶
源代码：
输出结果：
{'Name': 'Fred', 'Age': 18, 'Country': 'China', 'ID': 1} dict_items([('Name', 'Fred'), ('Age', 18), ('Country', 'China'), ('ID', 1)]) # 'dict_items' 类对象 <class 'dict_items'> # 'dict_items' 类对象名 [('Name', 'Fred'), ('Age', 18), ('Country', 'China'), ('ID', 1)]
10.字典获取所有键值¶
10.2 示例¶
源代码：
输出结果：
{'Name': 'Fred', 'Age': 18, 'Country': 'China', 'ID': 1} dict_values(['Fred', 18, 'China', 1]) # 'dict_values' 类对象 <class 'dict_values'> # 对象的类别 ['Fred', 18, 'China', 1] # 转换为列表后
集合¶
Note
集合（set）是一个无序的不重复元素序列。
Mixly中有很多用于集合操作的模块，如下：
1.集合初始化¶
1.1 描述¶
Mixly中有两种初始化集合的方式：
- 第一种，你需要输入集合名称，将代表各种数据的模块连接到初始化模块上，你也可以点击蓝色齿轮增加元素数量。
- 第二种，你也需要输入集合名称，然后直接在花括号中输入各种数据，各个元素使用英文逗号分隔即可。
在使用集合初始化模块后，你可以在”变量”模块分类中根据你输入的集合名称找到代表此集合的模块。
Attention
- 集合内部的各个元素是没有顺序的，所以直接输出集合，每一次的输出结果都是随机的。
- 集合的各个元素类型不要求相同，可以是数字、布尔值和字符串。
- 集合中不能存在相同元素，且集合中的元素必须是不可变类型（列表、集合等为可变类型）。
- 集合中的字符串元素都是由引号包围的，若其他数据类型使用引号包围也将会被视为字符串类型。
1.2 示例¶
源代码：
输出结果：
{1, 'Mixly'} # 因为在Python中1 = 1.0 = True，所以仅保留了1这个元素 {1.5, True, 'Mixly'} {0, 'Mixly'} # 因为在Python中0 = False，所以仅保留了0这个元素 {False, 1, 'Mixly'}
3.集合删除并获取元素¶
3.1 描述¶
此模块可以在给定的集合中删除随机元素，并返回被删除的元素值。
3.2 示例¶
源代码：
输出结果：
{'Mixly', 1, 2, 'Mixpy'} Mixly {1, 2, 'Mixpy'}
4.集合运算¶
4.1 描述¶
此模块可以将给定的两个集合进行并集、交集、差集运算，并返回运算结果的集合。
Attention
- 此模块并不会对原集合进行修改。
- 并集是将两个集合的元素在删除重复元素后组成的集合。
- 交集是两个集合中都包含的元素组成的集合。
- 差集是包含在第一个集合中，但不包含在第二个集合(方法的参数)中的元素组成的集合。
4.2 示例¶
源代码：
输出结果：
{'Mixly', 1, 2, 'Mixpy'} {'Mixly', 2, 3, 'MixGo'} {1, 2, 3, 'MixGo', 'Mixly', 'Mixpy'} {'Mixly', 2} {1, 'Mixpy'} {'Mixly', 1, 2, 'Mixpy'} # 此模块并不会对原集合进行修改 {'Mixly', 2, 3, 'MixGo'}
5.集合运算并更新¶
5.1 描述¶
此模块可以将给定的两个集合进行并集、交集、差集运算，并将运算结果的集合赋值给第一个参数集合。
Attention
- 此模块没有返回值。
- 此模块只会改变第一个参数集合，不会改变第二个参数集合。
5.2 示例1¶
源代码：
输出结果：
{'Mixpy', 1, 'Mixly', 2} {3, 'MixGo', 'Mixly', 2} {1, 2, 3, 'MixGo', 'Mixly', 'Mixpy'} # 更新后的第一个参数集合 {3, 'MixGo', 'Mixly', 2}
5.3 示例2¶
源代码：
输出结果：
{1, 2, 'Mixpy', 'Mixly'} {'MixGo', 2, 3, 'Mixly'} {2, 'Mixly'} # 更新后的第一个参数集合 {'MixGo', 2, 3, 'Mixly'}
5.4 示例3¶
源代码：
输出结果：
{1, 'Mixpy', 2, 'Mixly'} {'MixGo', 2, 3, 'Mixly'} {1, 'Mixpy'} # 更新后的第一个参数集合 {'MixGo', 2, 3, 'Mixly'}
6.集合增加和删除元素¶
6.1 描述¶
此模块可以根据所给值在集合中增加或删除元素。
Attention
- Mixly中，此模块仅能够在集合中增加或删除数字元素。
- 如果添加的元素在集合中已存在，则不执行任何操作。
- 此模块没有返回值。
6.2 示例¶
源代码：
输出结果：
{'Mixpy', 1, 2, 'Mixly'} {'Mixpy', 1, 2, 3, 'Mixly'} # 添加元素3 {'Mixpy', 1, 2, 3, 'Mixly'} # 添加元素2，因为集合中已包含元素2，所以没有执行任何操作 {'Mixpy', 2, 3, 'Mixly'} # 删除元素1
7.集合拆分增加序列元素¶
7.1 描述¶
此模块可以将给定的字符串、列表、元组、集合等拆分增加到集合中。
Attention
- 若是字符串，则将会把字符串拆分为一个一个字符作为元素添加进集合中。
- 在添加时，如果添加的元素在集合中已存在，则该元素只会出现一次，重复的会忽略。
- 此模块没有返回值。
7.2 示例¶
源代码：
输出结果：
{1, 2, 'Mixpy', 'Mixly'} # 添加列表[1,2,3,4,5]，因为1，2已存在，所以并未添加 {1, 2, 3, 4, 5, 'Mixpy', 'Mixly'} # 添加字符串"MixGo"，字符被拆分后添加到集合里 {1, 2, 3, 4, 5, 'i', 'x', 'Mixpy', 'Mixly', 'G', 'M', 'o'} # 添加元组(6,7,8,9,0) {0, 1, 2, 3, 4, 5, 'i', 'x', 6, 7, 8, 9, 'Mixpy', 'Mixly', 'G', 'M', 'o'} # 添加集合{"A","B","C"} {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 'C', 'B', 'Mixpy', 'A', 'x', 'M', 'i', 'Mixly', 'G', 'o'}
8.集合子集超集判断¶
8.1 描述¶
此模块可以判断两个集合的子集和超集关系，并返回判断的逻辑值。
若前一集合是后一集合的子集或超集，则将返回True；否则将返回False。
8.2 示例¶
源代码：
输出结果：
{1, 'Mixly', 2, 'Mixpy'} {1, 2} {2, 3} True # s2是否是s1的子集 False # s3是否是s1的子集 True # s1是否是s2的超集 False # s1是否是s3的超集 False # s2是否是s3的子集 False # s2是否是s3的超集
变量¶
Note
变量是存储在内存中的值，变量可以指定不同的数据类型，存储各种不同类型的数据。
Python中，有五种标准的数据类型：Numbers（数字），String（字符串），List（列表），Tuple（元组），Dictionary（字典）。
Numbers（数字）又包含四种类型：int（有符号整型），long（长整型[也可以代表八进制和十六进制]），float（浮点型），complex（复数）。
Mixly中有很多用于变量操作的模块，如下：
Hint
当你使用其他模块创建变量之后，变量分类下会增加为此变量赋值和调用此变量的模块。
1.使用全局变量¶
1.1 描述¶
Python中定义函数时，若想在函数内部对函数外的变量进行操作，就需要声明其为global（全局变量）。
Hint
全局变量实际上是为了提示 python 解释器，表明被其修饰的变量是全局变量。这样解释器就可以从当前空间中读写相应变量了。
Python 的全局变量是模块 (module) 级别的
每个 python 函数拥有对应的 __globals__ 字典，该字典与函数所属模块的 __dict__ 字典完全相同。函数的全局变量也会从这个字典中获取
即：python 解释器发现函数中的某个变量被 global （全局变量）关键字修饰，就去函数的 __globals__ 字典变量中寻找（因为 python 中函数也是一等对象）；同时，一个模块中每个函数的 __globals__ 字典变量都是模块 __dict__ 字典变量的引用，二者值完全相同。
1.2 返回值¶
Attention
此模块没有返回值。
1.3 示例1¶
源代码：
输出结果：
1 # 在函数中并未使用全局变量，所以函数无法将x赋为2，无法改变x的值
1.4 示例2¶
源代码：
输出结果：
2 # 在函数中使用全局变量，函数将x赋为2
1.5 示例3¶
源代码：
输出结果：
1 # 使用全局变量需要在函数内部声明，在外部声明函数依然无法将x赋为2
2.初始化变量¶
2.1 描述¶
此模块对变量进行初始化，或者为其赋值。
你需要在模块中输入变量名称，如果不存在此变量，则将会创建此变量并赋值；如果存在此变量，则将会为此变量赋新值。
使用此模块创建变量之后，变量分类下会增加为此变量赋值和调用此变量的模块。
2.2 返回值¶
Attention
此模块没有返回值。
2.3 示例¶
源代码：
输出结果：
# 没有输出结果
3.数据类型转换¶
Note
在Python中，各种类型的数据变量可以灵活便捷地进行转换。
但需要注意的是，数据类型转换需要建立在有意义的基础上，你不能够在非数字字符串和数字类型的变量之间转换等等。
3.1 转换为整数¶
3.1.1 描述¶
你可以将小数（float）、布尔值和字符串转换为整数。
Attention
- 将小数转换为整数时，将会直接取小数的整数部分；
- 布尔值转换为整数，True将转换为1，False将转换为0；
- 字符串转换为整数时，字符串的内容必须是整数，字符串类型的小数无法转换为整数，会触发报错。
3.1.2 示例¶
源代码：
输出结果：
7 # '7' 6 # 6.6 7 # 7.4 1 # True 0 # False
3.2 转换为小数¶
3.2.1 描述¶
你可以将整数、布尔值和字符串转换为小数。
Attention
- 将整数转换为小数时，将会直接在整数后面添加小数点和0；
- 布尔值转换为小数，True将转换为1.0，False将转换为0.0；
- 字符串转换为小数时，字符串的内容可以是整数也可以是小数，字符串类型的整数转换为小数时将会在整数后添加小数点和0。
3.2.2 示例¶
源代码：
输出结果：
7.0 # '7' 7.3 # '7.3' 6.0 # 6 1.0 # True 0.0 # False
3.3 转换为布尔值¶
3.3.1 描述¶
你可以将所有类型的变量转换为布尔值。
Attention
- 将所有非空序列（列表、元组、字典、集合、字符串）转换为布尔值时，都会转换为True，空序列将转换为False；
- 将整数和小数转换为布尔值时，1和1.0将转换为True，0和0.0将转换为False；
- 空对象（None）转换为布尔值为False；
3.3.2 示例¶
源代码：
输出结果：
True # "7.3" True # "0" False # "" True # 6 False # 0 False # None True # [1,2,3,4,5] True # (1,2,3,4,5) True # {'Name': 'Tom', 'Age': 18} True # {1,2,3,4,5}
3.4 转换为字符串¶
3.4.1 描述¶
你可以将所有类型的变量转换为字符串。
3.4.2 示例¶
源代码：
输出结果：
# 以下输出的变量类型都是str，可以使用type()方法查看 6 7.3 False None [1, 2, 3, 4, 5] (1, 2, 3, 4, 5) {'Name': 'Tom', 'Age': 18} {1, 2, 3, 4, 5}
3.5 转换为非字典序列¶
3.5.1 描述¶
非字典序列类型（列表、元组、集合、字符串）变量可以相互转换，字典也可以转换为非字典序列类型。
数字、布尔值等类型的变量无法转换为序列类型的变量。
Attention
将字典转换为其他非字典序列类型时，会将字典中的键作为序列的元素添加到序列中。
3.5.2 示例¶
源代码：
输出结果：
['M', 'i', 'x', 'l', 'y'] [1, 2, 3, 4, 5] ['Name', 'Age', 'Country'] [1, 2, 3, 4, 5] ('M', 'i', 'x', 'l', 'y') (1, 2, 3, 4, 5) ('Name', 'Age', 'Country') (1, 2, 3, 4, 5) {'l', 'x', 'y', 'M', 'i'} {1, 2, 3, 4, 5} {1, 2, 3, 4, 5} {'Name', 'Country', 'Age'} # 集合是无序的
4.获取变量数据类型¶
4.1 描述¶
此模块可以获取各种变量的数据类型并返回。
你可以使用此模块获取一些模块返回的未知的对象的数据类型。
4.2 示例¶
源代码：
输出结果：
<class 'int'> <class 'float'> <class 'str'> <class 'list'> <class 'tuple'> <class 'dict'> <class 'set'> <class 'bool'> <class 'NoneType'> # None的数据类型 <class 'zip'> # 迭代打包返回的数据类型 <class 'dict_keys'> # 获取字典所有键的模块返回的数据类型 <class 'dict_items'> # 字典转换为列表的模块返回的数据类型 <class 'dict_values'> # 获取字典所有键值的模块返回的数据类型
5.变量类型模块¶
5.1 描述¶
此模块用于在变量类型判断中作为代表各种变量类型的模块。
5.2 示例¶
在第一个条件语句中，若变量a是字符串类型，则打印输出a，否则输出”变量a不是字符串类型。”；在第二个条件语句中，若变量a是整数类型，则打印输出a，否则输出”变量a不是整数类型。”
源代码：
输出结果：
Mixly 变量a不是整数类型。
函数¶
Note
Mixly中，函数是组织好的、可重复使用的、用来实现单一或相关联功能的一组模块。
函数能提高应用的模块性和模块的重复利用率。
你已经知道Mixly提供了许多内建模块，比如”打印（自动换行）”。
你可以自己创建函数，这被叫做自定义函数。
Mixly中有如下用于函数操作的模块：
1.函数定义（无返回值）¶
1.1 描述¶
Mixly中，你需要在函数定义模块中输入函数的名称，然后将实现函数功能的各种其他模块连接到函数定义模块中。
Attention
- 函数定义模块默认没有参数，你可以点击蓝色齿轮为函数增加参数；
- 请尽量不要为函数命名为无意义的名称，函数的名称最好能够清楚地体现函数的功能；
- 当你创建有参数的函数后，你可以在变量分类下找到调用该参数的模块；
- 当你创建函数后，你可以在函数分类下找到调用函数的模块。
1.2 示例¶
源代码：
输出结果：
你好，Fred！ 欢迎使用Mixly！
2.函数定义（有返回值）¶
2.1 描述¶
在定义有返回值的函数时，你需要在返回值旁边连接变量模块。
有返回值的函数调用模块可以作为变量连接到其他模块上。
Attention
- 函数定义模块默认没有参数，你可以点击蓝色齿轮为函数增加参数；
- 请尽量不要为函数命名为无意义的名称，函数的名称最好能够清楚地体现函数的功能；
- 当你创建有参数的函数后，你可以在变量分类下找到调用该参数的模块；
- 当你创建函数后，你可以在函数分类下找到调用函数的模块。
2.2 示例¶
定义了两个有返回值的函数，square用于计算参数的平方值，calcu_1-2k在给定一元二次方程的参数a, b, c 后可以直接计算出方程的解，并返回一个解组成的列表。
源代码：
输出结果：
[1.0, -0.2] # 一元二次方程 5x²-4x-1=0 的解
3.返回（条件返回）¶
3.1 描述¶
返回语句会将程序或者函数的处理结果返回到原来调用的地方，并把程序的控制权一起交回。
Mixly中的返回模块在有返回值的函数中可以连接返回值，在无返回值的函数中不可以。
Attention
- 函数执行中遇到第一个返回语句时，就会结束函数的执行，不会运行其他的返回语句；
- 条件返回让你可以直接将条件语句连接在返回模块中，仅适用于条件返回的情况。
3.2 示例¶
下面定义了一个函数welcome，如果传入的参数name的名字在bad_guys列表里，则直接返回，不会再执行输出”欢迎使用Mixly！”的语句。
源代码：
输出结果：
你好，Fred 欢迎使用Mixly！ 你好，Tom
串口¶
传感器¶
传感模块：超声波、DHT11、DS18B20（新增）
在传感器部分，我们将一些最常见的传感器相关指令进行编库，比如超声波测距模块，学生在使用超声波进行测距时，可直接运用该模块，只需将Trig与Echo管脚填好即可，这大大节省了学生的编程时间，这将更有助于使学生将更多的精力集中在创意实践上而非抓耳挠腮地编程。
显示器¶
通信¶
通信是为了方便人与计算机交互而采用的一种特殊通信方式。具体包括：串口通信(新增串口选择和波特率设置)、红外通信、I2C通信、SPI通信（新增）。
串口通信¶
串口通信功能学生可在串口监视器中查看。这一功能对于学生检查自己代码以及监视传感器数据提供了便利条件。 假设学生将LM35的温度传感器接到模拟管脚A0口，学生可通过 .. image:: images/13Communicate/commu4.png 指令观察当前室温。随后可能会提出疑问：当前室温怎么可能是58？这将引发学生进一步的思考造成该数据的可能性。
I2C通信¶
I2C（Inter－Integrated Circuit）是同步通信的一种特殊形式，具有接口线少，控制方式简单，器件封装形式小，通信速率较高等优点。Mixly支持I2C的读取和写入，并且支持基于I2C协议的执行器。
SPI通信¶
SPI是串行外设接口（Serial Peripheral Interface）的缩写。SPI，是一种高速的，全双工，同步的通信总线，并且在芯片的管脚上只占用四根线，节约了芯片的管脚，同时为PCB的布局上节省空间，提供方便，拥有简单易用的特性。用户可以使用Mixly向SPI传输数据。
网络¶
物联网¶
自定义模块¶
Factory中的模块可以方便用户编写Mixly中不支持的传感器功能。 .. image:: images/16Factory/factory.png
将以RTC1307库为例，介绍利用factory中的模块，在Mixly快速使用Arduino标准库。
准备工作¶
1.从github.com等网站下载ds1307RTC Arduino库。 2.将库文件解压到Mixly/arduino-1.x.x/portable/sketchbook/libraries目录中。 3.打开Mixly自带的arduino IDE（路径Mixlyarduino-1.x.xarduino.exe），在软件中打开 库目录下的example范例，编译并上传，测试能否正常使用。如果不能正常使用，则需要更换库或者检查硬件问题。
重写程序¶
打开范例程序Mixly/arduino-1.x.x/portable/sketchbook/libraries/DS1307RTC/examples/ReadTime/ReadTest/ReadTest.ino，先分析程序，并适当简化程序。
源程序如下：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 | #include <Wire.h>
#include "TimeLib.h"
#include "DS1307RTC.h"
void setup() {
Serial.begin(9600);
while (!Serial) ; // wait for serial
delay(200);
Serial.println("DS1307RTC Read Test");
Serial.println("-------------------");
}
void loop() {
tmElements_t tm;
if (RTC.read(tm)) {
Serial.print("Ok, Time = ");
print2digits(tm.Hour);
Serial.write(':');
print2digits(tm.Minute);
Serial.write(':');
print2digits(tm.Second);
Serial.print(", Date (D/M/Y) = ");
Serial.print(tm.Day);
Serial.write('/');
Serial.print(tm.Month);
Serial.write('/');
Serial.print(tmYearToCalendar(tm.Year));
Serial.println();
} else {
if (RTC.chipPresent()) {
Serial.println("The DS1307 is stopped. Please run the SetTime");
Serial.println("example to initialize the time and begin running.");
Serial.println();
} else {
Serial.println("DS1307 read error! Please check the circuitry.");
Serial.println();
}
delay(9000);
}
delay(1000);
}
void print2digits(int number) {
if (number >= 0 && number < 10) {
Serial.write('0');
}
Serial.print(number);
}
|
简化程序如下：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 | #include <Wire.h>
#include "TimeLib.h"
#include "DS1307RTC.h"
void setup() {
Serial.begin(9600);
}
void loop() {
tmElements_t tm;
if (RTC.read(tm)) {
Serial.print(tm.Hour);
Serial.print(':');
Serial.print(tm.Minute);
Serial.print(':');
Serial.print(tm.Second);
Serial.print(tm.Day);
Serial.print('/');
Serial.print(tm.Month);
Serial.print('/');
Serial.print(tmYearToCalendar(tm.Year));
}
delay(1000);
}
|
Factory模式下模块：
编写完成后，编译并上传，进行测试。测试利用factroy编写的程序效果是否与arduino IDE编写相同。