ES Textbk _Shibu-592-646

Page 2: The Embedded System Development Environment

Overview of the Development Environment

• Components of the Development Environment:
  • Development Computer (PC or Host): Heart of the development environment.
  • Integrated Development Environment (IDE): Tool for embedded firmware development and debugging.
  • Electronic Design Automation (EDA) Tool: Used for embedded hardware design.
  • Emulator Hardware: Debugging tool for the target board.
  • Signal Sources: Function generator used for simulating inputs to the target board.
  • Target Hardware Debugging Tools: Includes digital CRO, multimeter, logic analyzer, etc.
• Installation of Tools:
  • Tools are available as installable files from vendors (CDs or online downloads).
  • Tools can be freeware, licensed, or trial versions.
• License Types:
  • Licensed Versions: Fully featured and functional.
  • Trial Versions: May have limited features or time restrictions.

Page 3: Integrated Development Environment (IDE)

Definition and Functionality of IDE

• IDE: Integrated environment for developing and debugging processor-specific embedded firmware.
• Components of IDE:
  • Text Editor (Source Code Editor)
  • Cross-Compiler: Supports both cross-platform and same-platform development.
  • Linker: Combines multiple object files into a single executable.
  • Debugger: Used for simulating and debugging code.
• User Interfaces: Can be command-line based or GUI based.
• Examples of IDEs:
  • Command-Line: TURBO C IDE.
  • GUI-Based: Microsoft Visual Studio, NetBeans, Eclipse.

Embedded-Specific IDEs

• Specific to each processor/controller family; provided by manufacturers or third-party vendors.
• Examples:
  • MPLAB (Microchip for PIC)
  • Keil µVision5 (for 8051/ARM)
  • CodeWarrior Development Studio.
• Selection of IDE: Tailored for specific families of processors/controllers; multi-architecture support is typically absent.

Page 4: Starting with Keil μVision IDE for 8051

Installation and Project Creation

• Launching Keil µVision5: Execute the program Uv4.exe.
• Creating a New Project:
  • Go to the Project tab and choose New µVision Project.
  • Save project with .uvproj extension.
  • A device selection dialog will prompt to choose a vendor and part number.
  • After device selection, IDE adds startup code to the project.

Page 5: Target Device Selection

Selecting the Target CPU

• Users can choose from the list of supported vendors for 8051 microcontrollers.
• Upon selection, the IDE displays information about the chosen device and prompts to add startup code.
• Understanding the functionality of the STARTUP.A51 file:
  • Necessary for initializing program memory before firmware execution.

Page 6: Project Setup

Organization on Project Window

• Project Window Categorization:
  • Files, Regs, Books, Functions, Templates
• Users can navigate and modify project organization as required.
• Creating and Adding Source Files:
  • New source files can be created and added to the project as needed.
  • Include necessary headers specific to 8051; for example, #include <reg51.h>.

Page 7: Writing and Managing Code

Writing the First Code

• Users follow standard C syntax for the Hello World program.
• Save files with a .c extension, and proper function definitions are required.

Page 8: File Management

Adding Source Files to Project Structure

• Users can manage multiple source files and ensure only one main function is defined in the project.

Page 9: Target Configuration

Configuring the Target Settings

• Users can set clock frequency, memory settings, and define whether to use internal or external RAM/ROM.

Page 10: Output Settings

File Creation Settings

• Configuring output file settings to either generate executable files or library files based on project requirements.

Page 11: Debugging Options

Firmware Debugging Techniques

• Users can choose between simulator-based or target-level debugging options when testing firmware.

Page 12: Flash Memory Programming

Flash Memory Configuration

• Discussed interfacing options for programming flash memory through the IDE configuration.

Page 13: Writing Content

Compiling and Generating Code

• Overview of how to cross-compile and build the project through the IDE.

Page 14: Compilation Techniques

Selective Compilation

• Users can selectively compile and link files to optimize for time during debugging.

Page 15: Debugging Techniques

Inline Breakpoints

• Discusses setting breakpoints and using debugger features for effective troubleshooting of code.

Page 16: Monitoring Execution

Execution Flow Monitoring

• Users can switch between viewed layouts to facilitate monitoring during debugging sessions.

Page 17: Memory Inspection

Inspecting Memory During Debugging

• Users can view memory contents and modify them as necessary.

Page 18: Local Variables and Call Stack Viewing

Call Stack Overview

• Track local variables and function call hierarchy using the IDE tools.

Page 19: Code Coverage

Performance Analysis

• Summarizes function execution tracking and analysis through provided IDE tools.

Page 20: Peripheral Simulation

Simulation Limitations

• Discusses challenges faced when simulating inputs from sensors and external hardware.

Page 21: Hardware Interaction

Serial Port Output Simulation

• Overview of simulating serial port interactions to retrieve firmware feedback.

Page 22: Delay Generation

Functions for Timing

• Details on implementing delay functions for time-sensitive operations in the firmware.

Page 23: Summary

Femme Debugging Overview

• Discusses overall coverage of debugging environments and techniques applicable.

Page 24: Assembly Language Development

Assembly Programming Environment

• Analyzes differences in developing applications in Assembly versus C.

Page 25: Assembly Program Example

Creating and Debugging Assembly Code

• Illustrates a basic assembly ‘Hello World’ program and its compilation.

Page 26: Assembly Language Comparison

Code Efficiency

• Discussion on memory and code efficiency between assembly and high-level representations.

Page 27: Summary of Differences

Embedded C vs. Assembly

• Analyzes the complexity and efficiency of each programming approach.

Page 28: Binary Code Processes

Converting Source Code to Executables

• Details on the conversion from high-level language to machine-level instructions.

Page 29: Cross Compilation File Types

Types of Generated Files

• Describes file types like .lst, .hex, and more generated during compilation.

Page 30: Disassembly Overview

Disassembler Functions

• Discusses the utility of disassemblers in understanding firmware execution.

Page 31: Compiler Outputs

Cross Compilation Outputs

• Details types of outputs generated during the compilation phases.

Page 32: Listing Files

Generating List Files for Debugging

• Discusses the relevance and utility of .lst files.

Page 33: Preprocessor File Outputs

Preprocessor Uses

• Overview of preprocessor outputs during the compilation stage.

Page 34: Object Files

Exploring OBJ File Structure

• Details contents and purpose of object files in the compilation process.

Page 35: Linker Map Files

Map File Structure

• Breakdown on analyzing and utilizing the map files during linking.

Page 36: HEX File Explained

Hex File Format

• Discusses hex file structure and its application for loading firmware to devices.

Page 37: Motorola HEX Procedure

Understanding Motorola HEX Files

• Describes differences in file structure between Intel and Motorola HEX formats.

Page 38: Disassemblers and Decompiled Code

Utility in Reverse Engineering

• Overview of how disassemblers assist in firmware analysis and debugging.

Page 39: Simulator Vs Emulator

Definition Distinctions

• Clarifies differences between simulator and emulator tools in embedded development.

Page 40: Simulators Explained

Application Use Cases

• Discusses functionalities of simulators in testing applications without physical hardware.

Page 41: Summary of Hardware Debugging Tools

Tool Overview

• A look at common tools used in embedded hardware debugging tasks.

Page 42: Debugging Techniques Summary

Historical Evolution

• Recaps the progression of debugging tools and techniques through the years.

Page 43: Incremental Debugging

Incremental Development Methodologies

• Discusses the significance of breaking down firmware into testable components.

Page 44: Breakpoint Insertion Strategies

Techniques for Code Monitoring

• Overview of inserting checkpoints within the code for debugging assistance.

Page 45: Monitor Program Insights

Characteristics of Monitor Programs

• Reviews essential features included in monitor programs for debugging.

Page 46: Emulation Hardware Structure

Overview of Emulator Functionality

• Discusses the hardware requirements for emulating embedded systems effectively.

Page 47: Hardware Emulator Technology

Examination of Components

• Detailing interoperability of emulator components with host systems.

Page 48: On-Chip Debugging Advantages

Enhancements in Debugging Practices

• Reviews advances offered by on-chip debug solutions for efficient debugging.

Page 49: Test Setup Techniques

Hardware Testing Requirements

• Overviews available testing practices for confirming hardware integrity.

Page 50: Boundary Scan Technique

Advanced Testing for Connectivity Issues

• Discusses the implementation of boundary scan techniques in physical hardware testing.

Page 51: Summary of Boundary Scan

Key Implementation Insights

• Summarizes benefits of boundary scanning for effective debugging of interconnections.