book

Making Embedded Systems, 2nd Edition

by Elecia White

March 2024

Intermediate to advanced

428 pages

12h 6m

English

O'Reilly Media, Inc.

Audio summary available

Read now

Unlock full access

Includes

Includes Quizzes

About This BookWho This Book Is ForAbout the AuthorOrganization of This BookTerminologyConventions Used in This BookUsing Code ExamplesO’Reilly Online LearningHow to Contact UsAcknowledgments
Embedded Systems DevelopmentCompilers and LanguagesDebuggingResource ConstraintsPrinciples to Confront Those ChallengesPrototypes and Maker BoardsFurther Reading
Getting StartedCreating System DiagramsThe Context DiagramThe Block DiagramOrganigramLayering DiagramDesigning for ChangeEncapsulate ModulesDelegation of TasksDriver Interface: Open, Close, Read, Write, IOCTLAdapter PatternCreating InterfacesExample: A Logging InterfaceA Sandbox to Play InBack to the Drawing BoardFurther Reading
Hardware/Software IntegrationIdeal Project FlowHardware DesignBoard Bring-UpReading a DatasheetDatasheet Sections You Need When Things Go WrongDatasheet Sections for Software DevelopersEvaluating Components Using the DatasheetYour Processor Is a LanguageReading a SchematicPractice Reading a Schematic: Arduino!Keep Your Board SafeCreating Your Own Debugging ToolboxDigital MultimeterOscilloscopes and Logic AnalyzersSetting Up a ScopeTesting the Hardware (and Software)Building TestsFlash Test ExampleCommand and ResponseCommand PatternDealing with ErrorsConsistent MethodologyError Checking FlowError-Handling LibraryDebugging Timing ErrorsFurther Reading
Handling RegistersBinary and Hexadecimal MathBitwise OperationsTest, Set, Clear, and ToggleToggling an OutputSetting the Pin to Be an OutputTurning On the LEDBlinking the LEDTroubleshootingSeparating the Hardware from the ActionBoard-Specific Header FileI/O-Handling CodeMain LoopFacade PatternThe Input in I/OMomentary Button PressInterrupt on a Button PressConfiguring the InterruptDebouncing SwitchesRuntime UncertaintyIncreasing Code FlexibilityDependency InjectionUsing a TimerTimer PiecesDoing the MathMore Math: Difficult Goal FrequencyA Long Wait Between Timer TicksUsing a TimerUsing Pulse-Width ModulationShipping the ProductFurther Reading
A Chicken Presses a ButtonAn IRQ HappensNonmaskable InterruptsInterrupt PriorityNested InterruptsSave the ContextRetrieve the ISR from the Vector TableInitializing the Vector TableLooking Up the ISRCall the ISRMultiple Sources for One InterruptDisabling InterruptsCritical SectionsRestore the ContextConfiguring InterruptsWhen and When Not to Use InterruptsHow to Avoid Using InterruptsPollingSystem TickTime-Based EventsA Very Small SchedulerFurther Reading
Scheduling and Operating System BasicsTasksCommunication Between TasksAvoiding Race ConditionsPriority InversionState MachinesState Machine Example: Stoplight ControllerState-Centric State MachineState-Centric State Machine with Hidden TransitionsEvent-Centric State MachineState PatternTable-Driven State MachineChoosing a State Machine ImplementationWatchdogMain LoopsPolling and WaitingTimer InterruptInterrupts Do EverythingInterrupts Cause EventsVery Small SchedulerActive ObjectsFurther Reading
Serial CommunicationTTL SerialRS-232 SerialSPII2C and TWI1-WireParallelDual and Quad SPIUSBConsidering Other ProtocolsCommunications in PracticeExternal ADC Example: Data Ready with SPIUse a FIFO If AvailableDirect Memory Access (DMA) Is FasterExternal ADC Example: SPI and DMACircular BuffersFurther Reading
Key MatricesSegmented DisplaysPixel DisplaysDisplay AssetsChangeable Data? Flyweight and Factory PatternsExternal Flash MemoryDisplay AssetsEmulated EEPROMs and KV StoresLittle File SystemsData StorageAnalog SignalsDigital SensorsData HandlingChanging Algorithms: StrategyAlgorithm Stages: Pipelines and FiltersCalculating Needs: Speeds and FeedsData BandwidthMemory Throughput and BufferingFurther Reading
Fighting with the Compiler OptimizationsImpossible BugsReproduce the BugExplain the BugCreating Chaos and Hard FaultsDividing by ZeroTalking to Things That Aren’t ThereRunning Undefined InstructionsIncorrect Memory Access (Unaligned Access)Returning a Pointer to Stack MemoryStack Overflows and Buffer OverflowsDebugging Hard FaultsProcessor Registers: What Went Wrong?Creating a Core DumpUsing the Core DumpMerely Very Difficult BugsConsequences of Being CleverFurther Reading

Connecting RemotelyDirectly: Ethernet and WiFiThrough a GatewayVia a MeshRobust CommunicationVersion!Checksums, CRCs, HashesEncryption and AuthenticationRisk AnalysisUpdating CodeFirmware Update SecurityMultiple Pieces of CodeFallback LifeboatStaged RolloutManaging Large SystemsManufacturingFurther Reading
Need More Code SpaceReading a Map File (Part 1)Process of EliminationLibrariesFunctions Versus Macros: Which Are Smaller?Constants and StringsNeed More RAMRemove mallocReading a Map File (Part 2)Registers and Local VariablesFunction ChainsPros and Cons of Globals: RAM Versus StackClever Memory OverlaysNeed More SpeedProfilingOptimizing for Processor CyclesSummaryFurther Reading
Identifying Fast and Slow OperationsTaking an AverageDifferent Averages: Cumulative and MedianUsing an Existing AlgorithmDesigning and Modifying AlgorithmsFactor PolynomialsTaylor SeriesDividing by a ConstantScaling the InputLookup TablesFake Floating-Point NumbersRational NumbersPrecisionAddition (and Subtraction)Multiplication (and Division)Machine LearningLook Up the Answer!Further Reading
Understanding Power ConsumptionMeasuring Power ConsumptionDesigning for Lower Power ConsumptionTurn Off the Light When You Leave the RoomTurn Off PeripheralsTurn Off Unused I/O DevicesTurn Off Processor SubsystemsSlow Down to Conserve EnergyPutting the Processor to SleepInterrupt-Based Code Flow ModelA Closer Look at the Main LoopProcessor WatchdogAvoid Frequent Wake-UpsChained ProcessorsFurther Reading
Creating MovementPosition EncodingDriving a Simple DC Motor with PWMMotor ControlPID ControlMotion ProfilesTen Things I Hate About MotorsFurther Reading

Overview

Interested in developing embedded systems? Since they don't tolerate inefficiency, these systems require a disciplined approach to programming. This easy-to-read guide helps you cultivate good development practices based on classic software design patterns and new patterns unique to embedded programming. You'll learn how to build system architecture for processors, not for operating systems, and you'll discover techniques for dealing with hardware difficulties, changing designs, and manufacturing requirements.

Written by an expert who has created systems ranging from DNA scanners to children's toys, this book is ideal for intermediate and experienced programmers, no matter what platform you use. This expanded second edition includes new chapters on IoT and networked sensors, motors and movement, debugging, data handling strategies, and more.

Optimize your system to reduce cost and increase performance
Develop an architecture that makes your software robust in resource-constrained environments
Explore sensors, displays, motors, and other I/O devices
Reduce RAM and power consumption, code space, and processor cycles
Learn how to interpret schematics, datasheets, and power requirements
Discover how to implement complex mathematics and machine learning on small processors
Design effective embedded systems for IoT and networked sensors