J.-M Friedt. FEMTO-ST/département temps-fréquence. transparents à jmfriedt.free.fr. 19 janvier 2015

Dimension: px

Commencer à balayer dès la page:

Download "J.-M Friedt. FEMTO-ST/département temps-fréquence. jmfriedt@femto-st.fr. transparents à jmfriedt.free.fr. 19 janvier 2015"

Huguette Carignan
il y a 8 ans
Total affichages :

1 Informatique FEMTO-ST/département temps-fréquence transparents à jmfriedt.free.fr 19 janvier / 15

2 16 séances Plan des cours 1 C pour microcontroleurs : volatile, tailles de variables, optimisations, C v.s asm, acces aux registres, *(type*)addr=val ;, interruptions, timer, péripheriques d un uc application aux périphériques matériels & interruptions (TP STM32 bare metal) 2 exploitation de bibliothèques, et en particulier libc création de sa toolchain ARM Cortex M3, newlib pour STM32 (stubs) 3 traitement du signal sur microcontrôleur filtre acquisition périodique, conception de FIR sur microcontrôleur 4 loi de commande en temps discret PID sur microcontrôleur 5 FreeRTOS, RTEMS, environnements executifs, TinyOS FreeRTOS/RTEMS sur STM32, émulateur de STM32 sur PC (qemu) 6 buildroot pour A13 GNU/Linux sur un systeme embarque, exploitation du meme programme sur A13 et PC, aspects utilisateur 7 unix sur système embarqué, aspects communication sur réseau IP, endianness TP TCP/IP sur Coldfire 8 unix sur système embarqué, aspects développeur, accès au matériel module noyau Linux sur A13 2 / 15

bibliothèques, et en particulier libc création de sa toolchain ARM Cortex M3, newlib pour STM32 (stubs) 3 traitement du signal sur microcontrôleur filtre acquisition périodique, conception de FIR sur

3 1 passage du C au langage machine 2 conséquences du compilateur : les options d optimisation font varier le temps d exécution 3 spécificités du développement sur système à ressources réduites : pas d allocation dynamique de mémoire, processus monolithique unique 4 instruction pour contrôler les optimisations 5 variables globales et goto 3 / 15

système à ressources réduites : pas d allocation dynamique de mémoire, processus

4 Passage du C au langage machine 1 étapes du compilateur : préprocesseur, assembleur, compilateur, éditeur de liens (linker) 2 gcc est un frontend pour appeler le préprocesseur (cpp, gcc -E), le compilateur (cc1, gcc -s), l assembleur (as, gcc -c) et le linker (ld) 3 séquence de compilation se découvre par gcc -v 4 / 15

appeler le préprocesseur (cpp, gcc -E), le compilateur (cc1, gcc -s), l

5 Séquence de compilation Comment passer de ce programme en C à une suite d opcodes compréhensibles par un processeur? #i n c l u d e <math. h> #d e f i n e i i n i t 3 i n t main ( ) { v o l a t i l e i n t i= i i n i t ; i=i +1; } 5 / 15

6 gcc -E... e x t e r n d o u b l e a s i n ( d o u b l e x ) a t t r i b u t e ( ( n o t h r o w, l e a f ) ) ; e x t e r n d o u b l e a s i n ( d o u b l e x ) a t t r i b u t e ( ( n o t h r o w, l e a f ) ) ; e x t e r n d o u b l e atan ( d o u b l e x ) a t t r i b u t e ( ( n o t h r o w, l e a f ) ) ; e x t e r n d o u b l e a t a n ( d o u b l e x ) a t t r i b u t e ( ( n o t h r o w, l e a f ) ) ;... s t r u c t e x c e p t i o n { i n t t y p e ; c h a r name ; d o u b l e arg1 ; d o u b l e arg2 ; d o u b l e r e t v a l ; } ;... i n t main ( ) { v o l a t i l e i n t i =3; i=i +1; } 6 / 15

) a t t r i b u t e ( ( n o t h r o w, l e a f ) ) ; e x t e r n d o u b l e atan ( d o u b l e x ) a t t r i b u t e ( ( n o t h r o w, l e a f ) ) ; e

7 gcc -S. f i l e "t.c". t e x t. g l o b l main. t y p e f u n c t i o n main :. LFB0 :. c f i s t a r t p r o c p u s h l %ebp. c f i d e f c f a o f f s e t 8. c f i o f f s e t 5, 8 movl %esp, %ebp. c f i d e f c f a r e g i s t e r 5 s u b l $16, %esp movl $3, 4(%ebp ) movl 4(%ebp ), %eax a d d l $1, %eax movl %eax, 4(%ebp ) l e a v e. c f i r e s t o r e 5. c f i d e f c f a 4, 4 r e t. c f i e n d p r o c. LFE0 :. s i z e main,. main. i d e n t " GCC : ( Debian ) ". s e c t i o n. note. GNU s t a c k, p r o g b i t s 7 / 15

c f i d e f c f a r e g i s t e r 5 s u b l $16, %esp movl $3, 4(%ebp ) movl 4(%ebp ), %eax a d d l $1, %eax movl %eax, 4(%ebp ) l e a v e.

8 objdump -dst < i n i t >: : 53 push %ebx : 83 ec 08 sub $0x8,% esp : e c a l l < x86. get pc thunk. bx> d : 81 c3 d add $0x13d7,% ebx : 8b 83 fc f f f f f f mov 0x4(%ebx ),% eax : 85 c0 test %eax,% eax b : je < i n i t+0x1e> d : e8 1e c a l l 80482b0 < gmon plt> : 83 c4 08 add $0x8,% esp : 5b pop %ebx : c3 r e t... i n t main ( ) { v o l a t i l e i n t i= i i n i t ; cb : 55 push %ebp 80483cc : 89 e5 mov %esp,%ebp ce : 83 ec 10 sub $0x10,% esp 80483d1 : c7 45 fc movl $0x3, 0x4(%ebp ) i=i +1; 80483d8 : 8b 45 fc mov 0x4(%ebp ),% eax 80483db : 83 c0 01 add $0x1,% eax de : f c mov %eax, 0x4(%ebp ) e1 : c9 l e a v e e2 : c3 r e t } Obtention de la séquence d opcodes et d arguments en mémoire du microcontrôleur Noter que cette dernière étape est possible même si nous ne possédons que le binaire exécutable 8 / 15

c a l l 80482b0 < gmon start @ plt> 8048292: 83 c4 08 add $0x8,% esp 8048295: 5b pop %ebx 8048296: c3 r e t.

9 Optimisations du code C Taille des variables (unsigned) char : 8 bits (unsigned) short : 16 bits (unsigned) int : 32 bits (unsigned long long) : 64 bits les nombres à virgule flottante simple précision float et double précision double Utiliser le type présentant le meilleur compromis espace/précision des données (analyse rationnelle) 9 / 15

shtm (unsigned long long) : 64 bits les nombres à virgule flottante simple précision float et

10 Optimisations de gcc -O0 Barely any transformations are done to the code, just code generation. At this level, the target code can be debugged with no loss of information. -O1 Some transformations that preserve execution ordering. Debuggability of the generated code is hardly affected. User variables should not disappear and function inlining is not done. -O2 More aggressive transformations that may affect execution ordering and usually provide faster code. Debuggability may be somewhat compromised by disappearing user variables and function bodies. -O3 Very aggressive transformations that may or may not provide better code. Some semantics may be modified (particularly floating point). Order of execution completely distorted. Debuggability is seriously -Os compromised. Optimize for size. This option enables transformations that reduce the size of the generated code. Ironically, this may sometimes improve application performance because there simply is less code to execute. This may lead to reduced memory footprints which may produce fewer page faults. 10 / 15

User variables should not disappear and function inlining is not done. -O2 More aggressive transformations that may affect execution ordering and usually provide faster code.

11 Allocation de mémoire 1 on connait l espace mémoire occupé 2 pas de multi-processus pas de ressources distribuées 3 passage de paramètres par pointeur et non par valeur 4 Pour le C, la mémoire est un ensemble d octets qui se manipule par les pointeurs 5 *(type *)(adresse)=valeur; (interdit sur les architectures à MMU) char c[4]={0x12,0x34,0x45,0x56}; short *s; int *i; s=(short*)c; printf("%x",s[1]); // 5645 i=(int*)c; printf("%x",i[0]); // / 15

manipule par les pointeurs 5 *(type *)(adresse)=valeur; (interdit sur les architectures à MMU) char

12 Conséquence du passage de paramètres Gain de place et de temps #include <stdio.h> #include <stdlib.h> #include <time.h> struct matrice {int reel[1024*1024];} toto1; void fonction(struct matrice *a) {a->reel[1]=a->reel[1]+1;} // ici void fonction2(struct matrice a) {a.reel[1]=a.reel[1]+1;} // ici 2 int main() {time_t t1,t2,t3; int k; toto1.reel[1]=1; // ici 1 time(&t1); for (k=0;k<1000;k++) fonction(&toto1); time(&t2); for (k=0;k<1000;k++) fonction2(toto1); time(&t3); printf("t1=%d t2=%d\r\n",t2-t1,t3-t2); // t1=0 t2=16 } 12 / 15

$.1001 void fonction2(struct matrice a) {a.reel[1]=a.reel[1]+1;} // ici 2 int main() {time_t t1,t2,t3; int k; toto1.$

13 volatile 1 instruction pour interdire au compilateur de faire des hypothèses sur une variable 2 sans cette instruction, le compilateur se permet d éliminer le code inutile Exemple : dans /usr/lib/avr/include/avr/sfr defs.h #define _MMIO_BYTE(mem_addr) (*(volatile uint8_t *)(mem_addr)) #define _MMIO_WORD(mem_addr) (*(volatile uint16_t *)(mem_addr)) #define _MMIO_DWORD(mem_addr) (*(volatile uint32_t *)(mem_addr))... #define _SFR_IO8(io_addr) _MMIO_BYTE((io_addr) + SFR_OFFSET) et dans /usr/lib/avr/include/avr/iom32u4.h (définition du Atmega 32U4) #define PINB _SFR_IO8(0x03) #define PINB #define DDRB _SFR_IO8(0x04) #define DDB0 0 #define DDB / 15

h #define _MMIO_BYTE(mem_addr) (*(volatile uint8_t *)(mem_addr)) #define _MMIO_WORD(mem_addr) (*(volatile uint16_t *)(mem_addr)) #define _MMIO_DWORD(mem_addr)

14 volatile Si on optimise sans volatile... il ne reste rien! Dans les deux cas : msp430-gcc -O2 -mmcu=msp430x149 -D GNU ASSEMBLER -S int main() {volatile unsigned short j=3,k; for (k=0;k<15;k++) {j+=k;} } mov #( stack-4), r1 /* prologue end (size=2) */ mov mov #llo(0), 2(r1) cmp #llo(15), 2(r1) jhs.l8.l6: add add #llo(1), 2(r1) cmp #llo(15), 2(r1) jlo.l6.l8: int main() {unsigned short j=3,k; for (k=0;k<15;k++) {j+=k;} } main: mov #( stack-0), r1 /* prologue end (size=2) */ /* epilogue: frame size=0 */ br # stop_progexec 14 / 15

{j+=k;} } mov #( stack-4), r1 /* prologue end (size=2) */ mov #llo(3), @r1 mov #llo(0), 2(r1) cmp #llo(15), 2(r1) jhs.l8.

15 Exploitation du STM32 : Mise en pratique mise en œuvre de la chaîne de compilation (arm-...-gcc) et des outils pour configurer le microcontrôleur accès aux périphériques spécificités du STM32 : granularité de la configuration des horloges datasheet... manuel du cœur 1 et du processeur manual/cd pdf 2. document/datasheet/cd pdf 15 / 15

la configuration des horloges datasheet... manuel du cœur 1 et du processeur 2 1. http://www.st.

Documents pareils

Structure d un programme

Architecture des ordinateurs Cours 6 Structure d un programme 3 décembre 2012 Archi 1/30 Programme en Assembleur Archi 2/30 Sections de données programme en assembleur = fichier texte (extension.asm) organisé