SISTEMAS EMBEBIDOS
Unidad 1.2 – Desarrollo de software embebido
Photo by Tim Simpson
Herramientas de desarrollo
Conceptos (repaso):
Tool chain
Herramientas (compilador, ensamblador, etc.) compatibles
Herramientas nativas (native tools)
Crea programas que corren en la computadora que se compila
Host (donde se desarrolla) vs. target (destino)
“Compilador cruzado” (cross-compiler)
Compilador en host produce instrucciones binarias target
Instituto San Antonio de Padua
Sistemas embebidos Página 2
Proceso de creación y cargado:
programa de aplicación de escritorio
Loader
Object Files
Compiler
Compiler Executable
Image File
Read-Write
L L Memory (RAM)
in o
Linker
Assembler
Assembler k a
er d
er
Run-Time Library:
Boot
Boot
Operating System Image: Process
Proces
s
Fuente: Daniel W. Lewis, “Fundamentals of Embedded Software”
Instituto San Antonio de Padua
Sistemas embebidos Página 3
Compilador
Traduce código fuente en lenguaje C a instrucciones de máquina
generando un archivo objeto
main.c main.obj
int aux1,aux2; …
… MOVE R1,(aux1)
aux2 = Compilador CALL fun1
fun1(aux1); …
…
Instituto San Antonio de Padua
Sistemas embebidos Página 4
Enlazador (Linker)
El linker “junta” todos los archivos, resolviendo las referencias
entres los archivos
Determina las direcciones de las etiquetas que el compilador no pudo
resolver
Por ejemplo: funciones y variables externas (extern) definidas en
otros archivos
prog..exe
main.obj
…
…
MOVE R1,2388
MOVE R1,(aux1)
CALL 1547
CALL fun1 …
… auxiliares.obj Linker …
… …
fun1: 1547 [inicio fun1]
… …
2388 [valor de aux]
…
Instituto San Antonio de Padua
Sistemas embebidos Página 5
Loader
El loader debe ajustar las direcciones de memoria absolutas del
código y de los datos en función de la dirección de base
Obs.: cada vez pude ser cargado en diferentes regiones de memoria
prog..exe
…
MOVE R1,2388
CALL 1547
…
… Memoria
Loader
…
1547 MOVE R1, R5
… 21547
2388 [valor de aux]
… 22388
Instituto San Antonio de Padua
Sistemas embebidos Página 6
Loader
No necesitan ajustes:
Las direcciones relativas al PC en sistemas con memoria virtual
prog..exe
…
MOVE R1,2388
CALL 1547
…
… Memoria
Loader
…
1547 MOVE R1, R5
… 21547
2388 [valor de aux]
… 22388
Instituto San Antonio de Padua
Sistemas embebidos Página 7
Proceso de creación y cargado:
programa de aplicación embebido
Object Files
Read-Write
Memory
Read-Write
Cross-
Cross- (RAM)
Memory
Compiler
Compiler Executable ROM
(RAM)
Image File Image File
Locator
Cross-
Cross- L
Assembler
Assembler o
c
Linker
a
tr o
Re-Entrant Library:
L Read-Only
in Memory
Read-Only
k ROM (ROM)
er Memory
Real-Time Kernel: ROM
"Burner" (ROM)
"Burner"
tos básicos Sistemas embebidos de tiempo
Fuente: real“Fundamentals of Embedded Software”
Daniel W. Lewis,
Instituto San Antonio de Padua
Sistemas embebidos Página 8
(No) Portabilidad de binarios
Intrínseco de la compilación a código máquina (directam. exec.):
Compiladores nativos y compiladores-cruzados
Ejemplo de compilador nativo:
Pensar que un programa en C compila con en una plataforma (HW,
SO)...
¿Qué problemas se tienen al cambiar de plataforma?
Ejemplo de compiladores-cruzados:
Pensar que se compila para un microcontrolador dado...
¿Qué problemas se tienen al cambiar de microcontrolador?
Instituto San Antonio de Padua
Sistemas embebidos Página 9
Locator
Funcionalidad muy distinta a la del loader
Determina la imagen final en memoria del programa
No existe un proceso similar al correspondiente del loader
Es posible crear la imagen final porque:
Es el único programa en memoria, no existen conflictos por recursos
Es posible determinar la dirección final de todo, incluyendo el kernel (si lo
hubiera) y las funciones de biblioteca
Es posible indicar la ubicación en memoria
Datos, código
RAM, ROM
Instituto San Antonio de Padua
Sistemas embebidos Página 10
Ubicación en memoria
Tener en cuenta:
Datos persistentes necesitan estar en NVM (non-volatile memory)
Datos modificables necesitan estar en RAM
¿Como sabe el linker/locator dónde poner cada cosa?
El programa se organiza en segmentos que son tratados independientemente
Segmentos
Compilador: crea entidades lógicas conteniendo código o datos
Linker: agrupa segmentos de diferentes códigos objeto
Locator: mapea los segmentos en una ubicación física de memoria
Ejemplo de categorías:
CODE
XDATA
Instituto San Antonio de Padua
Sistemas embebidos Página 11
Inicialización de datos
Requerimientos:
Valor inicial (persistente entre reset) → ROM o Flash
Variable (modificable en ejecución) → RAM
Problema:
Valor inicial debe ser copiado en el arranque
Solución:
¿Cómo?
Copiar segmentos “shadow” (con los valores iniciales) de ROM a RAM (más
adelante ejemplo)
¿Quién?
Startup code (código de arranque) ejecutado antes del “main”
Instituto San Antonio de Padua
Sistemas embebidos Página 12
Inicialización de datos (2)
El estándar C especifica:
Variables estáticas (non-stack) no inicializadas se inicializan en cero
Requerimientos:
Variable (modificable en ejecución) → RAM
Valor inicial → cero
Solución:
Se realiza un memset (a cero)
Startup code incluye esa rutina
Instituto San Antonio de Padua
Sistemas embebidos Página 13
Ejemplo
x.c y.c z.asm Módulos:
x.c
cross- cross- cross-
compiler compiler assembler Instrucciones
x.obj y.obj z.obj Datos sin inicializar
Constantes strings
y.c
Instrucciones
Datos inicializados y sin
inicializar
z.asm
Funciones en asm
Datos sin inicializar
“Startup-code”
Instituto San Antonio de Padua
Sistemas embebidos Página 14
Ejemplo
x.c y.c z.asm
Cross-compiler
cross- cross- cross-
Divide archivo fuente en
compiler compiler assembler segmentos
x.obj y.obj y.c z.obj
x.c
code code
z.asm
code Directivas al cross-comp
x.c y.c z.asm
udata udata udata #pragma
x.c y.c z.asm
string idata start
Segmentos:
code: instrucciones
udata: datos sin inicializar
idata: datos inicializados
string: constantes strings
Instituto San Antonio de Padua
Sistemas embebidos Página 15
Ejemplo
x.c y.c z.asm
Segmentos
cross- cross- cross-
code: instrucciones
compiler compiler assembler
x.obj y.obj y.c z.obj
udata: datos sin inicializar
x.c z.asm
idata: datos inicializados
code code code
x.c y.c z.asm
udata udata udata
x.c y.c z.asm
string: constantes strings
string idata start
linker/locator
Linker/locator
ROM
z.asm
start
“Compagina” segmentos
x.c x.c
code RAM udata
y.c
“start-code” copia
idatshadow a idata en el
y.c
code udata
arranque
z.asm z.asm
code udata
x.c y.c
idatshadw es copiado a idata idata
string
en el arranque
y.c
idatshadw
Instituto San Antonio de Padua
Sistemas embebidos Página 16
Locator maps ****************************************
*
*
*
CROSS REFERENCE
*
*
*
****************************************
Program entry at : 020A Relocatable, from module : ?cstart
****************************************
Mapa:
* *
*
*
MODULE MAP
****************************************
*
*
DEFINED ABSOLUTE ENTRIES
Salida adicional del
*****************************************************************
DEFINED ABSOLUTE ENTRIES
PROGRAM MODULE, NAME : ?ABS_ENTRY_MOD
locator Absolute parts
ENTRY ADDRESS REF BY
===== ======= ======
_HEAP_SIZE 0050
Usualmente *.map
_STACK_SIZE 0050
*****************************************************************
FILE NAME : C:\temp\Debug\Obj\segment.r43
PROGRAM MODULE, NAME : segment
SEGMENTS IN THE MODULE
Resumen: ======================
DATA16_C
Relative segment, address: 025C - 0265 (0xa bytes), align: 0
Segment part 2. Intra module refs: str1
-----------------------------------------------------------------
DATA16_C
Ubicación del código,
Relative segment, address: 025A - 025B (0x2 bytes), align: 1
Segment part 3. Intra module refs: main
ENTRY ADDRESS REF BY
===== ======= ======
variables, etc. en los str1 025A
-----------------------------------------------------------------
DATA16_Z
Relative segment, address: 0200 - 0209 (0xa bytes), align: 0
diferentes segmentos Segment part 4. Intra module refs: main
ENTRY ADDRESS REF BY
===== ======= ======
str2 0200
-----------------------------------------------------------------
CODE
Relative segment, address: 0222 - 023D (0x1c bytes), align: 1
Segment part 5.
ENTRY ADDRESS REF BY
===== ======= ======
main 0222 Segment part 12
stack 1 = 00000000 ( 00000002 )
*****************************************************************
Instituto San Antonio de Padua
Sistemas embebidos Página 17
Ejemplo: compilador IAR C/C++
Tipos de segmentos
CODE: código ejecutable
CONST: datos ubicados en ROM
DATA: datos ubicados en RAM
Nomenclatura: nombrebase_sufijo
Nombre base
Por ejemplo: DATA16 (MSP430), NEAR (AVR)
Sufijo (categoría):
Datos no inicializados: N
Datos inicializados a cero: Z
Datos inicializados non-cero: I
Inicializadores para el anterior: ID
Constantes: C
Etc.
Instituto San Antonio de Padua
Sistemas embebidos Página 18
Ejemplos
ejemplo.c
...
...
int i = 0;
Variables que son inicializadas a
int j = 4;
cero son ubicadas en el
... segmento DATA16_Z
...
Variables inicializadas a valores
distintos de cero son ubicadas en
el segmento DATA16_I y un
segmento de inicialización en
DATA16_ID.
Instituto San Antonio de Padua
Sistemas embebidos Página 19
Compilador IAR C/C++
Segmento CSTART
contiene código para:
Arranque (cstartup)
Terminación (exit)
main() {
}//end main
Instituto San Antonio de Padua
Sistemas embebidos Página 20
Otros temas sobre inicialización
Constantes strings: char *sMsg = “Alarma”;
¿Dónde se guarda esta constante?
¿Qué pasa si modificamos este string?
Es válido en C
Cross-compilers resuelven este problema de diferentes maneras.
En función si es declarado constante: char* const ..
Si es modificado o no en el código
Instituto San Antonio de Padua
Sistemas embebidos Página 21
Ejemplo SEGMENTS IN THE MODULE
======================
DATA16_I
Relative segment, address: 0200 - 0201 (0x2 bytes), align: 1
Segment part 3. Intra module refs: main
ENTRY ADDRESS REF BY
ej-string.c 0200
str1
-----------------------------------------------------------
char* str1 = "Hola chau"; DATA16_Z
char str2[10]; Relative segment, address: 0202 - 020B (0xa bytes), align: 0
Segment part 5. Intra module refs: main
int main( void ) ENTRY ADDRESS REF BY
{ str2 0202
char* c1; -----------------------------------------------------------
char* c2; c1=str1; CODE
c2=str2; Relative segment, address: 0236 - 0251 (0x1c bytes), align: 1
for(;*c1!=0;c1++,c2++) Segment part 6.
*c2 = *c1; ENTRY ADDRES REF BY
} main S 0236 Seg. part 12 (?cstart)
stack 1 = 00000000 ( 00000002 )
-----------------------------------------------------------
DATA16_ID
Relative segment, address: 02A0 - 02A1 (0x2 bytes), align: 1
Segment part 4. Intra module refs: str1
-----------------------------------------------------------
DATA16_C
Relative segment, address: 0296 - 029F (0xa bytes), align: 0
Segment part 2. Intra module refs: Seg. part 4
Instituto San Antonio de Padua
Sistemas embebidos Página 22
Ejemplo SEGMENTS IN THE MODULE
======================
DATA16_C
Relative segment, address: 025C - 0265 (0xa bytes), align: 0
Segment part 2. Intra module refs: str1
-----------------------------------------------------------
ej-string.c DATA16_C
Relative segment, address: 025A - 025B (0x2 bytes), align: 1
char* const str1 = "Hola chau"; Segment part 3. Intra module refs: main
char str2[10]; ENTRY ADDRESS REF BY
str1 025A
int main( void ) -----------------------------------------------------------
{ DATA16_Z
char* c1; Relative segment, address: 0200 - 0209 (0xa bytes), align: 0
char* c2; c1=str1; Segment part 4. Intra module refs: main
c2=str2; ENTRY ADDRESS REF BY
for(;*c1!=0;c1++,c2++) str2 0200
*c2 = *c1; -----------------------------------------------------------
} CODE
Relative segment, address: 0222 - 023D (0x1c bytes), align: 1
Segment part 5.
ENTRY ADDRESS REF BY
main 0222 Seg. part 12 (?cstart)
stack 1 = 00000000 ( 00000002 )
Instituto San Antonio de Padua
Sistemas embebidos Página 23
Cargado del programa en destino
Alternativas:
Grabarlo en ROM o PROM, y después insertar el chip en la placa
Usar un Emulador ROM
Escribirlo en la memoria flash destino
Usar un “in-circuit emulator”
Instituto San Antonio de Padua
Sistemas embebidos Página 24
Memoria Flash
Flash programable en campo
Host se conecta al target y reprograma la Flash directamente sin
necesidad de cambiar chips
Cargado del programa
BSL (bootstrap loader) copia el programa en flash
JTAG
Instituto San Antonio de Padua
Sistemas embebidos Página 25
In-circuit emulator (programming)
(Atención: paradójicamente ya no es emulado...)
Toma el lugar del microprocesador en el sistema
Para el resto del hardware es un micro común
Programable o controlado por el host
Funcionalidad similar a un debugger de escritorio
Set breakpoints
Single-step
Volcado de registros y memoria
Ejemplo:
Flash Emulation Tool (FET): prototipado y desarrollo
Interfaz JTAG
Instituto San Antonio de Padua
Sistemas embebidos Página 26
Actualizaciones en campo
Corregir código en producto es caro
Debe llevar el producto para actualizar el programa (memoria) o
incluso el cliente podría hacerlo
Algunos productos permiten actualización automática
Receptores de TV Satélite
Teléfonos celulares
Motes: “on the fly”
No es fácil:
Si la imagen obtenida está corrupta (problemas de comunicación),
después no anda...
Instituto San Antonio de Padua
Sistemas embebidos Página 27
¿Por qué segmentos?
Cada segmento puede ser ubicado separadamente en el lugar
deseado de memoria física
Ejemplos:
Segmentos de código pude ser ubicado en ROM
Segmentos de datos constantes pueden ser ubicados en ROM
Segmentos de datos modificables pueden ser ubicados en RAM
Segmento especial “Start Code” es ubicado automáticamente para
que sea lo primero que se ejecute después de un reset
Instituto San Antonio de Padua
Sistemas embebidos Página 28
Creación de segmentos
Creados automáticamente por el compilador
Se realiza también para programas de escritorio, pero normalmente
es transparente para el usuario
En lenguaje ensamblador el programador debe hacerlos
explícitamente
Los ensambladores no son suficientemente sofisticados para
manejarlos de manera transparente (DSP: ¿se acuerdan?)
Los nombres deben ser consistentes con la convención del
compilador
Todos los sistemas tienen categorías similares de segmentos
Pero el nombre depende de las herramientas en particular
Por ejemplo: CODE, XDATA, o DATA, etc.
Instituto San Antonio de Padua
Sistemas embebidos Página 29
Ejecución desde RAM
RAM en general mas rápida que Flash y ROM
Código de arranque (startup code) debe copiar el programa de
ROM a RAM, y después transferirle el control
Considerar el nuevo desafío para el locator:
Crear un programa que es guardado a partir de cierta dirección (en
ROM), pero debe correr correctamente en otra dirección (en RAM)
No es tan fácil: RTOS a veces vienen con herramientas que lo realiza
Instituto San Antonio de Padua
Sistemas embebidos Página 30
Debate
Misceláneas de programación
Guía de estilo
Técnicas de programación
XP
Programación de a pares (pair programming)
Otros
Instituto San Antonio de Padua
Sistemas embebidos Página 31
¡Muchas gracias por su atención!
Instituto San Antonio de Padua
Sistemas embebidos Página 32
