Construcción del entorno de desarrollo de sistemas integrados

El entorno de desarrollo del sistema integrado incluye principalmente:

• Herramientas de desarrollo integradas
• Compilador cruzado
• Archivo por lotes
• makefile
• Enlace de secuencia de comandos
• Herramientas de depuración
• herramienta de descarga
• Otras herramientas (herramientas sin conexión)
• Emulador
• Herramienta de control de versiones

A continuación, explique las herramientas anteriores por separado:

1. Herramientas de desarrollo integradas

Generalmente, los fabricantes de CPU proporcionarán un entorno de desarrollo integrado (IDE) para la CPU, pero en aplicaciones prácticas, la mayoría de las empresas de desarrollo de proyectos integrados seguirán utilizando su propio entorno de desarrollo. Uno son los requisitos especiales de algunas funciones del proyecto, y el otro es que no todos los modelos de CPU tienen el IDE correspondiente.

2, herramientas cruzadas

Cross-Tools incluye:

• Ensamblador cruzado
• Compilador cruzado
• Biblioteca cruzada
• Enlace cruzado
• herramienta de volcado (información sobre la conversión de archivos ejecutables en código de lenguaje ensamblador)
• Herramienta de depuración (GNU gdb)

Tomando el compilador de C gcc en GNU Tool-Chain como ejemplo, las siguientes son algunas opciones de compilación:

• -Werror: convierte todos los mensajes de advertencia en mensajes de error. Una vez que se genera un mensaje de advertencia, no se genera ningún archivo de destino.
• -S: Salida de código en lenguaje ensamblador al compilar.
• -C: solo se generan archivos objeto durante la compilación
• -E: solo realizar preprocesamiento sin generar archivos de objeto
• -D: define las constantes de macro en tiempo de compilación
• -O, -O2, -O3: Nivel de optimización.
• -g: agrega información de depuración al compilar, para que pueda depurarse con GDB

Tome el vinculador C Linker en GNU Tool-Chain como ejemplo. Aquí hay algunas opciones:

• -T: Desarrollar archivo de script de enlace
• -Mapa: Genere un archivo de mapa al conectarse, que contiene la información de dirección de todos los símbolos en el programa.

La cadena de herramientas GNU puede admitir muchas CPU diferentes y los usuarios pueden establecer la configuración de acuerdo con sus necesidades. Por ejemplo, arm-elf-gcc es un compilador de C que genera código de máquina ARM en formato elf, y 68K-coff-ld es un enlazador que genera código de máquina 68000 en formato COFF.

3 、 Hacer

make es una herramienta de programa para la compilación automática. Siempre que el makefile se use para describir en detalle qué herramienta (como un compilador cruzado) usar para qué archivo ( .c, .obj, ...) qué hacer (para producir archivos de objeto no optimizados) ), make también verificará si estos archivos están desactualizados. Si están desactualizados, solo volverán a compilar los archivos que deben compilarse (make comparará las dependencias y las fechas entre archivos para determinar si un archivo necesita ser recompilado). Programa de procesamiento (por ejemplo, programa .bat en Windows), después de actualizar algunos archivos, es necesario volver a compilar todos los archivos.

"Programación con software GNU / Programación GNU"

"Gestión de proyectos con la herramienta de desarrollo de proyectos make / make"

Los dos libros anteriores tienen instrucciones detalladas sobre el uso de make.

(1) Conceptos importantes en el archivo MAKE

• Destino: el nombre del archivo que desea generar.
• Dependencia: defina si existe una dependencia entre dos archivos.
• Requisito previo (archivos obligatorios): algunos archivos que pueden crear un destino. Un destino suele ser creado por varios archivos.
• ACTUALIZADO (nueva versión): Suponiendo que un archivo es más nuevo que el archivo del que depende, significa que el archivo tiene una nueva versión.

La sintaxis básica de Makefile:

#文件名：sample.mak
Target：Dependency list
    command1
    command2

El comando para ejecutar el archivo MAKE anterior es :, make -f sample.maksi no se especifica ningún archivo MAKE con -f, make buscará un archivo llamado "archivo MAKE" en el directorio actual. Además, si no se especifica target, make usará el primer nombre de archivo de destino en el archivo MAKE como nombre de destino.

(2) Ejemplos de makefile

• El siguiente ejemplo es un ejemplo de definición de macro en un archivo MAKE:

#File Name  :   DEFINE.MAK
#
#定义其它makefile中会用到的宏，思想和C语言的#define一样
#
！IFNDEF _DEFINE_MAK
_DEFINE_MAK = DEFINED
#
#定义项目相关文件所在的磁盘机编号
#
PRJ_DRIVER  =   Y:
#
#定义项目工具所在目录
#
PRJ_TOOLS_ROOT  =   $(PRJ_DRIVER)\Tools
#
#定义编译器所在目录
#
GNU_CC  =   $(GNU33_ROOT)\kcc33
GNU_LK  =   $(GNU33_ROOT)\ld
GNU_AR  =   $(GNU33_ROOT)\ar
#
#定义项目程序所在目录
#
SRC_ROOT    =   $(PRJ_DRIVER)\Project2020
SRC_INC     =   $(SRC_ROOT)\include
#
#当编译时传入-DXXX参数，其效果如同在程序中写了#define XXX
#
PRJ_CONFIG  =   -DPRJ_2020 -DCPU_ARM9 -DLCD_160X160
#
#定义执行C compiler时的参数
#
？CFLAGS= -c -gstabs -mlong-calls -fno-builtin -mgda=0 -mdp=1 -O3 
        -I$(GNU_INCLUDE)
        -I$(SRC_INC)
        -I$(PRJ_CONFIG)
#
#定义执行linker时的参数
#
LDFLAGS= -T main.lds -Map $(TARGET).map -N
#...
#...
!ENDIF

• El siguiente ejemplo es un ejemplo más complejo:

#
#在makefile中，也可以和include一样，包含其它makefile
#
!IF "$(_DEFINE_MAK)" == ""
!INCLUDE DEFINE.MAK
!ENDIF
#
#定义各模块包含的object file，每个object都是一个target
#
MODEL1_OBJS = m1_001.obj m1_002.obj m1_003.obj
MODEL2_OBJS = m2_001.obj m2_002.obj
#
# 项目中所有需要的object file
#
OBJS    = $(MODEL1_OBJS) $(MODEL2_OBJS)
#
#定义会用到的库函数
#
LIBS = $(GNU_LIB)\libgcc.a
#
#第一个target产生最终可执行文件main.elf,
#和main.elf有依赖关系的target有：所有的object file，main.mak,Link Script
#"$@"表示target本身，即main.elf
#
main.elf : $(OBJS) main.mak main.lds
    $(GNU_LK) $(LDFLAGS) -o $@ $(OBJS) $(LIBS)
#
# $* 表示target名称去掉扩展名
# $@ 表示target本身
# $< 表示XXX.c
#
m1_001.obj : $(SRC_ROOT)\m1\m1_001.c $(SRC_INC)\m1.h
    $(GNU_CC) $@ $(CFLAGS) $*.c

m1_002.obj : $(SRC_ROOT)\m1\m2_001.c $(SRC_INC)\m1.h
    $(GNU_CC) $@ $(CFLAGS) $*.c

...

• Cuando necesite procesar varios archivos con la misma extensión repetidamente, generalmente puede usar las reglas de compilación preestablecidas de make. Por ejemplo, cuando necesite compilar todos los destinos con la extensión .obj bajo las mismas reglas, puede usar la siguiente declaración:

?.c.obj:；$(GNU_CC) $@ $(CFLAGS) $<

Descripción de la sintaxis de las reglas de compilación preestablecidas:

• .c.obj :; Esta línea de directorio se usa para estandarizar el destino como el archivo .obj, y la dependencia es la regla de compilación preestablecida para el archivo .c

• Las macros aún se pueden usar al establecer reglas de precompilación

(3) Destino del nombre que no es de archivo

clean：
    del $(OBJS)
    del main.elf
    del main.bin

Solo hay un objetivo en la declaración makefile anterior y no hay dependencia, lo que significa que el objetivo definitivamente ejecutará el comando del a continuación. Generalmente se usa para ejecutar antes de recompilar todos los archivos.

Este destino sin nombre de archivo también se puede usar como una dependencia de otros destinos, que se usa para ejecutar una serie de instrucciones primero cuando se va a crear un destino:

build_all : clean
    ...
    ...

(4) Control de versiones

Antes de que el sistema sea lanzado oficialmente, el código del programa definitivamente contendrá muchas líneas de código para depurar. Pero en la práctica, debido a los recursos de almacenamiento limitados del sistema integrado, es imposible grabar el programa que contiene el código de depuración en la placa como código final. Por lo tanto, al diseñar, generalmente se diseñan dos versiones (versión de depuración y versión de lanzamiento). Por supuesto, cuando se desarrolla el programa, no podemos eliminar manualmente estos códigos de depuración uno por uno. En este momento, se puede utilizar la idea de compilación condicional en lenguaje C, consulte el siguiente análisis:

Archivo por lotes de la versión de depuración: make_debug.bat

REM ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
REM Make_debug.bat
REM~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

REM 设定Windows/DOS的系统环境变量
REM
set BUILD_MODE = Debug

REM make我们的程序
REM
make target

Lanzamiento del archivo por lotes: make_release.bat

REM ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
REM Make_release.bat
REM~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

set BUILD_MODE = Release
make target

makefile:

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#makefile
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#
!IF "$(BUILD_MODE)" == "Debug"
# 如果BUILD_MODE等于“Debug”，则设定编译时期的参数CFLAGS_DEBUG = __DEBUG_VERSION
# 反之，则设定编译时期的参数为空
#
CFLAGS_DEBUG = -D__DEBUG_VERSION
!ENDIF

target:
    gcc $(CFLAGS_DEBUG) xxx.c
#-D参数用来在编译时期设定宏变量“__DEBUG_VERSION”

4 、 Script de enlace

En el proceso de creación de archivos ejecutables, todos los archivos de programa deben compilarse primero en archivos de objeto, y luego todos los archivos de objeto y los archivos de biblioteca se vinculan en archivos ejecutables a través del vinculador. El archivo de script de enlace con la extensión .ld especifica cómo enlazar y a qué dirección conectarse.

En el caso de un sistema operativo, los diferentes programas tienen sus propios espacios de direcciones y no interfieren entre sí. Todos estos programas se ejecutan en RAM (memoria) y todos los programas solo necesitan estar conectados desde la misma dirección de inicio. Sin embargo, los programas integrados a menudo no tienen un sistema operativo. El sistema y el programa suelen estar en el mismo espacio de direcciones y, a menudo, no hay disco duro. El programa sólo se puede ejecutar en ROM o flash. Pero los datos solo se pueden direccionar en la RAM, por lo que cuando se conecte, dígale al enlazador dónde se debe direccionar el segmento del programa (la dirección de inicio de la ROM) y dónde se debe direccionar el segmento de datos (la dirección de inicio de la RAM) .

(1) La estructura de la sección del programa

• segmento de texto : el segmento de código, el contenido del segmento de texto no cambiará durante la ejecución, se puede ejecutar directamente en la ROM sin cargarlo en la memoria.
• Sección de datos de solo lectura (rodata) : las variables y cadenas definidas como const se clasificarán en la sección rodata. , Que también se ejecuta directamente en ROM.
• Sección de datos : Las variables globales con valores iniciales se colocan en esta sección. Durante el período de conexión, estos valores iniciales deben agregarse al archivo ejecutable, pero deben dirigirse a la dirección de la RAM; durante el período de ejecución, estas variables se almacenan en la ROM, pero deben cargarse en la RAM para ser utilizadas, porque El valor de es variable. Por lo tanto, el segmento de datos se agregará a la ROM, pero debe dirigirse a la RAM.
• Sección bss : las variables globales sin valores iniciales se clasificarán en la sección bss. Debido a que no hay un valor inicial, no es necesario agregarlo al programa, siempre que esté dirigido a la RAM al conectarse. No hubo ningún problema de carga durante la ejecución, pero después de que la máquina fue RESET, el sistema borró activamente todo el segmento bss.

(2) El contenido del script de enlace

Uso de memoria durante la ejecución:

• LMA （Cargar dirección de memoria） 与 VMA （Dirección de memoria virtual）

Los datos se colocarán en la ROM, pero deben cargarse en la RAM durante la ejecución La dirección en la ROM (la dirección de almacenamiento final) se llama LMA y la dirección en la RAM (tiempo de ejecución) es VMA.

Intente escribir un script de enlace con los siguientes requisitos de conexión:

• Hay una ROM en el sistema, su dirección inicial es 0xC00000, y otra RAM, su dirección inicial es 0.
• El archivo ejecutable contiene segmentos de texto, rodata y datos. Los segmentos de texto y rodata se pueden ejecutar en ROM, por lo que se dirigen a 0xC00000 y rodata sigue al texto.
• Debido a que el segmento bss no tiene un valor inicial, no ocupará espacio ejecutable o espacio ROM, y se dirigirá a la dirección inicial de RAM 0.
• La sección de datos es más complicada, su contenido también debe incluirse en el archivo ejecutable y debe cargarse en la RAM durante la ejecución. Por lo tanto, el VMA de datos está en RAM, después del segmento bss, y el LVA está después del segmento rodata.

Expansión : cuando desee que un programa determinado se ejecute a una velocidad más rápida, solo necesita poner su LMA en ROM y VMA para dirigirlo a RAM, y cargarlo de ROM a RAM antes de la ejecución.

/*********************************************************
Link Script sample
存储器地址配置：ROM起始地址（0xC00000），RAM起始地址（0）
输出ARM9机器码，可执行文件格式为elf32
**********************************************************/

OUTPUT_FORMAT("elf32-arm9")
OUTPUT_ARCH(arm9)
SEARCH_DIR(.);

SECTIONS
{
    /*****************************************
    定义text段，起始地址（VMA）从0xC00000开始，
    若没有指定LMA，表示LMA起始地址同VMA。
    *****************************************/
    .text 0xC00000:
    {
    /* 定义变量__START_text,句号.表示当前的VMA，即0xC00000 */
    __START_text = . ;

    /* *(.text)表示将当前目录中所有的.text段加入到这个段*/
    *(.text);

    /* 定义变量__END_text,目前VMA应该是0xC00000加上所有.text段的size总和 */
    __END_text = . ;
    }

     /*****************************************
    定义rodata段，起始地址（VMA）从__END_text开始（跟在text段之后），
    若没有指定LMA，表示LMA起始地址同VMA。
    *****************************************/
    .rodata __END_text :
    {
    __START_rodata = . ;
    *(.rodata);
    __END_rodata = . ;
    }

     /*****************************************
    定义bss段，起始地址（VMA）从0开始，
    若没有指定LMA，表示LMA起始地址同VMA。
    *****************************************/
    .bss 0x00000000:
    {
        __START_bss = .;
        *(.bss);
        __END_bss = .;
    }

     /* 定义可在程序中使用的变量__SIZE_BSS,表示bss段的大小。*/
    __SIZE_BSS = __END_bss - __START_bss；

    /*****************************************
    定义data段，其LMA应该在ROM，而VMA在RAM。
    所以，VMA跟在bss段后面，LMA跟在rodata段之后
    *****************************************/
    .data __END_bss : AT(__END_rodata)
    {
        __START_data = .;
        *(.data);
        __END_data = .;
    }

    /*定义变量__START_data_LMA,表示data段的起始地址*/
    __START_DATA_LMA =  LOADADDR(.data);

     /* 定义可在程序中使用的变量__SIZE_DATA,表示data段的大小。*/
    __SIZE_DATA = __END_data - __START_data;

    /***********************************************
    speed_up模块的VMA和LMA都是跟在data段之后，
    它会被加到可执行文件中，但执行时要载入到RAM才能执行
    **************************************************/
    .text_speed_up __END_data : AT(__START_data_LMA + SIZEOF(.data))
    {
    __START_text_speed_up = .;
      speed_up_main.o(.text);
      speed_up_main.o(.rodata);
      speed_up_main.o(.data);
    __END_text_speed_up = .;
    /* 为便于说明，假设该模块没有bss段*/
    }
    __START_text_speed_up_LMA = LOADADDR(.text_speed_up);
    __SIZE_TEXT_SPEED_UP = __END_text_speed_up - __START_text_speed_up;
}

El código para transferir un módulo de programa (speed_up) a una memoria más rápida para su ejecución es el siguiente:

extern unsigned char * __START_text_speed_up;
extern unsigned char * __START_text_speed_up_LMA;
extern int __SIZE_TEXT_SPEED_UP;

void copy_data_section(void)
{
    //一个字节一个字节的传输（性能较差）
    int i;
    unsigned char *dest = __START_text_speed_up;
    unsigned char *src = __START_text_speed_up_LMA;
    for(i=0; i<__SIZE_TEXT_SPEED_UP; i++)
        dest[i] = src[i]
}

El código asignado a 0 para el segmento bss es:

extern unsigned char * __START_bss;
extern int __SIZE_BSS;

void clear_bss_section(void)
{
    int i;
    unsigned char * dest = __START_bss;
    for(i=0; i<__SIZE_BSS；i++)
        dest[i] = 0;
}

(3) Archivo de mapa o tabla de símbolos

Además de generar archivos ejecutables después de la vinculación, generalmente se requiere generar un archivo de mapa (parámetro -m de GNU linker'ld '), que se usa para registrar cada símbolo en el proyecto (todas las funciones en el programa, funciones de biblioteca, variables globales y vinculador) La variable generada automáticamente de la dirección inicial y final de cada sección) la relación correspondiente entre el LMA y VMA. La siguiente información se puede obtener a través del archivo de mapa:

• Si el direccionamiento de cada sección del programa es correcto;
• El tamaño de cada sección del programa, es decir, el uso de ROM y RAM;
• La dirección de cada símbolo en el programa;
• El orden de cada símbolo en la memoria.
• Uso de almacenamiento de cada archivo de programa

Cuando se completa la conexión, antes de descargar el archivo ejecutable al almacenamiento real, generalmente debe verificar el archivo de mapa para asegurarse de que la dirección de inicio y el tamaño de cada sección cumplan con sus propias suposiciones. La siguiente figura es una captura de pantalla parcial de un archivo de mapa:

5 、 Creador de ROM

El archivo ejecutable tiene varios formatos (ELF, COFF, HEX, S-Record, EXE, etc.), pero el archivo binario que debe grabarse en la ROM de la placa es el archivo binario, por lo que cuando se obtiene el archivo ejecutable, debe ser convertido por ROM Maker Solo se pueden programar archivos binarios. Por supuesto, debido a que los sistemas embebidos generalmente no tienen un disco duro, los archivos que no sean archivos binarios ejecutables también deben convertirse en un solo archivo binario total (archivo de imagen) junto con ellos. Este proceso se llama hacer ROM. El proceso específico se muestra en la siguiente figura:

Además del archivo ejecutable binario, los archivos que se agregan al archivo de imagen suelen ser imágenes (archivos JPG, etc.). La práctica común es convertir el archivo de imagen en una matriz C constante por bytes y darle un nombre En el programa, puede usar estos datos operando directamente la memoria, evitando así el uso del sistema de archivos, pero la escalabilidad no es fuerte y la actualización es problemática. Por lo tanto, cuando hay muchos de estos archivos de imagen, se recomienda utilizar un sistema de archivos para administrarlos de manera más conveniente.

De hecho, generalmente desarrollamos una herramienta para convertir todos los archivos en un directorio en un programa de matriz C y, al mismo tiempo, se generará un archivo de encabezado .h, que contiene todas las declaraciones de matriz C que representan la minería de datos y cada matriz Tamaño, puede usar estas matrices siempre que incluya el archivo .h cuando lo use.

• Imagen del sistema de archivos

De hecho, el sistema de archivos es solo una interfaz para acceder a los datos, es un conjunto de tipos de datos abstractos que implementan operaciones como el almacenamiento de datos, la organización jerárquica, el acceso y la adquisición. Es posible dónde se almacena el sistema de archivos y qué formato utiliza. Si el sistema no tiene requisitos para escribir archivos, el sistema de archivos aún se puede almacenar en la ROM.

En un sistema integrado, si no hay necesidad de escribir datos, generalmente uso una tabla de índice para registrar el nombre del archivo y su primera dirección y tamaño de archivo en la memoria. Para facilitar la búsqueda, la tabla de índice generalmente se encuentra en la dirección más alta.

6 、 Herramientas sin conexión

Las herramientas que se utilizan en la fase de desarrollo y deben desarrollarse y ejecutarse en la PC se denominan herramientas fuera de línea. Estas herramientas se pueden dividir en 6 categorías:

• Generador de programas (Programa general)

  • Herramienta de configuración del sistema: una herramienta que se ejecuta en la PC y se utiliza para seleccionar la configuración del sistema (ciertos interruptores de función, resolución de LCD, etc.) y generar automáticamente un archivo .h o make-file.
  • Administrador de recursos: el archivo de cadena, gráfico o datos que se agregará al sistema es recurso. Por ejemplo, el pequeño archivo gráfico utilizado para la interfaz de IU debe convertirse a una matriz C y agregarse al programa, y ​​otros programas corresponden a la matriz a través del ID de recurso. Esta herramienta nos permite exportar automáticamente el archivo .h que contiene todas las definiciones de ID de recursos y el archivo .c que contiene la matriz C de estos contenidos de recursos con solo editar el nombre del archivo de recursos.
• Data Maker: Los sistemas integrados generales no pueden utilizar bases de datos como mySQL y deben diseñarse de acuerdo con las características de la aplicación.
  • Sistema de archivos: estrictamente hablando, un sistema de archivos también es una base de datos, pero su unidad es un archivo en lugar de un registro.
  • Base de datos: La denominada base de datos contiene básicamente archivos de datos y múltiples niveles de tablas de índices. Bajo la premisa de una potencia informática limitada de la CPU, el diseño del formato de la base de datos y el algoritmo de compresión es particularmente importante.
  • Archivos integrados del producto: por ejemplo, algunos archivos que los usuarios no pueden eliminar, como algunos archivos de música MP3 incorporados o libros incorporados de libros electrónicos, deben distinguirse de los archivos editables por el usuario, y esto implica varias áreas de almacenamiento de archivos o varios sistemas de archivos.
  • Información del producto o configuración predeterminada de fábrica: para cierta información que cambia con frecuencia (fabricante, fecha, etc.), tendemos a no escribirla en el programa, sino a almacenar la información en un archivo o base de datos, de modo que el sistema se esté ejecutando. Solo obtén la información en él.
• Image Maker: Su función es hacer una imagen para quemarla en la memoria al final. La imagen contiene no solo el programa, sino también información del producto, imagen del sistema de archivos, base de datos, etc.

• Herramienta de descarga: además de utilizar una grabadora para escribir la imagen en la memoria, también es necesario proporcionar una herramienta de descarga para descarga parcial, ya que a veces solo actualiza algunos programas o algunos archivos en el sistema de archivos.
• Herramienta de producción en masa: parte de la información del fabricante (nombre del fabricante, número de lote, fecha, etc.) solo se puede determinar antes de grabar. En este momento, se debe proporcionar una herramienta al fabricante para escribir esta información en una ubicación específica en la imagen antes de proceder a la grabación de memoria.
• Emulador
• Otras herramientas

7. Descarga y ejecuta

Estrictamente hablando, la llamada ROM no se puede grabar. Antes de la producción en masa, es necesario confiar a un fabricante profesional de Mask-ROM para que realice una grabación única de acuerdo con el archivo de imagen que proporcionamos. En la etapa de desarrollo, tenemos que elegir otras alternativas repetibles, como NOR-flash, EPROM o EEPROM. Generalmente, hay varias formas de escribir datos:

• Primero use ICE para descargarlo a la RAM para su ejecución y prueba.
• Quemador: Primero coloque el chip de la memoria en el zócalo del quemador, y luego use la PC para operar el programa de grabación proporcionado por el fabricante, seleccione el archivo de imagen y ejecute la grabación. (La memoria de la placa en la etapa de desarrollo se diseña primero para conectarse a la placa a través de un zócalo, solo necesitamos colocar el IC quemado en el zócalo y sujetarlo)
• ROM-Emulator: Esta herramienta es para emular EPROM / EEPROM, un extremo del cual está conectado al zócalo de la placa y el otro extremo está conectado a la PC. A través del programa proporcionado por el fabricante, el archivo de imagen se puede descargar a la memoria del emulador de ROM, y la máquina se conecta al emulador como una ROM real.
• Programa de actualización: si la placa real se puede conectar a la PC a través de alguna forma (USB, RS232, cable de red) y transmitir datos, podemos desarrollar un módulo de programa de actualización para recibir el contenido del archivo de imagen en el lado de la PC y escribirlo en el flash NOR. De esta forma se completa la función de actualizar la versión del programa en la máquina.

8. Control de versiones

Ya sea un sistema integrado o un proyecto de software general, siempre que implique un desarrollo colaborativo de varias personas, se debe realizar el control de versiones. Cuando el desarrollo de software alcanza un cierto hito o tiene un gran avance, el administrador puede darle un nombre a la versión actual, lo llamamos Etiqueta o etiqueta, y cualquiera puede descargar todos los programas en un determinado momento desde el servidor de control de versiones.

Cuando el sistema necesita desarrollar una nueva función, puede crear una rama y desarrollar en esa rama. Después del éxito, se fusiona con la rama maestra.