1-intro-struct-circular-buffer

(1)

ELT048 – Embedded

Operational Systems

Rodrigo Maximiano Antunes de Almeida

rmaalmeida@gmail.com @rmaalmeida

(2)

The work ”Embedded System Design: From Electronics to Microkernel Development” of Rodrigo Maximiano Antunes de Almeida was licensed with Creative Commons 3.0 – Attribution – Non Commercial – Share Alike

license.

Additional permission can be given by the author through direct contact using the e-mail: rmaalmeida@gmail.com

(3)

(4)

U N I F E I U N I F E I

Initial comments

• _Classes  _{Wed 7:00 to 9:30}  _{LEC II}  _{1st Test 13/09}  _{2nd Test 08/11}

(5)

U N I F E I

Embedded OS

(6)

U N I F E I

(7)

U N I F E I

(8)

U N I F E I

(9)

U N I F E I

(10)

U N I F E I

(11)

U N I F E I U N I F E I

KL02

• _{MKL02Z32CAF4RTR} -ND  _{32K flash}  _{4k ram}  _US$1,76

(12)

U N I F E I U N I F E I

Schedule

• _{01) Intro / Pointers /} Buffers • _{02) void and} function pointers • _{03) Tasks} • _{04) Cooperative} kernel • _{05) Timing} requirements • _{06) Drivers} • _{08) Drivers} Controller • _{09) Callbacks} • _{10) Preemptive} Kernel, scheduler • _{11) Real time} • _{12) Mutex &} Semaphores • _{13) Message Prsing}

(13)

U N I F E I

void main (void){

//variable declaration kernel_project(1); //initialization concepts(2); //hard-work microkernel(3); device_driver_controller(4); }

(14)

void kernel_project (float i){ what_is_a_kernel(1.1); alternatives(1.2); monolithic_vs_microkernel(1.3); kernel_design_decisions(1.4); this_course_decisions(1.5); }

(15)

U N I F E I

kernel_project

(

1 );

(16)

U N I F E I

(17)

U N I F E I

kernel_project

(

1 );

• _{Kernel tasks:}

1. Manage and coordinate the processes execution using “some criteria”

2. Manage the free memory and coordinate the processes access to it

3. Intermediate the communication between the hardware drivers and the processes

(18)

U N I F E I U N I F E I I/O CPU Memory Kernel Drivers Extra libs

File system Context switch GUI

C/C++

libraries

Interface

actions System logic

Internal routines

kernel_project

(

1 );

(19)

kernel_project

(

1 );

Develop my own kernel?

Why?

(20)

U N I F E I

kernel_project

(

1 );

• _{Improve home design}

• _{Reuse code more efficiently}

• _{Full control over the source}

• _{Specific tweeks to the kernel}

 _{Faster context switch routine}

(21)

kernel_project

(

1 );

Develop my own kernel?

Why

not

?

(22)

U N I F E I

kernel_project

(

1 );

• _{Kernel overhead (both in time and}

memory)

• _{Free and paid alternatives}

• _{Time intensive project}

(23)

U N I F E I

Kernel Project

• _{Source code size (millions of lines)}  FreeBSD – 8.8  _{IOS – 80}  _{Linux (2.6.0) – 5.2}  _{Linux (3.6) – 15.9}  _{Debian 7.0 – 419}  _{Mac OS X 10.4 – 86}  _{OpenSolaris – 9.7}  _{Windows NT – 11}  _{Windows XP – 45}  _{Windows Vista – 66}

(24)

U N I F E I

kernel_project

(

1 );

• _Alternatives

 _{Windows Embedded Compact®}  _VxWorks®

 _{X RTOS®}  _uClinux  _FreeRTOS  _BRTOS

(25)

U N I F E I

kernel_project

(

1 );



Monolithic kernel versus microkernel

(26)

U N I F E I

kernel_project

(

1 );

• _{Kernel design decisions}

 _{I/O devices management}  _{Process management}

(27)

U N I F E I U N I F E I

kernel_project

(

1 );

• _{Our decisions:}  _Microkernel  _{Non-preemptive}  _Cooperative  _{No memory management}

 _{Process scheduled based on timer}  _{Isolate drivers using a controller}

(28)

U N I F E I

Practical Activities

• _Boards

 _{NEO201 – Pic18f4550}

 _{LPCxpresso base board – LPC1100}

• _{Development environment}

 _MPLABX  _Eclipse

(29)

void concepts (float i){ pointers(2.1); structs(2.2); circular_buffers(2.3); temporal_conditions(2.4); void_pointers(2.5); }

(30)

U N I F E I

concepts

(

2 );

(31)

U N I F E I

Pointers

(32)

U N I F E I

Pointers

• _{They are variables that store the address}

(location) of memory.

 In these memory addresses it is possible to enter values.

• _{The type of the value placed in the memory}

pointed by the address is defined in the declaration of the pointer.

 The type that tells the compiler how much memory is needed to store the values.

• _{A pointer variable points to a variable of a}

(33)

U N I F E I U N I F E I

Pointers

• _{It is necessary in} the declaration of a pointer, to

specify for which type of variable it will point.

• _{Pointers are}

declared with a * before the variable name.

• _Sintax:

• _type

(34)

U N I F E I U N I F E I int *aux; float *temp; char *pont;

Pointers

• _{aux, temp, and pont}

are variables that store memory

addresses and not variable of the types int, float, or char.

• * is used when you want to access the value that is in the memory location and not the memory

(35)

U N I F E I

(36)

U N I F E I

Pointers

• _{Operator &:}

 _{Always gets the}

address of a variable  _{Since pointers are}

also variables, they also occupy memory.  _{You can get the}

pointer address and have pointers to

pointers (multiples *).

• _{Operator *:}

 _{The * operator}

does the opposite of the & operator.

 _{Given a pointer,}

the * operator accesses the

content pointed to by it.

(37)

U N I F E I

Ponteiros

• _{Operator &:}

 _{“get the address}

of”  _{“saved in”} • _{Operator *:}  _{“dereference”}  _{“through”}  _{“pointed by”}

(38)

U N I F E I

Pointers

#include <stdio.h>

int main(int argc, char *argv[]){

int x=10;

int *p1=&x; //ponteiro para um inteiro

printf("x = %d\n\n", x); *p1=20; //ou p1[0]=20; printf("p1 = %u\n", p1); printf("x = %d\n", x); printf("*p1 = %d\n", *p1); printf("p1[0] = %d\n\n", p1[0]); return 0; } //end main

(39)

U N I F E I

Parameter passing

• _{C-language functions can receive}

multiple parameters and can return one.

• _{The method of sending the parameters}

can be done through the stack or through registers.

• _{The stack allows several parameters to}

be passed at once

• _{The registers have a lower overhead,}

therefore being faster and with smaller code size

(40)

U N I F E I

Parameter passing

• _{When sending, the parameters are}

copied to a temporary variable, so that

changes in its value are lost after the end of the function.

• _{The initial variable is not changed}

• _{To avoid this situation it is common to}

pass the parameter by reference.

• _{When passing by reference, the address}

of the variable is passed instead the

value. Therefore the function can change the value of the original variable.

(41)

U N I F E I

void incrementa(int a){ a += 1;

}

int main(int argc, char *argv[]){ int x = 10;

incrementa(x); return 0;

}

(42)

U N I F E I

void main(void){ int x = 10; incrementa(x);

return 0; }

void incrementa(int a){ a+=1;

return; }

(43)

U N I F E I

void main(void) {

int x = 10; inc(x);

return 0; }

void inc(int a){ a += 1;

return; }

Rotina Principal Função Variáveis

(44)

U N I F E I

x=10 a=10

int x = 10; inc(x);

return 0; }

void inc(int a){ a += 1;

return; }

(45)

U N I F E I

x=10 a=11

int x = 10; inc(x);

return 0; }

void inc(int a){ a += 1;

return; }

(46)

U N I F E I

x=10 descartado

int x = 10; inc(x);

return 0; }

void inc(int a){ a += 1;

return; }

(47)

U N I F E I

void incrementaptr(int* a){ (*a) += 1;

}

int main(int argc, char *argv[]){ int x = 10;

incrementaptr(&x); return 0;

(48)

U N I F E I

void main(void) { int x = 10; incptr(&x); return 0; } void incptr (int* a){ (*a) += 1; return; }

(49)

U N I F E I

x=10 temp=&x

(50)

U N I F E I

x=10 a=&x

(51)

U N I F E I

x=11 a=&x

*

(52)

U N I F E I

x=11 descartado

(53)

U N I F E I

Parameter passing

• _{Passing parameters by reference allows a}

function to "return" more than one parameter at a time.

• _{This is done by passing a variable via}

reference so that the function can write to it.

(54)

U N I F E I

//a e b são dados de entrada //d e r são dados de saída

void div(int a, int b, int* d, int* r){ (*d) = a / b;

(*r) = a % b; return;

}

void main(void){ int d, r;

div(10, 3, &d, &r); //d = 3 e r = 1;

return; }

(55)

U N I F E I

concepts

(

2 );

(56)

U N I F E I

concepts

(

2 );

// struct declaration

typedef struct{

unsigned short int age; char name[51];

float weight; }people;

• _{Structs are composed variables.}

• _{Group lots of information as if they were}

one single variable.

• _{A vector that each position stores a}

(57)

U N I F E I

void main(void){

struct people myself = {26, "Rodrigo", 70.5};

myself.age = 27;

//using each variable from the struct

printf("Age: %d\n", myself.age);

printf("Name: %s\n", myself.name);

printf("Weight: %f\n", myself.weight); return 0;

}

(58)

// struct declaration

typedef struct{

unsigned short int *age;

char *name[51];

float *weight;

}people;

void main(void){

struct people myself = {26, "Rodrigo", 70.5};

//using each variable from the struct

printf("Age: %d\n", myself->age);

printf("Name: %s\n", myself->name);

printf("Weight: %f\n", myself->weight);

return 0;

}

(59)

U N I F E I U N I F E I typedef struct{ char nome[20]; int idade; }t_aluno; t_aluno *a1; (*a1).nome = "Joao"; (*a1).idade = 18; a1->nome = "Joao"; a1->idade = 18;

Structs

• _{The access of the}

internal members of structures, pointed by pointers, can actually be done through the operator ->

(60)

U N I F E I

concepts

(

2 );

(61)

U N I F E I

concepts

(

2 );

• _{Circular Buffers}

 _{“Endless” memory spaces}  _{Use FIFO aproach}

 _{Store temporary data}

(62)

U N I F E I

concepts

(

2 );

• _{Vector implementation}

 _{Uses less space}

 _{Need special caution when cycling}

(63)

[0]

[1]

[2]

[3]

[4]

(64)

[0] [1] [2] [3] [4] fim=0

ini=0

? ? ? ? ?

(65)

[0] [1] [2] [3] [4] fim=2

ini=0

'A'

'B'

? ? ?

(66)

[0] [1] [2] [3] [4] fim=2

ini=1

'A'

'B'

? ? ?

(67)

[0] [1] [2] [3] [4] fim=4

ini=1

'A'

'B'

'C'

'D'

?

(68)

[0] [1] [2] [3] [4] fim=0

ini=1

'A'

'B'

'C'

'D'

'E'

(69)

U N I F E I

#define CB_SIZE 10

int circular_buffer[CB_SIZE]; int index=0;

for(;;){

//do anything with the buffer

circular_buffer[index] = index;

//increment the index

index = (index+1)%CB_SIZE; }

(70)

concepts

(

2 );

#define CB_SIZE 10

int circular_buffer[CB_SIZE]; int start=0, end=0;

char AddBuff(int newData) {

//check if there is space to add a number

if ( ((end+1)%CB_SIZE) != start)

{

circular_buffer[end] = newData;

end = (end+1)%CB_SIZE;

return SUCCESS;

}

return FAIL; }

(71)

U N I F E I

Exercise

• _{Implement a circular buffer}

 _{Use a 10-position vector}

• _{Each element of the vector is a structure}

with two variables

 _{char * ProcessName}  _{int Time}

• _{Create one function to add new elements}