
	^{For questions and comments about these pages send an e-mail to} ^{Copyright © all rights reserved Eberhard De Wille and Dana Vede.}

Multiple Choice Questions - Software Design Training

First name *
Family name *
E-Mail *

Fields with * have to be filled in!

Problems of a Typical Software Design for Microcontrollers

What are the general reasons for a problematic design? (tick several answers)

The additional hardware dimension in a project defers the attention from software design issues.

There is a need for global variables because of debugging and measurement.

The software engineers follow outdated design rules.

The tools like compilers, debuggers and emulators usually have a poor quality.

Microcontrollers are very hard to program.

The aim is to save RAM and ROM because this costs money in each unit which is sold. A good design is considered to generate overhead and thus additional costs.

What are the reasons that the use of globlal variables can lead to a bad software desing for microcontrollers? (tick several answers)

The use of global variables may lead to cross influences by deliberate access across modules.

The use of global variables may lead to errors due to the change of linkage according to the ISO C rules.

The use of global variables may lead to increased ROM consumption because the compiler generates additional debug code.

The use of global variables requires explicit initialisation of the variables.

The use of global variables will lead to a data flow which is scattered over multiple functions and modules. This means that maintainability and testability is very poor. Small modifications lead to a different data flow and possible data error.

Global variables are hard to debug because the break points in the debugger can not be set on lines where they are used.

The use of global variables tends to generate functions defined as void - void. This means that maintainability and testability is reduced.

What leads to further technical problems in software design for microcontroller systems? (tick several answers)

The use of implementation (compiler / CPU) specific commands in the source code leads to the loss of portability.

The use of implementation (compiler / CPU) specific commands in the source code leads to a bad testability. You are restricted in the selection of test tools and test benches.

The use of implementation specific source code requires the use of a special make tool and linker.

The use of hard coded constant values in the source code leads to the decrease of maintainability.

The use of hard coded constant values in the source code leads to the decrease of visibility in the debugger.

	The additional hardware dimension in a project defers the attention from software design issues.
	There is a need for global variables because of debugging and measurement.
	The software engineers follow outdated design rules.
	The tools like compilers, debuggers and emulators usually have a poor quality.
	Microcontrollers are very hard to program.
	The aim is to save RAM and ROM because this costs money in each unit which is sold. A good design is considered to generate overhead and thus additional costs.

	The use of global variables may lead to cross influences by deliberate access across modules.
	The use of global variables may lead to errors due to the change of linkage according to the ISO C rules.
	The use of global variables may lead to increased ROM consumption because the compiler generates additional debug code.
	The use of global variables requires explicit initialisation of the variables.
	The use of global variables will lead to a data flow which is scattered over multiple functions and modules. This means that maintainability and testability is very poor. Small modifications lead to a different data flow and possible data error.
	Global variables are hard to debug because the break points in the debugger can not be set on lines where they are used.
	The use of global variables tends to generate functions defined as void - void. This means that maintainability and testability is reduced.

	The use of implementation (compiler / CPU) specific commands in the source code leads to the loss of portability.
	The use of implementation (compiler / CPU) specific commands in the source code leads to a bad testability. You are restricted in the selection of test tools and test benches.
	The use of implementation specific source code requires the use of a special make tool and linker.
	The use of hard coded constant values in the source code leads to the decrease of maintainability.
	The use of hard coded constant values in the source code leads to the decrease of visibility in the debugger.