1-intro-pointers-struct

(1)

ELT048 – Embedded

Operational Systems

Rodrigo Maximiano Antunes de Almeida

(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: [email protected]

(3)

(4)

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

Initial comments

• _Classes  _{Mon 7:55 to 9:45 – B4.2.06}  _{Mon 13:30(P1) 15:45 (P2) - LEC II}  _{1st Test 20/04}  _{2nd Test 08/06}  _{Sub. Test 22/06}

(5)

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

Schedule

1. Intro / Pointers / Buffers

2. Function pointers / tasks / kernel

3. Scheduler / Cooperative kernel / priorities (RMS)

4. Timing requirements

5. Drivers

6. Drivers Controller

7. 1st Test

8. Preemptive Kernel, scheduler

9. FreeRTOS

10.Heap Memory

11.Task Management

12.Queues

13.Resource Management

14.*Soft Timers & Int

15.2nd Test

(6)

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

Labs Schedules

• _{L1 – Circular buffer & function pointers} • _{L2 – Kernel + Priorities} • _{L3 – Kernel + Timing} • _{L4 – Drivers} • _{L5 – FreeRTOS} • _{L6 – Tasks Management} • _{L7 – Queues}

(7)

Fast Intro

(8)

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

Embedded OS

(9)

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

(10)

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

(11)

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

(12)

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

(13)

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

(14)

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

KL02

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

(15)

(16)

What is a

kernel?

(17)

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

(18)

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

What is a kernel?

• _{Kernel tasks:}

 _{Manage and coordinate the processes}

execution using “some criteria”

 _{Manage the free memory and coordinate the}

processes access to it

 _{Intermediate the communication between}

(19)

I/O CPU Memory Kernel Drivers Extra libs

File system Context switch GUI

C/C++

libraries

Interface

actions System logic

Internal routines

(20)

Develop my

own kernel?

(21)

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

Develop my own kernel?

• _{Improve home design}

• _{Reuse code more efficiently} • _{Full control over the source} • _{Specific tweeks to the kernel}

 _{Faster context switch routine}

(22)

Develop my

own kernel?

(23)

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

Develop my own kernel?

• _{Kernel overhead (both in time and}

memory)

• _{Free and paid alternatives} • _{Time intensive project}

(24)

U N I F E I 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}

(25)

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

Develop my own kernel?

• _Alternatives

 _{Windows Embedded Compact®}  _VxWorks®

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

(26)

Programming

concepts

(27)

Pointers

(28)

U N I F E I 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} certain type (char, int, float, double, ...).

(29)

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

(30)

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

(31)

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

(32)

U N I F E I 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.

(33)

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

Pointers

• _{Operator &:}

 _{“get the address}

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

(34)

#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 Pointers

(35)

U N I F E I 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

(36)

U N I F E I 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.

(37)

U N I F E I 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;

}

(38)

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

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

return 0; }

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

return; }

(39)

U N I F E I 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

(40)

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

x=10 temp=10

int x = 10; inc(x);

return 0; }

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

return; }

(41)

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

x=10 a=10

int x = 10; inc(x);

return 0; }

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

return; }

(42)

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

x=10 a=11

int x = 10; inc(x);

return 0; }

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

return; }

(43)

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

x=10 descartado

int x = 10; inc(x);

return 0; }

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

return; }

(44)

U N I F E I 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;

(45)

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

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

(46)

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

x=10 temp=&x

(47)

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

x=10 a=&x

(48)

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

x=11 a=&x

*

(49)

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

x=11 descartado

(50)

U N I F E I 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.

(51)

U N I F E I 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;

(52)

(53)

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

// struct declaration

typedef struct{

unsigned short int age; char name[51];

float weight; }people;

Structs

• _{Structs are composed variables.}

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

one single variable.

• _{A vector that each position stores a}

(54)

Structs

void main(void){

people someone = {26, "Name", 70.5};

someone.age = 27;

//using each variable from the struct

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

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

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

(55)

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

Structs

• _{The access of the}

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

(56)

void main(void){

int dado = 10;

t_aluno aluno = {"Nome",17,&dado};

t_aluno *a1;

a1 = &aluno;

(*a1).idade = 18;

printf("Age: %d\n", (*a1).idade);

a1->idade = 19;

printf("Age: %d\n", a1->idade); *(aluno.p_dado) = 11;

printf("dado: %d\n", dado); //aluno->p_dado = 12; //erro

//printf("dado: %d\n", dado); *((*a1).p_dado) = 12;

printf("dado: %d\n", dado); *(a1->p_dado) = 13;

printf("dado: %d\n", dado);

return 0; }