Introduction xxix
Part I Beagle Board Basics 1
Chapter 1 The Beagle Hardware Platform 3
Introduction to the Boards 3
Who Should Use the Beagle Platform 6
When to Use Beagle Boards 7
When Should You Not Use the Beagle Boards 7
BeagleBone Documentation 8
The Beagle Hardware 10
BeagleBone Versions 10
The Beagle Hardware 12
Beagle Accessories 19
Highly Recommended Accessories 19
Headers for the PocketBeagle 20
Micro-SD Card (for Booting or Flashing eMMCs) 20
External 5V Power Supply (for Peripherals) 22
Ethernet Cable (for Wired BBB Network Connection) 22
HDMI Cable (for Connection to Monitors/Televisions) 22
USB to Serial UART TTL 3.3 (for Finding Problems) 23
Optional Accessories 24
USB Hub (to Connect Several USB Devices to a USB Host) 25
Micro-HDMI to VGA Adapters (for VGA Video and Sound) 25
Wi-Fi Adapters (for Wireless Networking) 25
USB Webcam (for Capturing Images and Streaming Video) 25
USB Keyboard and Mouse (for General-Purpose Computing) 26
Capes 26
How to Destroy Your Board! 27
Summary 29
Support 29
Chapter 2 Beagle Software 31
Linux on the Beagle Boards 32
Linux Distributions for Beagle Boards 32
Create a Linux Micro-SD Card Image 33
Communicating with the Boards 34
Installing Drivers 34
Wired Network Connections 35
Internet-over-USB (All Boards) 36
Regular Ethernet (BBB and BeagleBoard Only) 39
Ethernet Crossover Cable (BBB and BeagleBoard Only) 40
Communicating with Your Board 42
Serial Connection over USB 42
Serial Connection with the USB-to-TTL 3.3 V Cable 43
Connecting Through Secure Shell 44
Secure Shell Connections Using Putty 45
Chrome Apps: Secure Shell Client 45
Transferring Files Using Putty/psftp over SSH 46
Controlling the Beagle Board 48
Basic Linux Commands 48
First Steps 49
Basic File System Commands 50
Environment Variables 52
Basic File Editing 53
What Time Is It? 54
Package Management 56
Beagle-Specific Commands 58
Expand the File System on an SD Card 59
Update the Kernel 60
Interacting with the On-Board LEDs 61
Shutdown 63
Node.js, Cloud9, and BoneScript 64
Introduction to Node.js 64
Introduction to the Cloud9 IDE 66
Introduction to BoneScript 67
Summary 69
Further Reading 69
Chapter 3 Exploring Embedded Linux Systems 71
Introducing Embedded Linux 72
Advantages and Disadvantages of Embedded Linux 73
Is Linux Open Source and Free? 74
Booting the Beagle Boards 74
Bootloaders 74
Kernel Space and User Space 83
The systemd System and Service Manager 85
Managing Linux Systems 90
The Superuser 90
System Administration 92
The Linux File System 92
Links to Files and Directories 94
Users and Groups 95
File System Permissions 98
The Linux Root Directory 102
Commands for File Systems 103
The Reliability of SD Card/eMMC File Systems 111
Linux Commands 113
Output and Input Redirection (>, >>, and <) 113
Pipes (| and tee) 114
Filter Commands (from sort to xargs) 115
echo and cat 117
diff 118
tar 119
md5sum 120
Linux Processes 121
How to Control Linux Processes 121
Foreground and Background Processes 122
Other Linux Topics 124
Using Git for Version Control 124
A Practice-Based Introduction 126
Cloning a Repository (git clone) 126
Getting the Status (git status) 128
Adding to the Staging Area (git add) 128
Committing to the Local Repository (git commit) 129
Pushing to the Remote Repository (git push) 129
Git Branching 130
Creating a Branch (git branch) 130
Merging a Branch (git merge) 132
Deleting a Branch (git branch -d) 132
Common Git Commands 133
Desktop Virtualization 134
Code for This Book 135
Summary 136
Further Reading 136
Bibliography 137
Chapter 4 Interfacing Electronics 139
Analyzing Your Circuits 140
Digital Multimeter 140
Oscilloscopes 141
Basic Circuit Principles 143
Voltage, Current, Resistance, and Ohm’s Law 143
Voltage Division 145
Current Division 146
Implementing Circuits on a Breadboard 147
Digital Multimeters and Breadboards 149
Example Circuit: Voltage Regulation 150
Discrete Components 152
Diodes 152
Light-Emitting Diodes 153
Smoothing and Decoupling Capacitors 156
Transistors 158
Transistors as Switches 159
Field Effect Transistors as Switches 162
Optocouplers/Optoisolators 164
Switches and Buttons 166
Hysteresis 168
Logic Gates 169
Floating Inputs 173
Pull-Up and Pull-Down Resistors 173
Open-Collector and Open-Drain Outputs 174
Interconnecting Gates 175
Analog-to-Digital Conversion 177
Sampling Rate 177
Quantization 178
Operational Amplifi ers 178
Ideal Operational Amplifiers 178
Negative Feedback and Voltage Follower 181
Positive Feedback 181
Concluding Advice 182
Summary 182
Further Reading 183
Chapter 5 Practical Beagle Board Programming 185
Introduction 186
Performance of Different Languages 186
Setting the CPU Frequency 190
Scripting Languages 192
Scripting Language Options 192
Bash 193
Lua 196
Perl 197
Python 198
Dynamically Compiled Languages 201
JavaScript and Node.js on the Beagle boards 201
Java on the Beagle Boards 203
C and C++ on the Beagle Boards 207
C and C++ Language Overview 210
Compiling and Linking 211
Writing the Shortest C/C++ Program 213
Static and Dynamic Compilation 215
Variables and Operators in C/C++ 215
Pointers in C/C++ 219
C-Style Strings 221
LED Flashing Application in C 223
The C of C++ 224
First Example and Strings in C++ 225
Passing by Value, Pointer, and Reference 226
Flashing the LEDs Using C++ (non-OO) 227
Writing a Multicall Binary 228
Overview of Object-Oriented Programming 229
Classes and Objects 229
Encapsulation 230
Inheritance 231
Object-Oriented LED Flashing Code 233
Interfacing to the Linux OS 236
Glibc and Syscall 237
Improving the Performance of Python 239
Cython 239
Boost.Python 242
Summary 244
Further Reading 244
Bibliography 244
Part II Interfacing, Controlling, and Communicating 245
Chapter 6 Interfacing to the Beagle Board Input/Outputs 247
General-Purpose Input/Outputs 248
Introduction to GPIO Interfacing 248
GPIO Digital Output 250
GPIO Digital Input 255
GPIO Confi guration 257
Internal Pull-Up and Pull-Down Resistors 258
GPIO Pin Configuration Settings 258
Interfacing to Powered DC Circuits 265
C++ Control of GPIOs 267
The Linux Device Tree 271
Flattened Device Tree on the Beagle Boards 272
Modifying a Board Device Tree 276
Boot Confi guration Files 278
Analog Inputs and Outputs 280
Analog Inputs 280
Enabling the Analog Inputs 280
Analog Input Application—A Simple Light Meter 282
Analog Outputs (PWM) 285
Output Application—Controlling a Servo Motor 289
BoneScript 290
Digital Read and Write 290
Analog Read 292
Analog Write (PWM) 293
GPIO Performance 294
Advanced GPIO Topics 295
More C++ Programming 295
Callback Functions 295
POSIX Threads 297
Linux poll (sys/poll.h) 298
Enhanced GPIO Class 299
Using GPIOs without Using sudo 302
Root Permissions with setuid 304
Summary 306
Further Reading 306
Chapter 7 Cross-Compilation, Eclipse, and Building Linux 307
Setting Up a Cross-Compilation Toolchain 308
Cross-Compiling Under Debian 309
Testing the Toolchain 311
Emulating the armhf Architecture 312
Cross-Compilation with Third-Party Libraries (Multiarch) 314
Cross-Compilation Using Eclipse 315
Installing Eclipse on Desktop Linux 315
Confi guring Eclipse for Cross-Compilation 316
Remote System Explorer 318
Integrating GitHub into Eclipse 322
Remote Debugging 322
Automatic Documentation (Doxygen) 328
Adding Doxygen Editor Support in Eclipse 330
Cross-Building Linux 330
Downloading the Kernel Source 331
Building the Linux Kernel 332
Building a Poky Linux Distribution (Advanced) 335
Summary 340
Chapter 8 Interfacing to the Beagle Board Buses 341
Introduction to Bus Communication 342
I2C 343
I2C Hardware 343
I2C on the Beagle Boards 344
I2C Devices on the Beagle Boards 345
An I2C Test Circuit 346
A Real-Time Clock 346
The ADXL345 Accelerometer 347
Wiring the Test Circuit 348
Using Linux I2C-Tools 348
i2cdetect 348
i2cdump 349
i2cget 353
i2cset 354
I2C Communication in C 356
Wrapping I2C Devices with C++ Classes 358
SPI 360
SPI Hardware 361
SPI on the Beagle Boards 363
Testing an SPI Bus 363
A First SPI Application (74HC595) 365
Wiring the 74HC595 Circuit 366
SPI Communication Using C 367
Bidirectional SPI Communication in C/C++ 370
The ADXL345 SPI Interface 370
Connecting the ADXL345 to the Beagle Boards 372
Wrapping SPI Devices with C++ Classes 373
Three-Wire SPI Communication 375
Multiple SPI Slave Devices 376
UART 377
The Beagle Board UART 378
UART Examples in C 380
Beagle Board Serial Client 381
LED Serial Server 383
UART Applications: GPS 386
CAN Bus 388
Beagle Board CAN Bus 389
SocketCAN 390
A CAN Bus Test Circuit 392
Linux CAN-utils 393
A SocketCAN C Example 394
Logic-Level Translation 396
Summary 398
Further Reading 399
Chapter 9 Interacting with the Physical Environment 401
Interfacing to Actuators 402
DC Motors 403
Driving Small DC Motors (up to 1.5 A) 406
Controlling a DC Motor Using sysfs 407
Driving Larger DC Motors (Greater Than 1.5 A) 409
Controlling a DC Motor Using C++ 411
Stepper Motors 412
The EasyDriver Stepper Motor Driver 413
A Beagle Board Stepper Motor Driver Circuit 414
Controlling a Stepper Motor Using C++ 415
Relays 417
Interfacing to Analog Sensors 418
Protecting the ADC Inputs 420
Diode Clamping 421
Op-Amp Clamping 422
Analog Sensor Signal Conditioning 427
Scaling Using Voltage Division 427
Signal Offsetting and Scaling 428
Analog Interfacing Examples 431
Infrared Distance Sensing 431
ADXL335 Conditioning Example 436
Interfacing to Local Displays 438
MAX7219 Display Modules 438
Character LCD Modules 441
Building C/C++ Libraries 445
Makefi les 446
CMake 447
A Hello World Example 448
Building a C/C++ Library 449
Using a Shared (.so) or Static (.a) Library 452
Summary 453
Further Reading 454
Chapter 10 Real-Time Interfacing Using External Slave Processors 455
Real-Time Beagle Board 456
Real-Time Kernels 456
Real-Time Hardware Solutions 458
Extended GPIO Availability 458
The MCP23017 and the I2C Bus 460
Controlling the GPIO LED Circuit 461
Reading the GPIO Button State 462
An Interrupt Configuration Example (Advanced) 463
The MCP23S17 and the SPI Bus 464
A C++ Class for the MCP23x17 Devices 465
Adding External UARTs 468
The Arduino 471
An Arduino Serial Slave 474
A UART Echo Test Example 475
UART Command Control of an Arduino 478
An Arduino I2C Slave 481
An I2C Test Circuit 481
I2C Register Echo Example 482
I2C Temperature Sensor Example 484
I2C Temperature Sensor with a Warning LED 486
Arduino Slave Communication Using C/C++ 488
An I2C Ultrasonic Sensor Application 490
Summary 493
Further Reading 493
Part III Advanced Beagle Board Systems 495
Chapter 11 The Internet of Things 497
The Internet of Things 498
A Beagle Board IoT Sensor 499
The Beagle Board as a Sensor Web Server 501
Installing and Configuring a Web Server 502
Configuring the Apache Web Server 503
Creating Web Pages and Web Scripts 503
PHP on the Beagle Board 506
GNU Cgicc Applications (Advanced) 508
Replacing Bone101 with Apache 511
A C/C++ Web Client 512
Network Communications Primer 513
A C/C++ Web Client 514
Secure Communication Using Open SSL 516
A Beagle Board as a “Thing” 518
Thing Speak 518
The Linux Cron Scheduler 521
System crontab 521
User crontab 523
Sending E-mail from the Beagle Board 524
If This Then That 526
IoT Frameworks 528
MQ Telemetry Transport 529
MQTT Server/Broker 531
MQTT Publisher/Subscriber on a Beagle Board 533
The mqtt-spy Debug Tool 534
Writing MQTT Code 535
A Paho MQTT Publisher Example 535
A Paho MQTT Subscriber Example 537
Adafuit IO 539
Configuring the Adafruit IO Account 540
Connecting to Adafruit IO with MQTT 542
An MQTT Node.js Publish Example 543
The C++ Client/Server 545
IoT Device Management 548
Remote Monitoring of a Beagle Board 548
Beagle Board Watchdog Timers 549
Static IP Addresses 551
Power over Ethernet 551
PoE Power Extraction Modules (Advanced Topic) 553
Summary 554
Chapter 12 Wireless Communication and Control 555
Introduction to Wireless Communications 556
Bluetooth Communications 557
Installing a Bluetooth Adapter 558
Checking the LKM 559
Configuring a Bluetooth Adapter 560
Making the Beagle Board Discoverable 561
Android App Development with Bluetooth 563
Wi-Fi Communications 564
Installing a Wi-Fi Adapter 564
The NodeMCU Wi-Fi Slave Processor 568
Flashing with the Latest Firmware 569
Connecting the NodeMCU to Wi-Fi 570
Programming the NodeMCU 571
The NodeMCU Web Server Interface 574
JSON 575
The NodeMCU and MQTT 577
ZigBee Communications 579
Introduction to XBee Devices 579
AT versus API Mode 581
XBee Confi guration 582
XCTU 582
Configuring an XBee Network Using XCTU 583
An XBee AT Mode Example 584
Setting Up the Arduino XBee Device (XBeeA) 584
Setting Up the PocketBeagle XBee Device (XBeePB) 586
An XBee API Mode Example 589
Setting Up the PocketBeagle XBee Device (XBee1) 589
Setting Up the Stand-Alone XBee Device (XBee2) 589
XBee API Mode and Node.js 590
XBee and C/C++ 592
Near Field Communication 593
Summary 596
Chapter 13 Beagle Board with a Rich User Interface 599
Rich UI Beagle Board Architectures 600
Beagle Boards as General-Purpose Computers 601
Connecting a Bluetooth Input Peripheral 603
BeagleBone with a LCD Touchscreen Cape 604
Virtual Network Computing 605
VNC Using VNC Viewer 605
VNC with Xming and PuTTY 606
VNC with a Linux Desktop Computer 607
Fat-Client Applications 608
Rich UI Application Development 608
Introduction to GTK+ on the Beagle Boards 609
The “Hello World” GTK+ Application 609
The Event-Driven Programming Model 610
The GTK+ Temperature Application 611
Introduction to Qt for the Beagle Board 612
Installing Qt Development Tools 613
The “Hello World” Qt Application 613
Qt Primer 615
Qt Concepts 615
The QObject Class 617
Signals and Slots 617
Qt Development Tools 618
A First Qt Creator Example 620
A Qt Temperature Sensor GUI Application 621
Remote UI Application Development 625
Fat-Client Qt GUI Application 626
Multithreaded Server Applications 629
A Multithreaded Temperature Service 632
Parsing Stream Data 634
The Fat Client as a Server 635
Parsing Stream Data with XML 638
The Beagle Board Client Application 639
Summary 641
Further Reading 641
Chapter 14 Images, Video, and Audio 643
Capturing Images and Video 644
USB Webcams 644
Video4Linux2 (V4L2) 646
Image Capture Utility 647
Video4Linux2 Utilities 648
Writing Video4Linux2 Programs 650
Streaming Video 652
Image Processing and Computer Vision 654
Image Processing with Open CV 654
Computer Vision with Open CV 656
Boost 659
BeagleBone Audio 660
Core Audio Software Tools 661
Audio Devices for the Beagle Boards 661
HDMI and USB Audio Playback Devices 661
Internet Radio Playback 664
Recording Audio 664
Audio Network Streaming 666
Bluetooth A2DP Audio 666
Text-to-Speech 669
Summary 670
Further Reading 670
Chapter 15 Real-Time Interfacing with the PRU-ICSS 673
The PRU-ICSS 674
The PRU-ICSS Architecture 674
The Remote Processor Framework 675
Important Documents 676
Development Tools for the PRU-ICSS 676
The PRU Code Generation Tools 677
The PRU Debugger 677
Using the AM335x PRU-ICSS 679
Setting Up the Board for Remoteproc 679
Testing Remoteproc under Linux 680
A First PRU Example 683
PRU-ICSS Enhanced GPIOs 683
A First PRU Program 686
A First PRU Program in C 686
A First PRU Program in Assembly 688
The PRU-ICSS in Detail 691
Registers 691
Local and Global Memory 692
PRU Assembly Instruction Set 696
PRU-ICSS Applications 698
PRU-ICSS Performance Tests 698
Utilizing Regular Linux GPIOs 702
A PRU PWM Generator 704
A PRU Sine Wave Generator 708
An Ultrasonic Sensor Application 709
Summary 714
Further Reading 714
Chapter 16 Embedded Kernel Programming 717
Introduction 718
Why Write Kernel Modules? 718
Loadable Kernel Module Basics 719
A First LKM Example 720
The LKM Make file 722
Building the LKM on a Beagle Board 723
Testing the First LKM Example 724
Testing the LKM Parameter 726
An Embedded LKM Example 727
Interrupt Service Routines 729
Performance 733
Enhanced Button GPIO Driver LKM 733
The object Interface 734
Enhanced LED GPIO Driver LKM 741
Kernel Threads 742
Conclusions 744
Summary 744
Index 745
