A maior rede de estudos do Brasil

Grátis
256 pág.
Descobrindo o STM32

Pré-visualização | Página 10 de 47

tem alguns dados e que funcione para sempre:
int i;
int off = 5;
void inc(void){
i += off;
}
int main(void){
while (1) {
inc();
}
}
Embora não podermos observar diretamente este programa enquanto
ele é executado, podemos anexar um depurador e controlar sua execução atra-
vés de breakpoints e watchpoints. Observe que esse programa tem duas variá-
veis globais (i e off) e uma é iniciada em zero e a outra tem uma inicialização
diferente de zero. Além disso, o programa tem uma única função além da prin-
cipal que é chamada repetidamente.
Antes de executarmos o programa, há uma série de obstáculos que
devemos superar. Primeiro, precisamos compilar o programa em um formato
binário adequado para carrega-lo na placa Discovery. Em segundo lugar, temos
de carregar este binário na memória flash. Finalmente, a fim de observar o
programa, é preciso interagir com a placa Discovery por meio de um depurador
(GDB). Apesar de usarmos o GDB como um carregador e como um depurador,
em geral, os dois últimos passo podem ser feitos por ferramentas distintas.
Programa Demo
O processo de compilação de um programa para processadores embar-
cados como o STM32 pode envolver alguns detalhes tais como os flags de
compilação específica para o processador, os caminhos (paths) para as ferra-
mentas de compilação, etc. Em geral, a melhor abordagem é construir um
script “make” para guiar o processo. Antes de avançar neste capítulo, você
deve baixar o modelo de código, conforme descrito na Seção 1.2, que contém
os scripts necessários. O layout deste diretório é mostrado na Figura 1.16.
Para criar este exemplo no seu sistema, você precisará modificar duas
constantes no arquivo Makefile.common – TOOLROOT que deve indicar o dire-
50 Revision: (None) ((None))
tório bin da instalação do Sourcery e LIBROOT que deve indicar a instalação
da biblioteca padrão para periféricos STM32.
Para compilar este programa, altere os diretórios para o diretório Demo
e execute “make”. Isso deve criar um arquivo chamado Demo.ELF que contém
o binário compilado.
Para baixar e executar esse binário vamos precisar de dois programas
– gdb (arm-none-eabi-gdb), que é parte da distribuição Sourcery, e st-util,
que fornece um servidor gdb que comunica com o stub de depuração stlink
na placa Discovery através de uma conexão USB. Descrevemos como instalar
st-util na Seção 1.2. Vamos assumir que você instalou e testou a conexão.
Você deve abrir duas janelas. Em um delas, execute:
st-util -1
Observação: versões anteriores de st-util precisam de uma sequencia de
startup diferente
st-util 4242 /dev/stlink
que inicia um servidor gdb na porta 4242. Você deverá ver uma saída tal como
a seguinte:
Chip ID is 00000420, Core ID is 1ba01477.
KARL - should read back as 0x03, not 60 02 00 00
Listening at *:4242...
Na outra janela, execute (as linhas que iniciam com “(gdb)” estão dentro do
depurador):
arm-none-eabi-gdb Demo.elf
(gdb) target extended -remote :4242
(gdb) load
(gdb) break main
(gdb) break inc
(gdb) continue
O comando “target” deve se conectar ao servidor gdb na porta 4242; o
“load” baixa o executável para a memória flash do STM32. Os próximos dois
comandos definem os breakpoins nos procedimentos main e inc, e o comando
“continue” executa até o próximo breakpoint. Você pode então executar re-
petidamente e examinar o valor de i:
Revision: (None) ((None)) 51
CAPÍTULO 3. PROGRAMA ESQUELETO
(gdb) print i
(gdb) continue
...
Exercise 3.1 GDB no STM32
Experimente com o GDB para testar os vários comandos disponíveis,
como por exemplo:
1. Exibir os valores atuais dos registradores (p. ex.: print /x $sp exibe o
stack pointer em hexadecimal.
2. Tente configurar um watchpoint em i.
3. Tente usar um breakpoint que exibe i e continua pouco antes das cha-
madas de main a inc
Scripts Make
Enquanto que para baixar e executar um binário é extremamente fácil,
o processo de criação não é. As ferramentas de compilação requerem opções
não-óbvias, as bibliotecas de firmware STM32 exigem várias definições, e a cri-
ação de um executável a partir de binários requer um “linker script” dedicado.
Além disso, “main.c” não é, em si, um programa completo – há sempre os pas-
sos necessários para inicializar variáveis e configurar o ambiente de execução.
No mundo Unix, cada programa em C é linkeditado com “crt0.o” para realizar
essa inicialização. No mundo embarcado, é necessário uma inicialização adi-
cional para configurar o ambiente de hardware. Nesta seção, vamos discutir
o processo de criação e na próxima, a função desempenhada pelo código de
inicialização STM32 (que está incluído com as bibliotecas de firmware).
Os arquivos make incluídos com o programa demo são divididos em
duas partes – Makefile.common faz o trabalho pesado e é reutilizável para ou-
tros projetos, enquanto Demo/Makefile é o específico do projeto. Na verdade,
a única função do makefile específico do projeto é definir os arquivos objetos
necessários e suas dependências. O Makefile para o projeto demo é mostrado
na Listagem 3.1. Ele pode ser modificado para outros projetos, adicionando
objetos e modificando os flags de compilação. A variável TEMPLATEROOT deve
ser modificada para apontar o diretorio template.
52 Revision: (None) ((None))
TEMPLATEROOT = ..
# compilation flags for gdb
CFLAGS = -O1 -g
ASFLAGS = -g
# object files
OBJS= $(STARTUP) main.o
# include common make file
include $(TEMPLATEROOT)/Makefile.common
Listing 3.1: Makefile Demo
A maior parte do Makefile.common define os caminhos para as ferra-
mentas e bibliotecas. As únicas partes notáveis deste arquivo são as definições
específicas do processador e os flags de compilação. As definições especificas
do processador incluem o linker script LDSCRIPT que informa ao linkeditor
o arquivo correto do linker script a ser usado – vamos discutir esse arquivo
brevemente na próxima seção. O tipo de processador é definido pelo PTYPE
que controla a compilação condicional das bibliotecas de firmware, e dois ar-
quivos de inicialização – um genérico (system_stm32f10x.o) e um específico
para os processadores STM32 Value Line (startup_stm32f10x.o). As bi-
bliotecas STM32 são projetados para oferecer suporte a vários membros da
família STM32, exigindo várias chaves de compilação. O processador da placa
STM32 VL Discovery é do tipo “medium density value line” – isso se reflete
na definição em tempo de compilação STM32F10X_MD_VL.
PTYPE = STM32F10X_MD_VL
LDSCRIPT = $(TEMPLATEROOT)/stm32f100.ld
STARTUP= startup_stm32f10x.o system_stm32f10x.o
# Compilation Flags
FULLASSERT = -DUSE_FULL_ASSERT
LDFLAGS+= -T$(LDSCRIPT) -mthumb -mcpu=cortex-m3
CFLAGS+= -mcpu=cortex-m3 -mthumb
CFLAGS+= -I$(TEMPLATEROOT) -I$(DEVICE) -I$(CORE) -I$(PERIPH)/inc -I.
CFLAGS+= -D$(PTYPE) -DUSE_STDPERIPH_DRIVER $(FULLASSERT)
Revision: (None) ((None)) 53
CAPÍTULO 3. PROGRAMA ESQUELETO
Os flags -mcpu=cortex-m3 -mthumb informam ao gcc sobre o núcleo
do processador. -DUSE_STDPERIPH_DRIVER -DUSE_FULL_ASSERT afeta a com-
pilação do código da biblioteca de firmware.
O Modelo de Memória do STM32 e a sequencia de Boot
A memória dos processadores STM32 é composta por duas grandes
áreas – memória flash (efetivamente somente leitura) começa no endereço
0x08000000 enquanto que a memória RAM estática (leitura / gravação) co-
meça no endereço 0x20000000. O tamanho destas áreas é específico do pro-
cessador. Quando um programa está sendo executado, o código de máquina
(em geral) fica na memória flash e o estado variável (variáveis e a run-time
stack) ficam na memória RAM estática (SRAM). Além disso, a primeira parte
da memória flash, a partir de 0x08000000, contém uma tabela de vetor con-
sistindo de ponteiros para os vários manipuladores (handlers) de exceção. O
mais importante deles é o endereço do manipulador de reset (armazenado em
0x8000004), que é executado sempre que o

Crie agora seu perfil grátis para visualizar sem restrições.