Exploring BeagleBone

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