Embedded Software Engineer

Embedded systems require infinite loops for repeatedly processing or monitoring the state of the program. For instance, the case of a program state continuously being verified for any exceptional errors that might just happen during run-time such as memory outage or divide by zero, etc.

Priority inheritance is a solution to the priority inversion problem. The process waiting for any resource which has a resource lock will have the maximum priority. This is priority inheritance. When one or more high priority jobs are blocked by a job, the original priority assignment is ignored and execution of critical section will be assigned to the job with the highest priority in this elevated scenario. The job returns to the original priority level soon after executing the critical section.

Passing structure by its value to a function is possible, but not a good programming practice. First of all, if we pass the structure by value and the function changes some of those values, then the value change is not reflected in caller function. Also, if the structure is big, then passing the structure by value means copying the whole structure to the function argument stack which can slow the program by a significant amount.

In C, the array name itself represents the address of the first element. So, even if we pass the array name as argument, it will be passed as reference and not its address.

Some of the commonly found errors in embedded systems are

☛ Damage of memory devices static discharges and transient current

☛ Address line malfunctioning due to a short in circuit

☛ Data lines malfunctioning

☛ Due to garbage or errors some memory locations being inaccessible in storage

☛ Inappropriate insertion of memory devices into the memory slots

☛ Wrong control signals

☛ Deterministic operating system having guaranteed worst-case interrupt latency and context-switch times.

☛ Documentation providing for the minimum, average, and maximum number of clock cycles required by each system call.

☛ Interrupt response times should be very minute.

☛ Context switch time should be very low.

☛ Compatibility with several plugin devices.

☛ Overall it should be very reliable.

Paging is a memory management scheme by which computers can store and retrieve data from the secondary memory storage when needed in to primary memory. In this scheme, the operating system retrieves data from secondary storage in same-size blocks called pages. The paging scheme allows the physical address space of a process to be non continuous. Paging allows OS to use secondary storage for data that does not fit entirely into physical memory.

We can use function inside ISR as long as that function is not invoked from other portion of the code.

Volatile- it is about instructing the compiler that a variable will change

Constant- it is about instructing the compiler that a variable will not change.

Real-time embedded systems are computer systems that monitor, respond or control an external environment. This environment is connected to the computer system through actuators, sensors, and other input-output interfaces.

Yes, we can have constant volatile variables

Different types of IPC mechanism are -

☛ Pipes

☛ Named pipes or FIFO

☛ Semaphores

☛ Shared memory

☛ Message queue

☛ Socket

Printf function in ISR is not supported because printf function is not reentrant, thread safe and uses dynamic memory allocation which takes a lot of time and can affect the speed of an ISR up to a great extent.

ISR does not return anything. An ISR returns nothing because there is no caller in the code to read the returned values.

Interrupt latency is the time required for an ISR responds to an interrupt.

With embedded system, it is possible to replace dozens or even more of hardware logic gates, input buffers, timing circuits, output drivers, etc. with a relatively cheap microprocessor.

DMA address deals with physical addresses. It is a device which directly drives the data and address bus during data transfer. So, it is purely physical address.

If we see the declaration volatile int *p, it means that the pointer itself is not volatile and points to an integer that is volatile. This is to inform the compiler that pointer p is pointing to an integer and the value of that integer may change unexpectedly even if there is no code indicating so in the program.