精通Arduino：从传感器到游戏开发

5星 · 超过95%的资源需积分: 9 124 浏览量更新于2024-07-25 1 收藏 5.38MB PDF 举报

"Apress.Pro.Arduino.2013" 是一本关于Arduino技术的书籍，由Apress出版社在2013年6月出版，作者和详细内容未给出。本书面向的是英语读者，ISBN编码分别为1430239395和978-1430239390，共316页。通过本书，读者将学习到以下关键知识点： 1. 修改Arduino以适应其他芯片：了解如何扩展Arduino的功能，使其能够与不同类型的微控制器或传感器芯片兼容，以满足更广泛的项目需求。 2. 模拟传感器：学习如何创建和使用传感器模拟器，用于测试和调试Arduino项目中的传感器部分，而无需实际设备，这有助于降低成本并提高开发效率。 3. 构建高级XBee网络：掌握如何设置和管理XBee无线通信模块，建立可靠、高效的无线传感器网络，实现远程数据传输和控制。 4. 编写Arduino库：学习如何为Arduino编写自定义库，提升代码复用性，并且能够分享给Arduino社区，促进开源精神的发展。 5. 使用Android Accessory Development Kit (ADK)：了解如何将Android设备与Arduino连接，利用Android的强大处理能力来控制硬件，开发创新的交互式应用。 6. 游戏开发：探索如何借助Arduino和Gameduino进行硬件游戏开发，创造有趣的互动体验。 7. 连接Android手机与Arduino传感器网络：学习如何将Android设备集成到Arduino传感器网络中，实现手机对环境数据的实时监测和智能响应。书中的章节结构如下： - 第1章：介绍Arduino 1.0.4核心变化，涵盖了新版本带来的改进和升级。 - 第2章：探讨Arduino的开发环境和社会化编程，讨论开源社区对项目的影响。 - 第3章：介绍如何将开源框架openFrameworks与Arduino结合，提升项目的视觉和交互性。 - 第4章：深入Android ADK的使用，讲解如何开发Android与Arduino之间的应用程序。 - 第5章：讲解XBees的配置和应用，构建无线通信网络。 - 第6章：讲述如何模拟传感器，进行项目开发的仿真测试。 - 第7章：学习PID控制器的原理和应用，实现精确的自动控制。 - 第8章：构建Android驱动的传感器网络，实现跨平台的数据交换。 - 第9章：讲解如何使用Arduino与PIC32和ATtiny Atmel芯片协同工作，扩展系统功能。 - 第10章：介绍多处理技术，通过链接多个Arduino实现更高的计算能力。 - 第11章：进入游戏开发领域，利用Arduino开发硬件游戏。 - 第12章：学习自定义Arduino库的编写方法，提高代码组织和可维护性。 - 第13章：介绍Arduino的测试套件，帮助开发者确保代码质量和稳定性。这本书是为想要深入探索Arduino生态系统，提高技能并创新项目的读者准备的。通过学习，读者不仅可以增强对Arduino硬件和软件的理解，还能了解到如何与其他技术（如Android和无线通信）结合，拓宽其应用领域。

Chapter 1 ■ arduino 1.0.4 Core Changes

Variants Files

The Arduino Leonardo is a good example. The Teensy from Paul Stoffregen and the ATmega32u4 breakout board

from Adafruit both contain the same chip as the Leonardo, but have different form factors. The number of pins and

locations don’t match, so creating a board variants file helps map the pins to the common locations more easily. Like

pin 13 used for blink. Pin 7 maps to an LED on the ATmega32u4 breakout board. Adding a variant file causes those

mappings to be the same. The variants file makes it much easier to create a custom board that is Arduino compatible.

These variants files are placed into a folder named after the board or the pin layout. Then, inside boards.txt,

the variants entry needs to be added to:

boardname.build.variant=myboardpins

The files can be placed either into the application hardware/arduino/variants folder or in sketches/hardware/

myat32u4/variants.

Arduino comes with several predefined variants that support the existing Arduino boards, but this chapter will

examine the section specific to the Leonardo variants. Among the other variant folders (mega, micro, standard), there

is a new one called Leonardo. That folder contains pins_arduino.h. This is used at compile time as a reference for the

pin mappings and board-specific features.

Variant Types and Naming

The Arduino Leonardo has 12 analog inputs, but only 5 are mapped on the silk screen. However, all 12 are defined

in the variants file. This means you can use the features—even though they are not labeled—by reading the variants.

The SPI pins are not labeled, but can be accessed via the ICSP header. Here is the section where these capabilities are

defined:

I2C is defined as pins 2 and 3 on the ATmega32u4 chip, as shown in Listing 1-6.

Listing 1-6. Variant File i2C Mappings

static const uint8_t SDA = 2;

static const uint8_t SCL = 3;

SPI is defined as pins 17, 16, 14, and 15 on the ICSP header, as shown in Listing 1-7.

Listing 1-7. SPI Pin Mappings

// Map SPI port to 'new' pins D14..D17

static const uint8_t SS = 17;

static const uint8_t MOSI = 16;

static const uint8_t MISO = 14;

static const uint8_t SCK = 15;

The analog pins are defined and mapped on the ATmega32u4 to the pins shown in Listing 1-8.

Listing 1-8. Analog Pin Mappings

// Mapping of analog pins as digital I/O

// A6-A11 share with digital pins

static const uint8_t A0 = 18;

static const uint8_t A1 = 19;

static const uint8_t A2 = 20;

static const uint8_t A3 = 21;

Chapter 1 ■ arduino 1.0.4 Core Changes

static const uint8_t A4 = 22;

static const uint8_t A5 = 23;

static const uint8_t A6 = 24; // D4

static const uint8_t A7 = 25; // D6

static const uint8_t A8 = 26; // D8

static const uint8_t A9 = 27; // D9

static const uint8_t A10 = 28; // D10

static const uint8_t A11 = 29; // D12

The rest of the file configures the ports and other features to support these constants.

Uploader Options Renamed to Programmers

There are several programmers supported in the list. The supported programmers are

AVR ISP•

AVRISP mkII•

USBtinyISP•

USBasp•

Parallel programmer•

Arduino as ISP•

These options make it easier to program devices that don’t have serial or USB serial ports. The smaller chips, like

the ATtiny 4313, 2313, 85, and 45, can only be programmed via one of these programmers. These programmers can

also be used to put new bootloaders onto Arduino boards. Additionally, they set the chip configuration and speed.

New Bootloaders

A bootloader is the software on the Arduino board that loads the sketch into memory. The sketch is compiled into

a HEX file. The bootloader receives the HEX file from a programmer called Avrdude, and then loads it as the active

program on the device. Several new bootloaders come with Arduino 1.0.4:

• Optiboot: The bootloader for the Arduino Uno rv3.

• Diskloader: The bootloader for the Leonardo and 32u4-based boards.

• Stk500v2: The bootloader for the Arduino Mega 2560.

USB Firmware for 16u2

The firmware is for the USB support and VID information for official Arduino boards. The USB firmware for 16u2

also contains the LUFA library, which Arduino licensed for official USB support. This firmware is burnable into the

Atmega16u2, the Atmega8u2 for the Arduino Uno, and the Arduino Mega 2560. These are now updated for all the

revision 3 boards. Revision 3 also removes the FTDI USB support and replaces it with the Atmega16u2.

You need to use the DFU programmer to program this firmware into those chips. The DFU programmer is

available here: http://dfu-programmer.sourceforge.net/.

Additionally, a modification to board needs to be enabled to allow the programmer to communicate with the

chip.

Chapter 2

Arduino Development and

Social Coding

Improve the world through sharing your code. Participating in a community of coders brings professionalism to your

hobby. The Arduino world is a community that values the free flow of knowledge and recognizes the benefit of the

community to problem solving.

While sharing code might seem to be an unsolvable puzzle at first, many tools have been used to accomplish the

task of code collaboration. In this chapter, you will learn to use the online code-sharing community called GitHub.

Along the way, this chapter will also explore how the Arduino open source community uses modern social-coding

practices to contribute to projects.

Social coding is the idea that any code you create begins with and contributes to the work of a community of

coders and active users who want to assist you as well as to improve their own projects.

Arduino is a fast-changing platform, and its development and best practices are set not by industry standards

alone, but also by the emergent interaction between industry makers and an open source community of software

and hardware hackers. How you participate in the open source community demonstrates how you are a professional.

In the field of Arduino and open hardware, pro means using emergent techniques in social-coding communities,

alongside making and testing in open, entrepreneurial communities. Open hardware, like open source software, even

if created by a single person, is used and lives on in communities of use. So contribute your Arduino IDE source code

for the good of the world and move along.

Because Arduino is open source, it is always under revision by its community of developers. Your code can

undergo quite a bit change when starting a project, and when people begin to work collaboratively with you. The fast

pace of change in a project needs to be matched by fast updates to the documentation. You and your collaborators

will all need to have the same shared idea, and learn to describe that shared concept via documentation in a

collaborative wiki environment. Even if you work alone, documenting your process will enable you to quickly return

to projects once set aside, keep track of multiple projects at a time, or publish the software to run a kit you want to sell.

To document your project, you need to know how to create pages, and edit a project Wiki using the Markdown syntax.

This will be covered in the Documentation section of this chapter.

Components of Social Coding and Project Management

Project description, issue management, code version control, and documentation are the main components of social

coding and project management. We will dig into each one, including a description of what each is and how you

manage it through GitHub. Instead of these features all being hosted in different systems, they can all be found on

GitHub. Centralizing these features in one place helps your community of users and developers keep up to date with

the project and automatically watch for changes. The project repositories you host at GitHub can be created as public

or private repositories. You choose whether you are hosting a private project for a small team, or a public open source

project. On GitHub, you can host as many public open source repositories as you like, but you have to pay for the

ability to have a private project.

Chapter 2 ■ arduino development and SoCial Coding

The first example in this chapter will be a Hello World GitHub example that you can use as a template for

structuring typical projects. All the examples for the book will be organized in a GitHub project repository:

http://github.com/proard. As we learn the tool, you will be able to not only get your own copy of the code for the

book, but you will be able to submit your changes back to the main project.

What Is a Project and How Is It Organized?

A project is the story of what you are working on, and then the hardware and code that make your physical project

blink, move, or communicate. You can’t put physical electronics on your site, so you have to put the description of the

electronics. For our purposes, these files will count as code. and how is it defined?

The basic unit of a project is the code repository. This is where the code lives. Every project is required to have a

name and a description. A readme file is strongly encouraged as well, as it is commonly used as a quick starting point

for people to pick up key concepts and examples of your project. When you use a social-coding tool like GitHub, it

derives a starter page for the project and generates the project’s own unique URL, so users of the project can find it

the project page easily. Hosting a project so that it is public and findable is a good start, but you want to encourage

even more usage and participation. When someone watches, stars, or joins a project, GitHub tracks the changes in the

repository. These changes are then emailed to them, or listed as part of their main page in GitHub.

There are two common patterns for project directory layouts. If you are creating a plain Arduino sketch, then the

folder and the sketch name are the same. So, a sketch called HelloGithub.ino would be placed in a directory called

HelloGithub. As seen in Figure 2-1 for HelloGithub.

Figure 2-1. Example HelloGithub directory layout from Arduino sketches folder

Figure 2-2. Example HelloLibrary directory layout

That directory would be the repository name. This way, when the project is cloned or downloaded from GitHub,

it unpacks as a valid sketch and then can be easily placed in your Arduino sketches folder as in Figure 2-1.

The second pattern is for hosting Arduino libraries you create. In Chapter 13 we go over the details for writing

libraries. In this case there is a pattern to create a repository for the Arduino library you are writing. If you were to write

a library called “HelloLibrary” you would call your repository HelloLibrary. The repository name would automatically be

the directory name that the holds the typical files in an Arduino library. However, the name of the project and the directory

should not include a “_” because Arduino doesn’t allow that in a library name. That way you do not have to change file

names when you want to download or clone the library into the Arduino sketches libraries folder, like in Figure 2-2.

剩余304页未读，继续阅读

DoomLord

粉丝: 114
资源: 1318

精通Arduino：从传感器到游戏开发

Apress.Pro.JPA.2.2nd.Edition.Oct.2013

关于springboot的英文文献

帮我找一下可以写再javaweb毕设里的英文参考文献

spring boot项目英文文献

javascript相关外文文献

列举几个SpringBoot相关的技术文献,以文献引用的格式展示

springboot的参考文献

springboot框架外文参考文献列表

springboot外文文献

springboot参考文献

最新资源