Infotronik

Explain reasons why we used a Shell in INTRO:

In INTRO we implemented an 'Events' driver.

• (a) Why did we implement it as an array of bits?
• (b) What is the fundamental disadvantage of such an array of bits?
• (c) It implements critical section (e.g. to set an event bit) with EnterCritical() and ExitCritical(). Under which conditions such a critical section would not be required?
• (d) List reasons why an interrupt service routine should use such an Event module:

An RTOS can be either preemptive or cooperative: Explain the difference:

In an RTOS, each task can be in one of 5 fundamental states: List them:

What's the purpose of the scheduler in an RTOS?

Provide a short definition of the term Interrupt Latency, and which factors/aspects are contributing to it:

Provide an example of a typical Reactive System, and explain why this is a reactive system:

A PWM signal on a H-Bridge is labeled as low active. Explain what this means and how this impacts the speed of a DC motor?

Given the following program:

#define ADC_CONFIG (*(volatile uint8_t*) 0x123 )

static void Interrupt (void) {
   uint8_t i ;
   while (ADC_CONFIG & ~0x10 ) ;
   for(i =0; i <10; i++) {
      __asm( "nop" ) ;
   }
}


This program is using

Your Eclipse project stores the make files, object files and the final (binary) application file in a sub folder inside your project. Are you going to store this folder and files in a version control system? Justify your answer:

Processor Expert components are using the concept of Methods, Properties and Events. What would you expect for an ADC (Analog to Digital Converter) component?
(a) 2 typical Methods for an ADC component
(b) 2 typical Properties for of an ADC component:
(c) 2 typical Events for an ADC component:

Given following variable definition:

static char *string = "hello";

What is the difference between the two following usages

• sizeof(string)
• strlen(string)

In respect to the result and the expected code generated?

Given following interface implementation for a DC motor driver:

/* motor . h */

#include "LED. h" /* LED i n t e r f a c e */
#include "PWM. h" /* PWM i n t e r f a c e */

static uint16_t MOT_motorSpeed ;

void MOT_Init (void);

/* end o f motor . h */

Identify three issues with such an interface implementation (issues which could lead to linker/compiler failure, or things which are not considered as good programming style):

Write in C code a single statement which only sets bit number 0 in variable var and let the other bits untouched (bit number 0 is the LSB):

Provide an example of a typical Transforming System, and explain why this is a Transforming System:

Explain why Optimized Memory Usage is a typical attribute for a Transforming System:

Explain the reason why some processors push all their core registers onto the interrupt stack, and some only push a subset of the registers:

What does it mean, if somebody says "I have masked the interrupts"?

Explain multiple things which affects the interrupt latency time.

List the things a processor has to do in order to jump to an interrupt service routine and to return from it.

List reasons, why a company would not allow any interrupt synchronization methods:

Does the ARM Cortex-M0+ support nested interrupts?

What does it mean: the ARM Cortex M0+ supports nested interrupts?

Answer the questions for following C code, assuming default compiler settings:

typedef signed short MyType;
static unsigned char myVar[3];
typedef enum { RED=5, GREEN, YELLOW } Color s ;

(a) What gives sizeof(MyType) for the tinyK20/Remote board/project:
(b) What gives sizeof(MyType) for the Robot board/project?
(c) What gives sizeof(MyVar) for the tinyK20/Remote board/project?
(d) What gives sizeof(MyVar) for the Robot board/project?
(e) Which value has YELLOW?

Given following source code:

uint16_t abcd [16];
uint8_t buf [10];
static uint16_t values [3];

(a) Determine the value of following expression:

• sizeof("abcd")

(b) Determine the value of following expression:

• sizeof(buf)

(c) Determine the value of following expression:

• sizeof(values)