Skip to main content
Fachgebiete
Automobil + Motoren Bauwesen + Immobilien Business IT + Informatik Elektrotechnik + Elektronik Energie + Nachhaltigkeit Finance + Banking Management + Führung Marketing + Vertrieb Maschinenbau + Werkstoffe Versicherung + Risiko
DE
EN
Themenseiten
Organisationspsychologie Projektmanagement Marketing Smart Manufacturing
Bücher
Zeitschriften
Weitere Formate
Podcasts Webinare Technik Webinare Wirtschaft Kongresse Veranstaltungskalender Awards
Jetzt Einzelzugang starten
Zugang für Unternehmen
Referenzkunden
MTZ-Fachkongress

Antriebe und Energiesysteme von morgen


Austausch von Automobil- und Energiewirtschaft

Am 14./15. Mai geht es in Chemnitz um die Mobilitätswende durch Elektro- und Wasserstofffahrzeuge.
Erweiterte Suche
Anmelden
nach oben

2010 | Buch

About Embedded Linux Kapitel lesen Erstes Kapitel lesen

Pro Linux Embedded Systems

verfasst von: Gene Sally

Verlag: Apress

Enthalten in: Springer Professional "Wirtschaft+Technik" , Springer Professional "Technik" , Springer Professional "Wirtschaft"

Einloggen, um Zugang zu erhalten
insite
SUCHEN

Über dieses Buch

Today, Linux is included with nearly every embedded platform. Embedded developers can take a more modern route and spend more time tuning Linux and taking advantage of open source code to build more robust, feature-rich applications. While Gene Sally does not neglect porting Linux to new hardware, modern embedded hardware is more sophisticated than ever: most systems include the capabilities found on desktop systems. This book is written from the perspective of a user employing technologies and techniques typically reserved for desktop systems.

Modern guide for developing embedded Linux systems Shows you how to work with existing Linux embedded system, while still teaching how to port Linux Explains best practices from somebody who has done it before

Inhaltsverzeichnis

Frontmatter
Chapter 1. About Embedded Linux
Abstract
Linux is an incredible piece of software. It’s an operating system that’s just as at home running on IBM’s zSeries supercomputers as it is on a cell phone, manufacturing device, network switch, or even cow milking machine. What’s more incredible is that this software is currently maintained by thousands of the best software engineers and it is available for free
Gene Sally
Chapter 2. Configuring the Software Environment
Abstract
Getting ready for an embedded Linux project is a straightforward process. You need to collect the tools and install the necessary software components, which aren’t usually found on a run-of-the-mill Linux or Windows distribution. Some of the preparation involves getting the right sort of cabling and understanding how to get everything wired up and ready to go.
Gene Sally
Chapter 3. Target Emulation and Virtual Machines
Abstract
Virtualization is a mature technology that lets several operating systems share the physical resources of a machine, such that that each thinks it has exclusive use of the resources. Emulation means that a program impersonates another—or, in this case, that a processor impersonates another.
Gene Sally
Chapter 4. Starting Your Project
Abstract
Embedded projects start with selecting hardware. Based on the requirements of the project, such as cost, battery life, communications, and user interface, a few processors and technologies become obvious choices. For example, low-power consumer devices frequently use ARM processors, and industrial control applications frequently use Intel x86 parts. The hardware selection doesn’t occur in isolation; the team selecting the hardware must at the same time consider the peripheral devices and driver availability. Chapter 17 goes into detail regarding the development process unique to embedded projects.
Gene Sally
Chapter 5. Getting Linux for Your Board
Abstract
After looking at the Linux distribution included with a board or sold by the board vendor, it may make sense to start your project with a Linux distribution created by an open source project or from a commercial vendor. Commercial vendors offer deep support for certain use cases (like graphics on consumer electronics devices or Linux certified for use in telecommunications), and open source projects also focus on certain uses cases along the same lines.
Gene Sally
Chapter 6. Creating a Linux Distribution from Scratch
Abstract
Creating a Linux distribution from scratch is viewed as a daunting task, and it shouldn’t be. The process involves creating a toolchain, using that toolchain to create a root file system, and then building a kernel. The process isn’t complex, it just requires you to carefully follow many steps to build the proper tools. After you go over the instructions for building a toolchain and understand how it works, the smartest route may be to use a tool that builds a toolchain, such as crosstool-NG, to build the root file system and kernel.
Gene Sally
Chapter 7. Booting the Board
Abstract
The performance opens with a boot loader that sets the groundwork for the board to be able to load the kernel. Just like an opening, the boot loader paves the way for the kernel, going as far to load it from a remote server into memory so it can be executed. After it’s in memory, the boot loader hands execution to the kernel and exits. The kernel then has its own bootstrapping process (which duplicates what the boot loader did in some cases) that readies the hardware, loads drivers, and starts its processes to manage the system. When it’s in a running state, the kernel hands off control to an init program. The kernel and init then share the stage until you shut down the system; when the system restarts, the performance begins again.
Gene Sally
Chapter 8. Configuring the Application Development Environment
Abstract
Using Linux grants a great degree of freedom when you’re selecting an approach to use when implementing a project; the same tools available on a desktop are available for an embedded project. The great variety of tools is very liberating for engineers who could only code in C in years past—now you can use C++, Perl, C#, shell scripts, Python, or Java to build an application. Picking the right tool for the job is an important decision that involves knowing the nature of the application and the hardware constraints.
Gene Sally
Chapter 9. Application Development
Abstract
Embedded development on Linux is similar enough to desktop development that you may be lulled into thinking they’re the same. There are some important differences, which this chapter covers as you go through the mechanics of setting up a project from scratch. Although several IDEs perform this for you with varying degrees of success, they all end up creating make files, executing them, and interpreting the results. Learning what’s happening behind the scenes isn’t a character-building exercise; it is, however, a way to make sure you understand what’s happening when you need to get the tool to do something that’s not on the IDE’s menu or when the tool does something contrary to your expectations or needs.
Gene Sally
Chapter 10. Debugging Applications
Abstract
Debugging consumes the lion’s share of time in a project. Peeling away the wrapper around programming methodology fads usually exposes methods and practices for minimizing the time spent debugging, usually via planning and adding help during the debugging phase. Part of this chapter is dedicated to practices that reduce debugging, but mostly it focuses on tools to use when you’re debugging. The information is mixed, because it’s sometimes difficult to separate one topic from the other.
Gene Sally
Chapter 11. Kernel Configuration and Development
Abstract
Embedded Linux development when you’re creating applications is much less about kernel development and more about kernel configuration. Because hardware vendors have a vested interest in making sure Linux is ready for their hardware the day it ships, the days of a developer on an embedded project porting a kernel for a board has become a thing of the past. A typical embedded developer needs to know how the kernel project works but doesn’t spend time doing in-depth kernel hacking like in the days of yore.
Gene Sally
Chapter 12. Real Time
Abstract
A system is real time when timeliness is a dimension of correctness; that means a correct answer delivered late is the same as an answer that has never been delivered. Real-time systems abound in the real world. To a degree, all systems are real time, because they have real-world deadlines: an airline ticketing program needs to issue tickets before the plane leaves, for example. Meeting deadlines is one aspect of real-time systems; the other is that the system behaves in a predictable manner. If the aforementioned airline reservation system issues tickets within 24 hours and does so for every ticketing request, the system can be considered real time.
Gene Sally
Chapter 13. Using Open Source Software Projects
Abstract
As you’ve already read (unless you’ve skipped ahead), the Linux distribution used in an embedded project, or for that matter any Linux distribution, includes more than the kernel—although technically, the Linux project consists of only the kernel. The kernel’s job is managing system resources and running user programs; from your perspective, the value of the device is the problem that the application running on the device solves. This chapter goes into detail describing how to use open source packages in your project. In prior chapters, you built a Linux distribution using tools built for that purpose; but these tools don’t always have all the functionality required for the project, and you need to use packages that these distribution tools don’t support. This chapter describes how an open source project is organized from a technical and personnel perspective. There is also a section dedicated to describing how to build and install the source code offered by an open source project.
Gene Sally
Chapter 14. BusyBox
Abstract
BusyBox is an open source project that is a key part of many embedded systems. It supplies limitedfunctionality implementations of most of the command-line executables found on a desktop Linux system; BusyBox calls these applets. What the applets lack in functionality is more than compensated for in their size: a complete, full-featured BusyBox system weighs in at 1.5MB and can be much smaller when unused applets are dropped. In addition to being small, BusyBox is also clever about how it’s deployed on an embedded target: it’s just one file. Symbolic links named after the applications they replace point to the BusyBox executable. This makes BusyBox easy to deploy and manage.
Gene Sally
Chapter 15. System Design
Abstract
Up until now, the goal has been to get a system up and running well enough for testing, but not for production. In this chapter, you go through the process of systematically creating a root file system that is proper for deployment on a production device. This process involves thinking about how the device is produced and how the user is using the device. This process shouldn’t be haphazard, which means understanding and selecting the right tools for the job and taking the time to study and understand the alternatives offered by the environment around Linux.
Gene Sally
Chapter 16. System Tuning
Abstract
Small is a relative term. Embedded systems seem to divide into three groups: those with just a few megabytes of storage, those with around 16–32MB, and those with a hard drive with gigabytes of storage. This chapter is aimed squarely at the first two groups, because as soon as your system contains a storage medium over a few hundred megabytes, there is no real need to economize on the size of the system—on such a this system, a desktop Linux distribution fits comfortably. However, you may be interested in decreasing the amount of time required to get the system up and running, so don’t flip past this chapter quite yet.
Gene Sally
Chapter 17. Deploying Applications
Abstract
Embedded applications aren’t installed like traditional applications. Nonetheless, code is installed on the target, and time needs to be allotted for the process of getting the program on the target in such a way that it’s ready to run when the board starts. This is a nontrivial undertaking. During the design process, how the device will be built, where, and in what quantities affects what effort goes into automating the deployment process.
Gene Sally
Chapter 18. Handling Field Updates
Abstract
Change is as ever-present as death and taxes. Companies sometimes ship embedded devices with a set of software that fulfills requirements, only to find out that what the software does and what the customer wants don’t quite match. Software passes through code reviews and test suites with flying colors but fails in the field. The new industrial designer likes rounded corners and blue, not square corners and earth tones. A competitor has released a similar device, getting rave reviews for features your product managers said nobody would ever want. No matter what the reason, the software that goes on the device as it leaves the factory will need some sort of update. The question isn’t about the need but rather how to fulfill that need.
Gene Sally
Backmatter
Metadaten
Titel
Pro Linux Embedded Systems
verfasst von
Gene Sally
Copyright-Jahr
2010
Verlag
Apress
Electronic ISBN
978-1-4302-7226-7
Print ISBN
978-1-4302-7227-4
DOI
https://doi.org/10.1007/978-1-4302-7226-7

Premium Partner

    Bildnachweise