Embedded test interview

What is the difference between nandflash and nor flash?

Nor transmission efficiency is very high, in 1 ~ The small size of 4 MB has high cost efficiency, but the low write and erase speeds greatly affect its performance.
The NAND structure provides a very high unit density, achieves a high storage density, and writes and erases quickly. The difficulty of using NAND lies in Flash management and special system interfaces.
 
Performance Comparison
Flash flash memory is a non-loss-prone memory. It can be used to erase and re-program memory unit blocks called blocks. Write operations on any flash device can only be performed in an empty or erased unit. In most cases, the flash device must be erased before writing. It is very easy for the NAND device to perform the erasure operation, and nor requires that all the bits in the target block be written to 0 before the erasure.
Since the nor device is erased with 64 ~ For blocks of KB, the time for performing a write/erase operation is 5 S. In contrast, the erased NAND device is 8 ~ For 32 KB blocks, it takes up to 4 ms to perform the same operation.
When the block size is erased, the performance gap between nor and nadn is further extended. Statistics show that, for a given set of write operations (especially when updating small files, more erasure operations must be performed in the nor-based unit. In this way, when selecting a storage solution, the designer must weigh the following factors.
● Nor reads faster than NAND.
● NAND writes much faster than nor.
● NAND's 4 Ms erasure speed is far faster than nor's 5s.
● Most write operations require erasure first.
● NAND has fewer erased units and fewer erased circuits.
 
Interface differences
Nor Flash has an SRAM interface and enough address pins to address it, so it can easily access every byte in it.
Nand devices use complex I/O ports to access data in a serial manner. Different products or vendors may use different methods. Eight pins are used to transmit control, address, and data information.
Nand read and write operations use 512 bytes of blocks, which is a bit like hard disk management. Naturally, NAND-based memory can replace hard disks or other Block devices.
 
Capacity and cost
The unit size of NAND Flash is almost half the size of the nor device. Because the production process is simpler, the NAND structure can provide a higher capacity within the given mold size, thus reducing the price accordingly.
Nor flash occupies 1 ~ Most of the 16 MB flash memory market, while NAND Flash is only used in 8 ~ Among the MB products, this also shows that nor is mainly used in code storage media. NAND is suitable for data storage. NAND shares the largest share in the compactflash, secure digital, PC cards, and MMC memory cards markets.
 
Reliability and Durability
Reliability is an important issue to consider when using the flahs media. Flash is a suitable storage solution for systems that need to expand MTBF. The reliability of nor and NAND can be compared in terms of life (durability), bit switching and bad block processing.
Life (durability)
In nand flash memory, the maximum number of writes to each block is 1 million, while that of nor is 100,000. In addition to having a block erasure cycle of 10 to 1, the typical NAND block size is eight times smaller than that of the nor device, each NAND memory block is deleted less frequently within a given period of time.
Bit Switching
All flash devices are plagued by bit switching. In some cases (rarely, Nand occurs more often than nor), a bit is reversed or reported to be reversed.
One-bit changes may not be obvious, but if it occurs on a critical file, this small fault may cause system downtime. If there is only a report problem, it may be solved by reading multiple times.
Of course, if this bit changes, you must use the error detection/error correction (EDC/ECC) algorithm. The problem of bit inversion is more common in nand flash memory. The NAND supplier recommends using the EDC/ECC algorithm when using nand flash memory.
This problem is not fatal when using NAND to store multimedia information. Of course, if you use a local storage device to store operating systems, configuration files, or other sensitive information, you must use the EDC/ECC system to ensure reliability.
Bad Block Processing
Bad blocks in NAND devices are randomly distributed. I have tried to eliminate bad blocks before, but I found that the yield rate is too low, the cost is too high, and it is not cost-effective at all.
The NAND device needs to initialize the media to detect Bad blocks and mark them as unavailable. In an existing device, a high failure rate may occur if this processing is not performed in a reliable way.
 
Easy to use
The nor-based flash memory can be used very directly, and can be connected like other memory, and code can be directly run on it.
Due to the need for I/O interfaces, Nand is much more complicated. The access methods for various NAND devices vary from manufacturer to manufacturer.
When using the NAND device, you must first write the driver to continue other operations. Writing information to a NAND device requires considerable skill, because the designer must not
Block write, which means that virtual ing is required from beginning to end on the NAND device.
 
Software Support
When discussing software support, we should distinguish basic read/write/erase operations from high-level software for disk simulation and flash management algorithms, including performance optimization.
Running code on the nor device does not require any software support. When performing the same operation on the NAND device, the driver is usually needed, that is, the memory technology driver (MTD ), the NAND and nor devices require MTD for write and erase operations.
Fewer MTDS are required to use the nor device. Many vendors provide more advanced software for the nor device, including the trueffs driver of the M-system, this driver is used by Wind River system, Microsoft, QNX software system, Symbian, Intel, and other vendors.

1. Read the program section and answer questions.
()
Int main (INT argc, char * argv [])
{
Int c = 9, D = 0;
C = C ++ % 5;
D = C;
Printf ("d = % d \ n", d );
Return 0;
}
A) Write Program output
B) Is this expression risky in a portable system? Why?
Answer: 5
There is a risk, because C = C ++ % 5; this expression has been modified twice for C, the behavior is undefined, and the value of C is undefined.
(B)
# Include "stdio. H"
Int A = 0; // data section
Int B; // data section
Static char C; // BSS
Int main (INT argc, char * argv [])
{
Char d = 4; // Stack
Static short e; // BSS
A ++;
B = 100;
C = (char) ++;
E = (++ d) ++;
Printf ("A = % d, B = % d, c = % D, D = % d, e = % d", a, B, c, d, e );
Return 0;
}
A) Write Program output
B) if the compiler arranges the layout of each variable (A, B, C, D) in the memory (eg. Stack, heap, datasection, BSS section), it is best to use a Graphical description.
Answer: A = 2, B = 100, c = 2, D = 6, E = 5

2. interruption is an important part of embedded systems, which leads to many compilation developers to provide an extension: To interrupt Standard C support, a New Keyword _ interrupt is generated. The following code uses the _ interrupt keyword to define an interrupt service subroutine (ISR). Please comment on the following code.
_ Interrupt double compute_area (double radius)
{
Double area = pI * radius;
Printf ("narea = % F", area );
Return area;
}
Answer
A) ISR cannot return a value;
B) ISR cannot pass parameters;
C) floating points are generally not reentrant;
D) The printf function has re-entry and performance problems.

3 C/C ++ basic knowledge
A) What is the meaning of the keyword volatile during compilation? Three examples of different use cases are provided (which can be pseudo-code or text description ).
Defining variables with the volatile keyword is equivalent to telling the compiler that the value of this variable changes at any time and needs to be stored in the memory each time it is used.
Reread its value and do not optimize it at will.
We recommend that you use the volatile variable:
(1) Hardware registers of parallel Devices
(2) Non-automatic variables (global variables) that will be accessed in an interrupt service subroutine)
(3) variables shared by several tasks in multi-threaded applications

B) What are the specific functions of the static keyword in C language?
In the function body, a variable declared as static remains unchanged when the function is called.
Within the module (but in the external body of the function), a variable declared as static can be accessed by the function used in the module, but cannot be accessed by other functions outside the module.
Access. It is a local global variable.
In a module, a function declared as static can only be called by other functions in this module. That is, this function is restricted in declaring its
Within the local scope of the module.
What is the difference between static global variables and common global variables? STATIC global variables are only made once to prevent being referenced in other file units;
What is the difference between static local variables and common local variables: static local variables are initialized only once, and the next time is based on the previous result value;
What is the difference between a static function and a common function: a static function has only one copy in the memory, and a normal function maintains one copy in each call.
C) What is the difference between the following three variable declarations? Please give the specific meaning
Int const * P;
Int * const P;
Int const * const P;
Answer
A pointer to a constant integer.
A constant pointer to an integer
A constant pointer to a constant integer.

4 embedded system problems
A) for integer variables A = 0x12345678, draw out how to store them in memory in the little endian and big endian modes.
Little endian big endian is the opposite
High address --> 0x12 low address --> 0x12
0x34 0x34
0x56 0x56
Low address --> 0x78 high address --> 0x78

B) In the arm system, which method does the Parameter Pass when a function is called?
When the parameter is <= 4 ~ R3 transfer,> 4 pass through the stack Mode

C) What is the difference between an interrupt (interrupt, such as a keyboard interrupt) and an exception (exception, such as a division by zero exception?
Exception: synchronization with the CPU clock must be considered during generation. In practice, exceptions are also called synchronization interruptions. When the processor executes a wrong command due to a programming error, or a special situation (such as a page missing) occurs during execution, the processor will generate an exception when it must be processed by the kernel.
Interruption refers to an electrical signal generated by external hardware. It enters from the interrupt pin of the CPU and interrupts the current operation of the CPU;
The so-called exception refers to some events that must be handled during software operation. The CPU automatically generates an event to interrupt the current operation and transfer the event to the exception handling process.

5. Set the periodic tasks P1, P2, and P3 to T1, T2, and T3 to 100,150,400 respectively, and the execution time to 20, 40, and 100 respectively. Design a Scheduling Algorithm for task scheduling to meet the task execution cycle and task cycle.

6 priority reversal is a serious problem in embedded systems and must be paid enough attention.
A) First, please explain the priority reversal problem.
B) Many RTOS provide priority inheritance policies (priorityinheritance) and priority ceiling policies (Priority ceilings) to solve the priority reversal problem. Please discuss these two policies.
 
A high-priority task needs to wait for a low-priority task to release resources, while a low-priority task is waiting for a medium-priority task.
Priority Inheritance: inherits the highest priority of a blocked task as its priority. The task exits from the critical section and recovers
Re-initial priority.
Priority ceilings: Specifies the priority ceiling for semaphores that access critical resources.
The Priority Inheritance policy has little impact on the task execution process, because only the critical resources occupied by the high-priority tasks are applied.
This fact raises the priority of a low-priority task.

Preprocessor)

1. Use the preprocessing command # define to declare a constant to indicate the number of seconds in a year (ignore the leap year problem)
# Define seconds_per_year (60*60*24*365) UL
Here I want to see several things:
1) # basic knowledge of define syntax (for example, it cannot end with a semicolon, use of parentheses, and so on)
2) knowing that the pre-processor will calculate the value of a constant expression for you, therefore, it is clearer without a cost to directly write how much seconds you have in a year instead of calculating the actual value.
3) realize that this expression will overflow the integer number of a 16-bit machine-so the long integer sign L is used to tell the compiler that this constant is the long integer number.
4) if you use ul (representing an unsigned long integer) in your expression, you have a good starting point. Remember, the first impression is very important.

2. Write a "standard" macro min, which inputs two parameters and returns a smaller one.
# Define min (A, B) (a) <= (B )? (A): (B ))
This test is intended for the following purposes:
1) ID # basic knowledge of define application in macros. This is important. Before the inline operator becomes part of standard C, macros are the only way to easily generate embedded code. For embedded systems, in order to achieve the required performance, embedded code is often a required method.
2) knowledge of triple-condition operators. The reason for the existence of this operator in C language is that it enables the compiler to produce code that is more optimized than if-then-else. It is important to understand this usage.
3) Be careful to enclose parameters in brackets in macros.
4) I also use this question to discuss the side effects of macros. For example, what will happen when you write down the code below?
Least = min (* P ++, B );

3. pre-processor ID # What is the purpose of error?
If you do not know the answer, see References 1. This problem is useful for distinguishing a normal guy from a nerd. Only the nerd can read the appendix of the C language textbook to find the answer to such a question. Of course, if you are not looking for a nerd, you 'd better ask yourself not to know the answer.

Infinite Loops)

4. Infinite loops are often used in embedded systems. How do you write an infinite loop in C?
There are several solutions to this problem. My preferred solution is:

While (1)
{

}

Some programmers prefer the following solutions:

For (;;)
{

}

This implementation method makes me embarrassed because this syntax does not exactly express what is going on. If a candidate provides this solution, I will use this as an opportunity to explore the basic principles of their practice. If their basic answer is: "I was taught to do this, but I never thought of why. "This leaves a bad impression on me.

The third solution is to use GOTO
Loop:
...
Goto loop;
If the candidate gives the above solution, it indicates that he is an assembly language programmer (which may be a good thing) or a basic/Fortran programmer who wants to enter a new field.

Data declarations)

5. Use variable A to give the following definition
A) An integer)
B) a pointer to an integer (a pointer to an integer)
C) a pointer to a pointer pointing to an integer (a pointer to anintege) r
D) an array of 10 integers (an array of 10 integers)
E) an array with 10 pointers pointing to an integer. (An array of 10 pointers to integers)
F) A pointer to an array with 10 integers (a pointer to anarray of 10 integers)
G) a pointer to a function. The function has an integer parameter and returns an integer number (a pointer to a function thattakes an integer as an argument and returns an integer)

H) An array with 10 pointers pointing to a function, this function has an integer parameter and returns an integer (an array of ten pointers to functions that takean integer argument and return an integer)

The answer is:
A) int A; // an integer
B) int * A; // a pointer to an integer
C) int ** A; // a pointer to an integer
D) int A [10]; // an array of 10 Integers
E) int * A [10]; // an array of 10 pointers to Integers
F) int (* A) [10]; // a pointer to an array of 10 Integers
G) int (* A) (INT); // a pointer to a function a that takes an integer argumentand returns an integer

H) int (* A [10]) (INT); // an array of 10 pointers to functions that take aninteger argument and return an integer

People often claim that there are several questions that need to be answered by reading a book. I agree with this statement. When I wrote this article, I checked the book to confirm the correctness of the syntax. But when I was interviewed, I expected to be asked this question (or similar questions ). Because I knew the answer to this question during the interview period. If the examinee does not know all the answers (or at least most of the answers), the candidate will not be prepared for the interview. If the interviewer is not prepared for the interview, then why did he prepare?

Static

6. What is the role of the keyword static?
Few people can answer this simple question completely. In the C language, the keyword static has three obvious functions:
1) In the function body, a variable declared as static remains unchanged when the function is called.
2) in a module (but in the function body), a variable declared as static can be accessed by the function used in the module, but not by other functions outside the module. It is a local global variable.
3) in a module, a function declared as static can only be called by other functions in the module. That is, this function is restricted to use within the local scope of the module that declares it.

Most of the respondents can answer part 1 correctly. Some of them can answer part 2 correctly. Few people can understand part 3. This is a serious disadvantage of a candidate because he obviously does not understand the benefits and importance of localized data and code scope.

Const

7. What does the const keyword mean?
As soon as I hear the subject say, "const means constant", I know that I am dealing with an amateur. Last year, Dan Saks has completely summarized all const usage in his article, So ESP (TRANSLATOR: embedded systems programming) every reader should be very familiar with what const can and cannot do. if you have never read that article, you only need to say that const means "read-only. Although this is not a complete answer, I accept it as a correct answer. (If you want to know more detailed answers, read the Saks Article carefully .)
If the examinee can answer this question correctly, I will ask him an additional question:
What does the following statement mean?

Const int;
Int const;
Const int *;
Int * const;
Int const * a const;

/******/
The first two functions are the same. A is a constant integer. Third, it means that a is a pointer to a constant INTEGER (that is, an integer cannot be modified, but a pointer can be ). Fourth, a is a constant pointer to an integer (that is, the integer to which the Pointer Points can be modified, but the pointer cannot be modified ). The last one means that A is a constant pointer to a constant INTEGER (that is, the pointer to an integer cannot be modified, and the pointer cannot be modified ). If the examinee can answer these questions correctly, he will leave a good impression on me. By the way, you may ask, even if you don't need the keyword const, it is still easy to write a program with the correct function. Why should I pay so much attention to the keyword const? I also have the following reasons:
1) The function of the keyword const is to send very useful information to the person who reads your code. In fact, the purpose of declaring a parameter as a constant is to inform the user of the application of this parameter. If you spend a lot of time cleaning up the garbage left by others, you will soon learn to thank this excess information. (Of course, programmers who know how to use const seldom leave garbage for others to clean up .)
2) by attaching some information to the optimizer, using the keyword const may produce more compact code.
3) the rational use of the keyword const can enable the compiler to naturally protect those parameters that do not want to be changed, so as to prevent them from being accidentally modified by code. In short, this can reduce the occurrence of bugs.

Volatile

8. What does the keyword volatile mean? Three different examples are provided.
A variable defined as volatile means that this variable may be unexpectedly changed, so that the compiler will not assume the value of this variable. Precisely, the optimizer must carefully re-read the value of this variable every time when using this variable, rather than using the backup stored in the register. The following are examples of volatile variables:
1) Hardware registers of parallel devices (for example, Status Registers)
2) Non-automatic variables that will be accessed in an interrupt service subroutine)
3) variables shared by several tasks in multi-threaded applications

People who cannot answer this question will not be hired. I think this is the most basic problem to distinguish between C programmers and embedded system programmers. Embedded people often deal with hardware, interruptions, RTOS, etc. All of these require volatile variables. If you do not know volatile content, it will lead to disasters.
If the subject correctly answers this question (well, I suspect it will be the case), I will go a little deeper to see if this guy understands the full importance of volatile.
1) can a parameter be const or volatile? Explain why.
2) can a pointer be volatile? Explain why.
3); what are the following function errors:

Int square (volatile int * PTR)
{
Return * PTR ** PTR;
}

The answer is as follows:
1) Yes. One example is read-only status registers. It is volatile because it may be unexpectedly changed. It is const because the program should not try to modify it.
2); yes. Although this is not very common. One example is when a service subroutine repairs a pointer to a buffer.
3) This code is a little abnormal. The purpose of this Code is to return the pointer * PTR points to the square of the value. However, since * PTR points to a volatile parameter, the compiler will generate code similar to the following:

Int square (volatile int * PTR)
{
Int A, B;
A = * PTR;
B = * PTR;
Return a * B;
}

* The value of * PTR may be unexpectedly changed, so a and B may be different. As a result, this Code may not return the expected square value! The correct code is as follows:

Long square (volatile int * PTR)
{
Int;
A = * PTR;
Return a *;
}

Bit manipulation)

9. In an embedded system, you must perform bit operations on variables or registers. Given an integer variable A, write two pieces of code. The first one sets bit 3 of A, and the second one clears bit 3 of. In the preceding two operations, you must keep the other bits unchanged.
There are three basic responses to this problem.
1) I don't know how to start. The quilt has never worked on any embedded system.
2) use bit fields. Bit fields is thrown into the dead corner of C language. It ensures that your Code cannot be transplanted between different compilers, and that your Code cannot be reused. Recently, unfortunately, I have seen infineon write drivers for its more complex communication chip. It uses bit fields and is completely useless to me, because my compiler uses other methods to implement bit fields. Morality: Never let a non-embedded guy stick the actual hardware edge.
3) Use # defines and bit masks. This is a highly portable method and should be used. The best solution is as follows:

# Define bit3 (0x1 <3)
Static int;

Void set_bit3 (void)
{
A | = bit3;
}
Void clear_bit3 (void)
{
A & = ~ Bit3;
}

Some people like to define a mask to set and clear values and define some descriptive constants at the same time, which is acceptable. I want to see several key points: constant, | = and & = ~ Operation.

Accessing fixed memory locations)

10. embedded systems often require programmers to access a specific memory location. In a project, the value of an integer variable whose absolute address is 0x67a9 must be set to 0xaa66. The compiler is a pure ANSI compiler. Write code to complete this task.
Test whether you know that it is legal to forcibly convert an integer number (typecast) into a pointer to access an absolute address. The implementation of this problem varies with the individual style. The typical code is as follows:
Int * PTR;
PTR = (int *) 0x67a9;
* PTR = 0xaa55;

A more obscure approach is:
A relatively obscure method is:

* (Int * const) (0x67a9) = 0xaa55;

Even if your taste is closer to the second option, I suggest you use the first option during the interview.

Interrupts)

11. interruption is an important part of embedded systems, which causes many compilation developers to provide an extension to interrupt Standard C support. It indicates that a new keyword _ interrupt is generated. The following code uses the _ interrupt keyword to define an interrupt service subroutine (ISR). Please comment on this code.

_ Interrupt double compute_area (double radius)
{
Double area = pI * radius;
Printf ("\ narea = % F", area );
Return area;
}

There are too many errors in this function, so people don't know where to start:
1) ISR cannot return a value. If you do not understand this, you will not be hired.
2) ISR cannot pass parameters. If you do not see this, your chances of being hired are equivalent to the first.
3) In many processors/compilers, floating points are generally not reentrant. Some processors/compilers need to import the registers at the amount into the stack. Some processors/compilers do not allow floating-point operations in ISR. In addition, ISR should be short and efficient, and it is unwise to perform floating point operations in ISR.
4) with the 3.1 pulse, printf () often has re-import and performance problems. If you lose the third and fourth points, I won't be too embarrassed. Needless to say, if you can get the last two points, your prospects for employment will become brighter.

Code example)

12. What is the output of the following code? Why?

Void Foo (void)
{
Unsigned int A = 6;
Int B =-20;
(A + B> 6 )? Puts ("> 6"): puts ("<= 6 ");
}
To test whether you understand the principle of automatic Integer Conversion in C language, I found that some developers know very little about these things. In any case, the answer to this unsigned integer is "> 6 ". The reason is that when there are signed and unsigned types in the expression, all operands are automatically converted to the unsigned type. Therefore,-20 is a very large positive integer, so the result calculated by this expression is greater than 6. This is very important for embedded systems that should frequently use the unsigned data type. If you fail to answer this question, you will not be able to get the job.

13. Evaluate the following code snippet:

Unsigned int zero = 0;
Unsigned int compzero = 0 xFFFF;
/* 1's complement of zero */

For a 16-bit processor of the int type, the above Code is incorrect. It should be written as follows:

Unsigned int compzero = ~ 0;

This question reveals whether the examinee understands the importance of the processor font length. In my experience, good embedded programmers can understand hardware details and its limitations very accurately. However, PC programs often treat hardware as an unavoidable headache.
At this stage, the examinee is either totally frustrated or confident. If it is clear that the candidate is not good, the test will end here. However, if the candidates are doing well, I will throw the following append questions. These questions are difficult. I think only very good candidates can do well. To raise these questions, I hope to see more methods for the examinee to cope with the questions, rather than the answers. Whatever it is, you should be entertaining...

Dynamic Memory Allocation (dynamic memory allocation)

14. Although not as common as embedded computers, embedded systems still have the process of dynamically allocating memory from heap. In the embedded system, what are the possible problems with dynamic memory allocation?
In this case, I expect the examinee to mention memory fragmentation, fragment collection issues, variable holding time, and so on. This topic has been widely discussed in the ESP magazine (mainly P. j. plauger, his explanation is far more than anything I can mention here). Let's look back at these magazines! After putting the examinee into a false sense of security, I came up with a small program:
What is the output of the following code snippet? Why?

Char * PTR;
If (PTR = (char *) malloc (0) = NULL)
Puts ("got a null pointer ");
Else
Puts ("got a valid Pointer ");

This is an interesting question. Recently, one of my colleagues inadvertently passed the 0 value to the malloc function. After obtaining a valid pointer, I came up with this question. This is the above Code. The output of this code is "got a validpointer ". I used this to discuss such a problem and see if the subject thought of the library routine. It is important to get the correct answer, but the solution to the problem and the basic principle of your decision are more important.

Typedef
 
15 typedef is frequently used in C to declare an existing data type. You can also use a pre-processor to do similar things. For example, consider the following example:

# Define DPS struct s *
Typedef struct s * TPS;

The intention of the above two cases is to define the DPS and TPS as a pointing structure s pointer. Which method is better? (If so) Why?
This is a very subtle question. Anyone should be congratulated on answering this question (the legitimate reason. The answer is: typedef is better. Consider the following example:

DPS P1, P2;
TPS P3, P4;

The first extension is

Struct s * P1, P2;
.
The code above defines P1 as a point to the structure, and P2 as an actual structure, which may not be what you want. The second example correctly defines the P3 and P4 pointers.

 

Obscure syntax

16. The C language agrees to some shocking structures. Is the following structure legal? If so, what does it do?

Int A = 5, B = 7, C;
C = A ++ B;

This question will end happily in this quiz. Whether you believe it or not, the above example is completely syntactic. The problem is how does the compiler handle it? The authors of low-level compilation will actually argue about this issue. According to the best processing principle, the compiler should be able to handle as many valid usage as possible. Therefore, the above Code is processed:

C = A ++ B;

Therefore, a = 6, B = 7, c = 12 after the code is executed.
If you know the answer or guess the correct answer, you can do well. If you do not know the answer, I will not regard it as a question. I found that the biggest advantage of this problem is that it is a good topic about the code writing style, code readability, and code modifyability.

Okay, guys. You have finished all the tests now. This is my C language test question. I wrote it with pleasure. I hope you can read it in the same mood. If you think this is a good test, try to use it in your job search process. The Sky knows that maybe after a year or two, I will not do my current job. I also need to find one.