C Programming for Arduino电子书

C Programming for Arduino

Table of Contents

C Programming for Arduino

Credits

About the Author

Acknowledgement

About the Reviewers

www.PacktPub.com

Support files, eBooks, discount offers and more

Why Subscribe?

Free Access for Packt account holders

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Downloading the example code

Errata

Piracy

Questions

1. Let's Plug Things

What is a microcontroller?

Presenting the big Arduino family

About hardware prototyping

Understanding Arduino software architecture

Installing Arduino development environment (IDE)

Installing the IDE

How to launch the environment?

What does the IDE look like?

Installing Arduino drivers

Installing drivers for Arduino Uno R3

Installing drivers for Arduino Duemilanove, Nano, or Diecimilla

What is electricity?

Voltage

Current and power

And what are resistors, capacitors, and so on?

Wiring things and Fritzing

What is Fritzing?

Power supply fundamentals

Hello LED!

What do we want to do exactly?

How can I do that using C code?

Start with a new blank page

Setting up the environment according the board we are using

Let's write the code

Let's upload the code, at last!

Summary

2. First Contact with C

An introduction to programming

Different programming paradigms

Programming style

C and C++?

C is used everywhere

Arduino is programmed with C and C++

The Arduino native library and other libraries

Discovering the Arduino native library

Other libraries included and not directly provided

Some very useful included libraries

Some external libraries

Checking all basic development steps

Using the serial monitor

Baud rate

Serial communication with Arduino

Serial monitoring

Making the Arduino talk to us

Adding serial communication to Blink250ms

Serial functions in more detail

Serial.begin()

Serial.print() and Serial.println()

Digging a bit…

Talking to the board from the computer

Summary

3. C Basics – Making You Stronger

Approaching variables and types of data

What is a variable?

What is a type?

The roll over/wrap concept

Declaring and defining variables

Declaring variables

Defining variables

String

String definition is a construction

Using indexes and search inside String

charAt()

indexOf() and lastIndexOf()

startsWith() and endsWith()

Concatenation, extraction, and replacement

Concatenation

Concat()

Using the + operator on strings

Extract and replace

substring() is the extractor

Splitting a string using a separator

Replacement

Other string functions

toCharArray()

toLowerCase() and toUpperCase()

trim()

length()

Testing variables on the board

Some explanations

The scope concept

static, volatile, and const qualifiers

static

volatile

const

Operators, operator structures, and precedence

Arithmetic operators and types

Character types

Numerical types

Condensed notations and precedence

Increment and decrement operators

Types manipulations

Choosing the right type

Implicit and explicit types conversions

Implicit type conversion

Explicit type conversion

Comparing values and Boolean operators

Comparison expressions

Combining comparisons with Boolean operators

Combining negation and comparisons

Adding conditions in the code

if and else conditional structure

Chaining an if…else structure to another if…else structure

if…else structure with combined comparisons expressions

Finding all cases for a conditional structure

switch…case…break conditional structure

Ternary operator

Making smart loops for repetitive tasks

for loop structure

Playing with increment

More complex increments

Decrements are negative increments

Using imbricated for loops or two indexes

while loop structure

do…while loop structure

Breaking the loops

Infinite loops are not your friends

Summary

4. Improve Programming with Functions, Math, and Timing

Introducing functions

Structure of a function

Creating function prototypes using the Arduino IDE

Header and name of functions

Body and statements of functions

Benefits of using functions

Easier coding and debugging

Better modularity helps reusability

Better readability

C standard mathematical functions and Arduino

Trigonometric C functions in the Arduino core

Some prerequisites

Difference between radians and degrees

Cosine, sine, and tangent

Arccosine, arcsine, and arctangent

Trigonometry functions

Exponential functions and some others

Approaching calculation optimization

The power of the bit shift operation

What are bit operations?

Binary numeral system

Easily converting a binary number to a decimal number

AND, OR, XOR, and NOT operators

AND

OR

XOR

NOT

Bit shift operations

It is all about performance

The switch case labels optimization techniques

Optimizing the range of cases

Optimizing cases according to their frequency

Smaller the scope, the better the board

The Tao of returns

Direct returns concept

Use void if you don't need return

Secrets of lookup tables

Table initialization

Replacing pure calculation with array index operations

Taylor series expansion trick

The Arduino core even provides pointers

Time measure

Does the Arduino board own a watch?

The millis() function

The micros() function

Delay concept and the program flow

What does the program do during the delay?

The polling concept – a special interrupt case

The interrupt handler concept

What is a thread?

A real-life polling library example

Installing an external library

Let's test the code

Summary

5. Sensing with Digital Inputs

Sensing the world

Sensors provide new capacities

Some types of sensors

Quantity is converted to data

Data has to be perceived

What does digital mean?

Digital and analog concepts

Inputs and outputs of Arduino

Introducing a new friend – Processing

Is Processing a language?

Let's install and launch it

A very familiar IDE

Alternative IDEs and versioning

Checking an example

Processing and Arduino

Pushing the button

What is a button, a switch?

Different types of switches

A basic circuit

Wires

The circuit in the real world

The pull-up and pull-down concept

The pseudocode

The code

Making Arduino and Processing talk

The communication protocol

Protocol requirements

Protocol design

The Processing code

Sketching a pseudocode

Let's write that code

Variable definitions

setup()

draw()

The serialEvent() callback

The new Arduino firmware talk-ready

Playing with multiple buttons

The circuit

The Arduino code

The Processing code

Understanding the debounce concept

What? Who is bouncing?

How to debounce

Summary

6. Sensing the World – Feeling with Analog Inputs

Sensing analog inputs and continuous values

How many values can we distinguish?

Reading analog inputs

The real purpose of the potentiometer

Changing the blinking delay of an LED with a potentiometer

How to turn the Arduino into a low voltage voltmeter?

Calculating the precision

Introducing Max 6, the graphical programming framework

A brief history of Max/MSP

Global concepts

What is a graphical programming framework?

Max, for the playground

MSP, for sound

Jitter, for visuals

Gen, for a new approach to code generation

Summarizing everything in one table

Installing Max 6

The very first patch

Playing sounds with the patch

Controlling software using hardware

Improving the sequencer and connecting the Arduino

Let's connect the Arduino to Max 6

The serial object in Max 6

Tracing and Debugging easily in Max 6

Understanding Arduino messages in Max 6

What is really sent on the wire?

Extracting only the payload?

ASCII conversions and symbols

Playing with sensors

Measuring distances

Reading a datasheet?

Let's wire things

Coding the firmware

Reading the distance in Max 6

Measuring flexion

Resistance calculations

Sensing almost everything

Multiplexing with a CD4051 multiplexer/demultiplexer

Multiplexing concepts

Multiple multiplexing/demultiplexing techniques

Space-division multiplexing

Frequency-division multiplexing

Time-division multiplexing

The CD4051B analog multiplexer

What is an integrated circuit?

Wiring the CD4051B IC?

Identifying pin number 1

Supplying the IC

Analog I/O series and the common O/I

Selecting the digital pin

Summary

7. Talking over Serial

Serial communication

Serial and parallel communication

Types and characteristics of serial communications

Synchronous or asynchronous

Duplex mode

Peering and bus

Master and slave buses

Data encoding

Multiple serial interfaces

The powerful Morse code telegraphy ancestor

The famous RS-232

From 25 wires to 3

The elegant I2C

The synchronous SPI

The omnipresent USB

USB system design

USB connectors and cables

FTDI IC converting RS-232 to USB

Summary

8. Designing Visual Output Feedback

Using LEDs

Different types of LEDs

Monochromatic LEDS

Polychromatic LEDs

Remembering the Hello LED example

Multiple monochromatic LEDs

Two buttons and two LEDs

Control and feedback coupling in interaction design

The coupling firmware

More LEDs?

Multiplexing LEDs

Connecting 75HC595 to Arduino and LEDs

Firmware for shift register handling

Global shift register programming pattern

Playing with chance and random seeds

Daisy chaining multiple 74HC595 shift registers

Linking multiple shift registers

Firmware handling two shift registers and 16 LEDs

Current short considerations

Using RGB LEDs

Some control concepts

Different types of RGB LEDs

Lighting an RGB LED

Red, Green, and Blue light components and colors

Multiple imbricated for() loops

Building LED arrays

A new friend named transistor

The Darlington transistors array, ULN2003

The LED matrix

Cycling and POV

The circuit

The 3 x 3 LED matrix code

Simulating analog outputs with PWM

The pulse-width modulation concept

Dimming an LED

A higher resolution PWM driver component

Quick introduction to LCD

HD44780-compatible LCD display circuit

Displaying some random messages

Summary

9. Making Things Move and Creating Sounds

Making things vibrate

The piezoelectric sensor

Wiring a vibration motor

Firmware generating vibrations

Higher current driving and transistors

Controlling a servo

When do we need servos?

How to control servos with Arduino

Wiring one servo

Firmware controlling one servo using the Servo library

Multiple servos with external power supply

Three servos and an external power supply

Driving three servos with firmware

Controlling stepper motors

Wiring a unipolar stepper to Arduino

Firmware controlling the stepper motor

Air movement and sounds

What is sound actually?

How to describe sound

Microphones and speakers

Digital and analog domains

How to digitalize sound

How to play digital bits as sounds

How Arduino helps produce sounds

Playing basic sound bits

Wiring the cheapest sound circuit

Playing random tones

Improving the sound engine with Mozzi

Setting up a circuit and Mozzi library

An example sine wave

Oscillators

Wavetables

Frequency modulation of a sine wave

Adding a pot

Upgrading the firmware for input handling

Controlling the sound using envelopes and MIDI

An overview of MIDI

MIDI and OSC libraries for Arduino

Generating envelopes

Implementing envelopes and MIDI

Wiring a MIDI connector to Arduino

Playing audio files with the PCM library

The PCM library

WAV2C – converting your own sample

Wiring the circuit

Other reader libraries

Summary

10. Some Advanced Techniques

Data storage with EEPROMs

Three native pools of memory on the Arduino boards

Writing and reading with EEPROM core library

External EEPROM wiring

Reading and writing to the EEPROM

Using GPS modules

Wiring the Parallax GPS receiver module

Parsing GPS location data

Arduino, battery, and autonomy

Classic cases of USB power supplying

Supplying external power

Supplying with batteries

Power adapter for Arduino supply

How to calculate current consumption

Drawing on gLCDs

Wiring the device

Demoing the library

Some useful method's families

Global GLCD methods

Drawing methods

Text methods

Using VGA with the Gameduino Shield

Summary

11. Networking

An overview of networks

Overview of the OSI model

Protocols and communications

Data encapsulation and decapsulation

The roles of each layer

Physical layer

Data link layer

Network layer

Transport layer

Application/Host layers

Some aspects of IP addresses and ports

The IP address

The subnet

The communication port

Wiring Arduino to wired Ethernet

Making Processing and Arduino communicate over Ethernet

Basic wiring

Coding network connectivity implementation in Arduino

Coding a Processing Applet communicating on Ethernet

Some words about TCP

Bluetooth communications

Wiring the Bluetooth module

Coding the firmware and the Processing applet

Playing with Wi-Fi

What is Wi-Fi?

Infrastructure mode

Ad hoc mode

Other modes

The Arduino Wi-Fi shield

Basic Wi-Fi connection without encryption

Arduino Wi-Fi connection using WEP or WPA2

Using WEP with Wi-Fi library

Using WPA2 with Wi-Fi library

Arduino has a (light) web server

Tweeting by pushing a switch

An overview of APIs

Twitters API

Using the Twitter library with OAuth support

Grabbing credentials from Twitter

Coding a firmware connecting to Twitter

Summary

12. Playing with Max 6 Framework

Communicating easily with Max 6 – the [serial] object

The [serial] object

Selecting the right serial port

Polling system

Parsing and selecting data coming from Arduino

The readAll firmware

The ReadAll Max 6 patch

Requesting data from Arduino

Parsing the received data

Distributing received data and other tricks

Cordless trick

Encapsulation and subpatching

Abstractions and reusability

Creating a sound-level meter with LEDs

The circuit

The Max 6 patch for calculating sound levels

The firmware for reading bytes

Pitch shift effect controlled by hand

The circuit with the sensor and the firmware

The patch for altering the sound and parsing Arduino messages

Summary

13. Improving your C Programming and Creating Libraries

Programming libraries

The header file

The source file

Creating your own LED-array library

Wiring six LEDs to the board

Creating some nice light patterns

Designing a small LED-pattern library

Writing the LEDpatterns.h header

Writing the LEDpatterns.cpp source

Writing the keyword.txt file

Using the LEDpatterns library

Memory management

Mastering bit shifting

Multiplying/dividing by multiples of 2

Packing multiple data items into bytes

Turning on/off individual bits in a control and port register

Reprogramming the Arduino board

Summary

Conclusion

Index