Introductionto Embedded System

 

Role of Infinite loop

An infinite loop is a loop that runs indefinitely, meaning it never stops executing. It is called an infinite loop because it has no definite endpoint and will continue running forever unless it is interrupted.

Infinite loops can be useful in certain situations, such as when you want a process to run continuously in the background. For example, a server may run an infinite loop to continuously listen for incoming client requests and process them as they come in.

However, infinite loops can also be problematic if they are not designed correctly. For example, if an infinite loop is not programmed to exit under certain conditions, it can cause a program to hang or crash. It is important to carefully plan and design an infinite loop to ensure that it functions correctly and does not cause any issues.

 

 

Compiling

            Compiling is the process of translating source code written in a programming language into machine code that can be executed by a microprocessor or other hardware.

In embedded systems, the source code is usually written in a low-level programming language such as C or C++, and it is often specifically tailored for the hardware on which it will be run. The process of compiling the source code involves several steps, including preprocessing, compiling, and linking.

Preprocessing involves expanding macros and performing other tasks to prepare the source code for compilation. Compiling translates the source code into machine code, and linking combines the machine code with any libraries or other resources that it needs in order to execute.

The result of the compiling process is usually an executable file that can be loaded onto the embedded system and run. Compiling is an important step in the development process for embedded systems, as it allows the source code to be transformed into a form that can be run on the target hardware.

 

Linking And Locating

Linking is the process of combining object files and other resources, such as libraries, into a single executable file that can be run on the target hardware. During the linking process, the object files are combined, and any unresolved symbols (such as function calls or variable references) are resolved by linking in the necessary libraries or object files that contain the definitions for those symbols.

Locating, is the process of determining where in memory to load the program and its associated data. In embedded systems, the program and its data may be stored in a variety of different types of memory, such as ROM, RAM, or flash memory. The process of locating involves determining where in memory to store the program and its data and ensuring that it is properly positioned and aligned for execution.

Linking and locating are both important steps in the development process for embedded systems. Linking ensures that all the necessary code and resources are combined into a single executable file, while locating ensures that the program is properly positioned in memory and ready to be run on the target hardware.

 

 

Downloading

Downloading is the process of transferring a program or other data from a computer or other external device onto the embedded system. This is often done over a communication link, such as a USB connection or a network connection, using specialized software tools.

There are several reasons why downloading might be necessary in an embedded system. For example, it might be used to transfer a new or updated program onto the system, to transfer data for processing or storage, or to troubleshoot problems with the system.

The process of downloading typically involves establishing a connection between the embedded system and the external device, transferring the data over the connection, and then verifying that the data was transferred correctly. Downloading is an important step in the development and maintenance of embedded systems, as it allows new programs and data to be easily transferred onto the system.

 

Debugging

Debugging is the process of identifying and fixing errors or problems in a program or system. This can include finding and correcting syntax errors in the source code, identifying and fixing logical errors that cause the program to produce incorrect results, or troubleshooting hardware or system-level issues that cause the program to fail.

There are a variety of tools and techniques that can be used for debugging in embedded systems. These may include debugging tools built into the development environment, specialized hardware debugging tools such as in-circuit emulators (ICEs), and techniques such as printf debugging or code profiling.

Debugging is an important step in the development process for embedded systems, as it helps to ensure that the program or system is functioning correctly and is free of errors. It can also be an ongoing process, as systems are often updated or modified over time and may require debugging to resolve new issues that arise.

 

 

Emulators

An emulator is a device or software program that allows a computer or other device to mimic the functions of another device. In the context of embedded systems, an emulator may be used to run and test software on a development computer or other platform, without the need for the actual hardware on which the software will ultimately be deployed.

Emulators can be useful for a variety of purposes in embedded systems development. For example, they can be used to test and debug software before it is deployed on the target hardware, to simulate the behavior of hardware peripherals or other devices, or to evaluate the performance of a system under different conditions.

There are a variety of different types of emulators that can be used in embedded systems, ranging from simple software emulators to more complex hardware emulators that mimic the entire target system. Emulators can be an important tool in the development and testing of embedded systems, as they allow developers to test and debug software without the need for the actual hardware.

 

Simulators

A simulator is a device or software program that allows a computer or other device to mimic the behavior of another system or device. Like an emulator, a simulator can be used to run and test software on a development computer or other platform without the need for the actual hardware on which the software will ultimately be deployed.

Simulators are often used in embedded systems development to test and debug software, to evaluate the performance of a system under different conditions, or to simulate the behavior of hardware peripherals or other devices. They can also be used to model and analyze the behavior of a system or device, or to train users on how to operate a particular system.

There are a variety of different types of simulators that can be used in embedded systems, ranging from simple software simulators to more complex hardware simulators that mimic the entire target system. Simulators can be an important tool in the development and testing of embedded systems, as they allow developers to test and debug software without the need for the actual hardware.

 

 

External Peripherals

External peripherals are devices that are connected to the embedded system and are used to perform specific functions. These devices may be connected to the embedded system via a communication interface such as a USB port, a serial port, or a network connection.

Some examples of external peripherals that might be used in an embedded system include:

 

·         Displays: such as LCD screens or OLED displays, used to display information to the user

·         Input devices: such as keyboards, touchscreens, or sensors, used to receive input from the user or the environment

·         Storage devices: such as hard drives or flash drives, used to store data

·         Communication devices: such as modems or network cards, used to transmit and receive data over a communication link

External peripherals can be an important component of an embedded system, as they allow the system to interact with the user or the environment and perform a wide range of functions.

Memory Testing

Memory testing refers to the process of verifying that the system's memory (such as RAM or ROM) is functioning correctly. This may involve testing the memory to ensure that it can store and retrieve data accurately or testing the memory management hardware and software to ensure that it is functioning properly.

There are a variety of different techniques that can be used for memory testing in embedded systems. These may include:

·         Writing and reading data to and from the memory and verifying that it is correct

·         Executing test patterns or algorithms that are designed to stress the memory and detect errors

·         Testing the memory management hardware and software to ensure that it is allocating and deallocating memory correctly and efficiently

Memory testing is an important step in the development and testing of embedded systems, as it helps to ensure that the system's memory is functioning correctly and is free of errors. It can also be an ongoing process, as systems are often updated or modified over time and may require memory testing to ensure that they continue to function correctly.

 

Flash Memory

Flash memory is a type of non-volatile storage that is used in a wide range of electronic devices, including embedded systems. It is called "flash" memory because it uses a process called "floating gate avalanche injection" to store data, which is similar to the way that a camera's flash illuminates a scene.

Flash memory has several characteristics that make it well-suited for use in embedded systems:

·         It is non-volatile, which means that it retains data even when the power is turned off

·         It is relatively fast, with access times that are like those of dynamic RAM (DRAM)

·         It is durable, with a long lifespan and the ability to withstand a wide range of temperatures and environments

·         It is relatively inexpensive, making it a cost-effective choice for many applications

Flash memory is used in a wide range of embedded systems, including smartphones, tablets, and other portable devices, as well as in industrial, automotive, and other applications. It is often used to store the program and data that the embedded system needs to execute, as well as other types of data such as configuration files or user data.

What is Job role of Electronics and Telecommunication Student After B.Tech ?

 

After completing a B.Tech degree in electronics and telecommunications, there are many job roles that you can pursue. Some of the common job roles for such professionals include:

1.      Software developer: This role involves designing, developing, and testing software programs. The average salary for a software developer in India is INR 4.5 lakhs per annum.

2.      Network engineer: This role involves designing, implementing, and maintaining networks and communication systems. The average salary for a network engineer in India is INR 4.5 lakhs per annum.

3.      System engineer: This role involves designing, developing, and testing systems and their components. The average salary for a system engineer in India is INR 4.5 lakhs per annum.

4.      Embedded systems engineer: This role involves designing and developing systems that are integrated into other products. The average salary for an embedded systems engineer in India is INR 4.5 lakhs per annum.

5.      Telecom engineer: This role involves designing, installing, and maintaining telecommunications systems. The average salary for a telecom engineer in India is INR 4.5 lakhs per annum.

6.      Hardware engineer: This role involves designing and developing electronic hardware and systems. The average salary for a hardware engineer in India is INR 4.5 lakhs per annum.

7.      Electronics engineer: This role involves designing and developing electronic systems and components. The average salary for an electronics engineer in India is INR 4.5 lakhs per annum.

8.      Technical sales engineer: This role involves selling technical products or services to customers. The average salary for a technical sales engineer in India is INR 4.5 lakhs per annum.

9.      Project manager: This role involves managing projects from conception to completion. The average salary for a project manager in India is INR 6.5 lakhs per annum.

10.  Consultant: This role involves providing expert advice and support to clients on technical matters. The average salary for a consultant in India is INR 7 lakhs per annum.

 

It is important to note that salaries for these job roles may vary based on factors such as the company, location, industry, and your skills and experience. You can expect to earn a higher salary if you have relevant experience and skills, and if you work for a larger and more established company.

Startup file text (look carefully while copy and past in keil )

 

;/*****************************************************************************/

;/* STARTUP.S: Startup file for Philips LPC2000                               */

;/*****************************************************************************/

;/* <<< Use Configuration Wizard in Context Menu >>>                          */ 

;/*****************************************************************************/

;/* This file is part of the uVision/ARM development tools.                   */

;/* Copyright (c) 2005-2007 Keil Software. All rights reserved.               */

;/* This software may only be used under the terms of a valid, current,       */

;/* end user licence from KEIL for a compatible version of KEIL software      */

;/* development tools. Nothing else gives you the right to use this software. */

;/*****************************************************************************/

;/*

; *  The STARTUP.S code is executed after CPU Reset. This file may be 

; *  translated with the following SET symbols. In uVision these SET 

; *  symbols are entered under Options - ASM - Define.

; *

; *  REMAP: when set the startup code initializes the register MEMMAP 

; *  which overwrites the settings of the CPU configuration pins. The 

; *  startup and interrupt vectors are remapped from:

; *     0x00000000  default setting (not remapped)

; *     0x80000000  when EXTMEM_MODE is used

; *     0x40000000  when RAM_MODE is used

; *

; *  EXTMEM_MODE: when set the device is configured for code execution

; *  from external memory starting at address 0x80000000.

; *

; *  RAM_MODE: when set the device is configured for code execution

; *  from on-chip RAM starting at address 0x40000000.

; *

; *  EXTERNAL_MODE: when set the PIN2SEL values are written that enable

; *  the external BUS at startup.

; */

; Standard definitions of Mode bits and Interrupt (I & F) flags in PSRs

Mode_USR        EQU     0x10

Mode_FIQ        EQU     0x11

Mode_IRQ        EQU     0x12

Mode_SVC        EQU     0x13

Mode_ABT        EQU     0x17

Mode_UND        EQU     0x1B

Mode_SYS        EQU     0x1F

I_Bit           EQU     0x80            ; when I bit is set, IRQ is disabled

F_Bit           EQU     0x40            ; when F bit is set, FIQ is disabled

;// <h> Stack Configuration (Stack Sizes in Bytes)

;//   <o0> Undefined Mode      <0x0-0xFFFFFFFF:8>

;//   <o1> Supervisor Mode     <0x0-0xFFFFFFFF:8>

;//   <o2> Abort Mode          <0x0-0xFFFFFFFF:8>

;//   <o3> Fast Interrupt Mode <0x0-0xFFFFFFFF:8>

;//   <o4> Interrupt Mode      <0x0-0xFFFFFFFF:8>

;//   <o5> User/System Mode    <0x0-0xFFFFFFFF:8>

;// </h>

UND_Stack_Size  EQU     0x00000000

SVC_Stack_Size  EQU     0x00000008

ABT_Stack_Size  EQU     0x00000000

FIQ_Stack_Size  EQU     0x00000000

IRQ_Stack_Size  EQU     0x00000080

USR_Stack_Size  EQU     0x00000400

ISR_Stack_Size  EQU     (UND_Stack_Size + SVC_Stack_Size + ABT_Stack_Size + \

                         FIQ_Stack_Size + IRQ_Stack_Size)

                AREA    STACK, NOINIT, READWRITE, ALIGN=3

Stack_Mem       SPACE   USR_Stack_Size

__initial_sp    SPACE   ISR_Stack_Size

Stack_Top

;// <h> Heap Configuration

;//   <o>  Heap Size (in Bytes) <0x0-0xFFFFFFFF>

;// </h>

Heap_Size       EQU     0x00000000

                AREA    HEAP, NOINIT, READWRITE, ALIGN=3

__heap_base

Heap_Mem        SPACE   Heap_Size

__heap_limit

; VPBDIV definitions

VPBDIV          EQU     0xE01FC100      ; VPBDIV Address

;// <e> VPBDIV Setup

;// <i> Peripheral Bus Clock Rate

;//   <o1.0..1>   VPBDIV: VPB Clock

;//               <0=> VPB Clock = CPU Clock / 4

;//               <1=> VPB Clock = CPU Clock

;//               <2=> VPB Clock = CPU Clock / 2

;//   <o1.4..5>   XCLKDIV: XCLK Pin

;//               <0=> XCLK Pin = CPU Clock / 4

;//               <1=> XCLK Pin = CPU Clock

;//               <2=> XCLK Pin = CPU Clock / 2

;// </e>

VPBDIV_SETUP    EQU     0

VPBDIV_Val      EQU     0x00000000

; Phase Locked Loop (PLL) definitions

PLL_BASE        EQU     0xE01FC080      ; PLL Base Address

PLLCON_OFS      EQU     0x00            ; PLL Control Offset

PLLCFG_OFS      EQU     0x04            ; PLL Configuration Offset

PLLSTAT_OFS     EQU     0x08            ; PLL Status Offset

PLLFEED_OFS     EQU     0x0C            ; PLL Feed Offset

PLLCON_PLLE     EQU     (1<<0)          ; PLL Enable

PLLCON_PLLC     EQU     (1<<1)          ; PLL Connect

PLLCFG_MSEL     EQU     (0x1F<<0)       ; PLL Multiplier

PLLCFG_PSEL     EQU     (0x03<<5)       ; PLL Divider

PLLSTAT_PLOCK   EQU     (1<<10)         ; PLL Lock Status

;// <e> PLL Setup

;//   <o1.0..4>   MSEL: PLL Multiplier Selection

;//               <1-32><#-1>

;//               <i> M Value

;//   <o1.5..6>   PSEL: PLL Divider Selection

;//               <0=> 1   <1=> 2   <2=> 4   <3=> 8

;//               <i> P Value

;// </e>

PLL_SETUP       EQU     1

PLLCFG_Val      EQU     0x00000024

; Memory Accelerator Module (MAM) definitions

MAM_BASE        EQU     0xE01FC000      ; MAM Base Address

MAMCR_OFS       EQU     0x00            ; MAM Control Offset

MAMTIM_OFS      EQU     0x04            ; MAM Timing Offset

;// <e> MAM Setup

;//   <o1.0..1>   MAM Control

;//               <0=> Disabled

;//               <1=> Partially Enabled

;//               <2=> Fully Enabled

;//               <i> Mode

;//   <o2.0..2>   MAM Timing

;//               <0=> Reserved  <1=> 1   <2=> 2   <3=> 3

;//               <4=> 4         <5=> 5   <6=> 6   <7=> 7

;//               <i> Fetch Cycles

;// </e>

MAM_SETUP       EQU     1

MAMCR_Val       EQU     0x00000002

MAMTIM_Val      EQU     0x00000004

; External Memory Controller (EMC) definitions

EMC_BASE        EQU     0xFFE00000      ; EMC Base Address

BCFG0_OFS       EQU     0x00            ; BCFG0 Offset

BCFG1_OFS       EQU     0x04            ; BCFG1 Offset

BCFG2_OFS       EQU     0x08            ; BCFG2 Offset

BCFG3_OFS       EQU     0x0C            ; BCFG3 Offset

;// <e> External Memory Controller (EMC)

EMC_SETUP       EQU     0

;//   <e> Bank Configuration 0 (BCFG0)

;//     <o1.0..3>   IDCY: Idle Cycles <0-15>

;//     <o1.5..9>   WST1: Wait States 1 <0-31>

;//     <o1.11..15> WST2: Wait States 2 <0-31>

;//     <o1.10>     RBLE: Read Byte Lane Enable

;//     <o1.26>     WP: Write Protect

;//     <o1.27>     BM: Burst ROM

;//     <o1.28..29> MW: Memory Width  <0=>  8-bit  <1=> 16-bit

;//                                   <2=> 32-bit  <3=> Reserved

;//   </e>

BCFG0_SETUP EQU         0

BCFG0_Val   EQU         0x0000FBEF

;//   <e> Bank Configuration 1 (BCFG1)

;//     <o1.0..3>   IDCY: Idle Cycles <0-15>

;//     <o1.5..9>   WST1: Wait States 1 <0-31>

;//     <o1.11..15> WST2: Wait States 2 <0-31>

;//     <o1.10>     RBLE: Read Byte Lane Enable

;//     <o1.26>     WP: Write Protect

;//     <o1.27>     BM: Burst ROM

;//     <o1.28..29> MW: Memory Width  <0=>  8-bit  <1=> 16-bit

;//                                   <2=> 32-bit  <3=> Reserved

;//   </e>

BCFG1_SETUP EQU         0

BCFG1_Val   EQU         0x0000FBEF

;//   <e> Bank Configuration 2 (BCFG2)

;//     <o1.0..3>   IDCY: Idle Cycles <0-15>

;//     <o1.5..9>   WST1: Wait States 1 <0-31>

;//     <o1.11..15> WST2: Wait States 2 <0-31>

;//     <o1.10>     RBLE: Read Byte Lane Enable

;//     <o1.26>     WP: Write Protect

;//     <o1.27>     BM: Burst ROM

;//     <o1.28..29> MW: Memory Width  <0=>  8-bit  <1=> 16-bit

;//                                   <2=> 32-bit  <3=> Reserved

;//   </e>

BCFG2_SETUP EQU         0

BCFG2_Val   EQU         0x0000FBEF

;//   <e> Bank Configuration 3 (BCFG3)

;//     <o1.0..3>   IDCY: Idle Cycles <0-15>

;//     <o1.5..9>   WST1: Wait States 1 <0-31>

;//     <o1.11..15> WST2: Wait States 2 <0-31>

;//     <o1.10>     RBLE: Read Byte Lane Enable

;//     <o1.26>     WP: Write Protect

;//     <o1.27>     BM: Burst ROM

;//     <o1.28..29> MW: Memory Width  <0=>  8-bit  <1=> 16-bit

;//                                   <2=> 32-bit  <3=> Reserved

;//   </e>

BCFG3_SETUP EQU         0

BCFG3_Val   EQU         0x0000FBEF

;// </e> End of EMC

; External Memory Pins definitions

PINSEL2         EQU     0xE002C014      ; PINSEL2 Address

PINSEL2_Val     EQU     0x0E6149E4      ; CS0..3, OE, WE, BLS0..3, 

                                        ; D0..31, A2..23, JTAG Pins

                PRESERVE8

                

; Area Definition and Entry Point

;  Startup Code must be linked first at Address at which it expects to run.

                AREA    RESET, CODE, READONLY

                ARM

; Exception Vectors

;  Mapped to Address 0.

;  Absolute addressing mode must be used.

;  Dummy Handlers are implemented as infinite loops which can be modified.

Vectors         LDR     PC, Reset_Addr         

                LDR     PC, Undef_Addr

                LDR     PC, SWI_Addr

                LDR     PC, PAbt_Addr

                LDR     PC, DAbt_Addr

                NOP                            ; Reserved Vector 

;               LDR     PC, IRQ_Addr

                LDR     PC, [PC, #-0x0FF0]     ; Vector from VicVectAddr

                LDR     PC, FIQ_Addr

Reset_Addr      DCD     Reset_Handler

Undef_Addr      DCD     Undef_Handler

SWI_Addr        DCD     SWI_Handler

PAbt_Addr       DCD     PAbt_Handler

DAbt_Addr       DCD     DAbt_Handler

                DCD     0                      ; Reserved Address 

IRQ_Addr        DCD     IRQ_Handler

FIQ_Addr        DCD     FIQ_Handler

Undef_Handler   B       Undef_Handler

SWI_Handler     B       SWI_Handler

PAbt_Handler    B       PAbt_Handler

DAbt_Handler    B       DAbt_Handler

IRQ_Handler     B       IRQ_Handler

FIQ_Handler     B       FIQ_Handler

; Reset Handler

                EXPORT  Reset_Handler

Reset_Handler   

; Setup External Memory Pins

                IF      :DEF:EXTERNAL_MODE

                LDR     R0, =PINSEL2

                LDR     R1, =PINSEL2_Val

                STR     R1, [R0]

                ENDIF

; Setup External Memory Controller

                IF      EMC_SETUP <> 0

                LDR     R0, =EMC_BASE

                IF      BCFG0_SETUP <> 0

                LDR     R1, =BCFG0_Val

                STR     R1, [R0, #BCFG0_OFS]

                ENDIF

                IF      BCFG1_SETUP <> 0

                LDR     R1, =BCFG1_Val

                STR     R1, [R0, #BCFG1_OFS]

                ENDIF

                IF      BCFG2_SETUP <> 0

                LDR     R1, =BCFG2_Val

                STR     R1, [R0, #BCFG2_OFS]

                ENDIF

                IF      BCFG3_SETUP <> 0

                LDR     R1, =BCFG3_Val

                STR     R1, [R0, #BCFG3_OFS]

                ENDIF

                ENDIF   ; EMC_SETUP

; Setup VPBDIV

                IF      VPBDIV_SETUP <> 0

                LDR     R0, =VPBDIV

                LDR     R1, =VPBDIV_Val

                STR     R1, [R0]

                ENDIF

; Setup PLL

                IF      PLL_SETUP <> 0

                LDR     R0, =PLL_BASE

                MOV     R1, #0xAA

                MOV     R2, #0x55

;  Configure and Enable PLL

                MOV     R3, #PLLCFG_Val

                STR     R3, [R0, #PLLCFG_OFS] 

                MOV     R3, #PLLCON_PLLE

                STR     R3, [R0, #PLLCON_OFS]

                STR     R1, [R0, #PLLFEED_OFS]

                STR     R2, [R0, #PLLFEED_OFS]

;  Wait until PLL Locked

PLL_Loop        LDR     R3, [R0, #PLLSTAT_OFS]

                ANDS    R3, R3, #PLLSTAT_PLOCK

                BEQ     PLL_Loop

;  Switch to PLL Clock

                MOV     R3, #(PLLCON_PLLE:OR:PLLCON_PLLC)

                STR     R3, [R0, #PLLCON_OFS]

                STR     R1, [R0, #PLLFEED_OFS]

                STR     R2, [R0, #PLLFEED_OFS]

                ENDIF   ; PLL_SETUP

; Setup MAM

                IF      MAM_SETUP <> 0

                LDR     R0, =MAM_BASE

                MOV     R1, #MAMTIM_Val

                STR     R1, [R0, #MAMTIM_OFS] 

                MOV     R1, #MAMCR_Val

                STR     R1, [R0, #MAMCR_OFS] 

                ENDIF   ; MAM_SETUP

; Memory Mapping (when Interrupt Vectors are in RAM)

MEMMAP          EQU     0xE01FC040      ; Memory Mapping Control

                IF      :DEF:REMAP

                LDR     R0, =MEMMAP

                IF      :DEF:EXTMEM_MODE

                MOV     R1, #3

                ELIF    :DEF:RAM_MODE

                MOV     R1, #2

                ELSE

                MOV     R1, #1

                ENDIF

                STR     R1, [R0]

                ENDIF

; Initialise Interrupt System

;  ...

; Setup Stack for each mode

                LDR     R0, =Stack_Top

;  Enter Undefined Instruction Mode and set its Stack Pointer

                MSR     CPSR_c, #Mode_UND:OR:I_Bit:OR:F_Bit

                MOV     SP, R0

                SUB     R0, R0, #UND_Stack_Size

;  Enter Abort Mode and set its Stack Pointer

                MSR     CPSR_c, #Mode_ABT:OR:I_Bit:OR:F_Bit

                MOV     SP, R0

                SUB     R0, R0, #ABT_Stack_Size

;  Enter FIQ Mode and set its Stack Pointer

                MSR     CPSR_c, #Mode_FIQ:OR:I_Bit:OR:F_Bit

                MOV     SP, R0

                SUB     R0, R0, #FIQ_Stack_Size

;  Enter IRQ Mode and set its Stack Pointer

                MSR     CPSR_c, #Mode_IRQ:OR:I_Bit:OR:F_Bit

                MOV     SP, R0

                SUB     R0, R0, #IRQ_Stack_Size

;  Enter Supervisor Mode and set its Stack Pointer

                MSR     CPSR_c, #Mode_SVC:OR:I_Bit:OR:F_Bit

                MOV     SP, R0

                SUB     R0, R0, #SVC_Stack_Size

;  Enter User Mode and set its Stack Pointer

                MSR     CPSR_c, #Mode_USR

                IF      :DEF:__MICROLIB

                EXPORT __initial_sp

                ELSE

                MOV     SP, R0

                SUB     SL, SP, #USR_Stack_Size

                ENDIF

; Enter the C code

                IMPORT  __main

                LDR     R0, =__main

                BX      R0

                IF      :DEF:__MICROLIB

                EXPORT  __heap_base

                EXPORT  __heap_limit

                ELSE

; User Initial Stack & Heap

                AREA    |.text|, CODE, READONLY

                IMPORT  __use_two_region_memory

                EXPORT  __user_initial_stackheap

__user_initial_stackheap

                LDR     R0, =  Heap_Mem

                LDR     R1, =(Stack_Mem + USR_Stack_Size)

                LDR     R2, = (Heap_Mem +      Heap_Size)

                LDR     R3, = Stack_Mem

                BX      LR

                ENDIF

                END

Linux Questions

 

1. 

Define shell

A shell is a program that acts as the interface between you and the UNIX system, allowing you

to enter commands for the operating system to execute

2.  Describe different types of shell

There are many different shells in use. They are

1.       Bourne shell (sh)

The Bourne shell, or sh, was the default Unix shell of Unix Version 7. It was developed by Stephen Bourne, of AT&T BellLaboratories.

2.       C shell (csh)

This is a Unix shell and a command processor that is run in a text window. The character % is the default prompt for the C shell. File commands can also be read easily by the C shell, which is known as a script

 

3.       Korn shell (ksh)

The Korn shell is the UNIX shell (command execution program, often called a command interpreter ) that was developed by David Korn of Bell Labs as a comprehensive combined version of other major UNIX shells.

 

3.      Write down the responsibility of the shell ?

Shell responsibilities

1. Program Execution

2. Variable and Filename Substitution

3. I/O Redirection

4. Pipeline Hookup

5. Environment Control

6. Interpreted Programming Language

 

1.Program Execution:

• The shell is responsible for the execution of all programs that you request fromyour terminal.

• Each time you type in a line to the shell, the shell analyzes the line and thendetermines what to do. The line that is typed to the shell is known more formallyas the command line. The shell scans this command line and determines the name of the program to be executed and what arguments to pass to the program.

 

2.Variable and Filename Substitution:

• Like any other programming language, the shell lets you assign values to variables. Whenever you specify one of these variables on the command line, preceded by adollar sign, the shell substitutes the value assigned to the variable at that point.

 

 

3. I/O Redirection:

• It is the shell's responsibility to take care of input and output redirection on the command

line. It scans the command line for the occurrence of the special redirection characters <,>, or >>.

 

4.Pipeline Hookup:

• Just as the shell scans the command line looking for redirection characters, it also looks for the pipe character For each such character that it finds, it connects the standard output from the command preceding the | to the standard input of the one following the.  It then initiates execution of both programs.

 

5.Environment Control:

• The shell provides certain commands that let you customize your environment. Your environment includes home directory, the characters that the shell displays toprompt you to type in a command, and a list of the directories to be searched whenever you request that a program be executed.

 

6.Interpreted Programming Language:

• The shell has its own built-in programming language. This language is interpreted, meaning that the shell analyzes each statement in the language one line at a time and then executes it. This differs from programming languages such as C and FORTRAN, in which the programming statements are typically compiled into a machine-executable

form before they are executed.

• Programs developed in interpreted programming languages are typically easier to debug and modify than compiled ones. However, they usually take much longer to execute than their compiled equivalents.

 

4.    What is shell scripting ?

A shell script is a list of commands in a computer program that is run by the Unix shell which is a command line interpreter. A shell script usually has comments that describe the steps.

 

5.     Write down different use of commands in user mode and kernel mode

The User mode is normal mode where the process has limited access. While the Kernel mode is the privileged mode where the process has unrestricted access to system resources like hardware, memory, etc.

User mode

-c = We can add comment field for the useraccount.

-d = To modify the directory for any existing user account.

-e = Using this option we can make the account expiry in specific period.

-g = Change the primary group for a User.

-G = To add a supplementary groups

 

Kernel Mode The kernel’s command-line parameters — The Linux Kernel documentation

agp = [AGP]

acpi= [HW,ACPI,X86,ARM64]

apic= [APIC,X86-32]

autoconf=[IPV6]

ataflop= [HW,M68k]

 

6.     Define system calls and describe its working.

System calls are provided by UNIX to access and control files and devices.

7.     Define process in Linux describe different types of state of a process

A process is an active program. It can also be said as a program that is under execution. It is more than the program code as it includes the program counter, process stack, registers, program code etc. Compared to this, the program code is only the text section.

 

In Unix/Linux operating systems, processes can be in one of the following states:

 

1. RUNNING & RUNNABLE

2. INTERRRUPTABLE_SLEEP

3. UNINTERRUPTABLE_SLEEP

4. STOPPED

5. ZOMBIE

 

1.       RUNNING & RUNNABLE

When the CPU executes a process, it will be in a RUNNING state. When the process is not waiting for any resource and ready to be executed by the CPU, it will be in the RUNNABLE state.

 

2.       INTERRUPTABLE_SLEEP:

When a process is in INTERRUPTABLE_SLEEP, it will wake up from the middle of sleep and process new signals sent to it.

 

3.       UNINTERRUPTABLE_SLEEP:

When a process is in UNINTERRUPTABLE_SLEEP, it will not wake up from the middle of sleep even though new signals are sent to it.

4.       STOPPED

            STOPPED state indicates that the process has been suspended from proceeding further. In Linux             when you issue the ‘Ctrl + Z’ command it will issue a SIGSTOP signal to the process.

 

5.       ZOMBIE

            A process will terminate when it calls ‘system exit’ API or when someone else kills the process.             When a process terminates, it will release all the data structures and the resources it holds.

8.       Define define Demos

 

A daemon (also known as background processes) is a Linux or UNIX program that runs in the background.

 

9.   Define threads &  differance between threads and process

Thread-

Thread is the segment of a process means a process can have multiple threads and these multiple threads are contained within a process. A thread has three states: Running, Ready, and Blocked.

Thread takes less time to terminate as compared to process but unlike process threads do not isolate.

Comparison Basis	Process	Thread
Definition	A process is a program under execution i.e an active program.	A thread is a lightweight process that can be managed independently by a scheduler.
Context switching time	Processes require more time for context switching as they are more heavy.	Threads require less time for context switching as they are lighter than processes.
Memory Sharing	Processes are totally independent and don’t share memory.	A thread may share some memory with its peer threads.
Communication	Communication between processes requires more time than between threads.	Communication between threads requires less time than between processes .
Blocked	If a process gets blocked, remaining processes can continue execution.	If a user level thread gets blocked, all of its peer threads also get blocked.
Resource Consumption	Processes require more resources than threads.	Threads generally need less resources than processes.
Dependency	Individual processes are independent of each other.	Threads are parts of a process and so are dependent.
Data and Code sharing	Processes have independent data and code segments.	A thread shares the data segment, code segment, files etc. with its peer threads.
Treatment by OS	All the different processes are treated separately by the operating system.	All user level peer threads are treated as a single task by the operating system.
Time for creation	Processes require more time for creation.	Threads require less time for creation.
Time for termination	Processes require more time for termination.	Threads require less time for termination.

 

 

 10.   Describe the concept of virtual memory in Linux

Linux supports virtual memory, that is, using a disk as an extension of RAM so that the effective size of usable memory grows correspondingly. The kernel will write the contents of a currently unused block of memory to the hard disk so that the memory can be used for another purpose.

 

When the original contents are needed again, they are read back into memory. This is all made completely transparent to the user; programs running under Linux only see the larger amount of memory available and don't notice that parts of them reside on the disk from time to time.

 

11  Describe a executable file format in Linux

The standard Linux executable format is named Executable and Linking Format ( ELF). It was developed by Unix System Laboratories and is now the most widely used format in the Unix world. Several well-known Unix operating systems, such as System V Release 4 and Sun’s Solaris 2, have adopted ELF as their main executable format.

 

Older Linux versions supported another format named Assembler OUTput Format (a.out); actually, there were several versions of that format floating around the Unix world. It is seldom used now, since ELF is much more practical.

 

Linux supports many other different formats for executable files; in this way, it can run programs compiled for other operating systems, such as MS-DOS EXE programs or BSD Unix’s COFF executables. A few executable formats, like Java or bash scripts, are platform-independent. Example are : load_binary ,load_shlib ,core_dump

 

12  Define linking and loading in Linux

Loading:

Bringing the program from secondary memory to main memory is called Loading.

 

Linking:

Establishing the linking between all the modules or all the functions of the program in order to continue the program execution is called linking.

 

13   Describe concept of semaphores & mutex

Mutex:

A mutex provides mutual exclusion, either producer or consumer can have the key (mutex) and proceed with their work. As long as the buffer is filled by the producer, the consumer needs to wait, and vice versa.

At any point of time, only one thread can work with the entire buffer. The concept can be generalized using semaphore.

 

Semaphore:

A semaphore is a generalized mutex. In lieu of a single buffer, we can split the 4 KB buffer into four 1 KB buffers (identical resources). A semaphore can be associated with these four buffers. The consumer and producer can work on different buffers at the same time.