C Programming for Arduino. Building your own electronic devices is fascinating fun and this book helps you enter the world of autonomous but connected devices. After an introduction to the Arduino board, you'll end up learning some skills to surprise yourself

Spis treści książki

• 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. Lets 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 ifelse structure to another ifelse structure
        • ifelse structure with combined comparisons expressions
        • Finding all cases for a conditional structure
      • switchcasebreak 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
      • dowhile 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

pokaż cały spis treści

ukryj recenzje