quinta-feira, 5 de novembro de 2015

Facilitando as coisas com o utilitário MAKE

No último post codificamos e executamos nosso primeiro programa para o microcontrolador STM32F051R8T6. Uma série de comandos na ordem certa são necessários para perfazer essa tarefa. Vamos aproveitar que as coisas ainda estão simples e introduzir um utilitário que facilita muito o trabalho de quem desenvolve programas: o utilitário MAKE. Em um post anterior, nós o baixamos e instalamos através de uma versão de utilitários POSIX: o MINGW. O utilitário MAKE busca dependências e comandos em um arquivo a parte que, por padrão, chama-se makefile. Vamos começar de uma forma simples e aos poucos automatizando mais o processo.

O utilitário MAKE trabalha com dependências e procedimentos. No nosso primeiro programa, o arquivo final era o flash.bin que dependia do rst_0.bin que, por sua vez, dependia do rst_0.elf e assim por diante até chegarmos na primeira dependência que era o programa assembly rst_0.s propriamente dito. Se usarmos o símbolo ':' para marcar a dependência, teremos:

  1. flash.bin: rst_0.bin
  2. rst_0.bin: rst_0.elf
  3. rst_0.elf: rst_0.o
  4. rst_0.o: rst_0.s

Do lado esquerdo dos dois-pontos temos o produto e do lado direito o produto necessário para gerá-lo. Dessa forma, temos uma cadeia de dependências:

flash.bin: rst_0.bin: rst_0.elf: rst_0.o: rst_0.s

Essa é a primeira construção do makefile.

Dissemos que o utilitário MAKE trabalha com dependências e procedimentos. Para satisfazer as dependências temos os procedimentos. Como incluir um procedimento no arquivo makefile?
Simples: na linha seguinte à dependência, iniciando com o caractere TAB (0x09), codificamos o(s) comando(s) que satisfaz(em) essa dependência. Veja o exemplo abaixo:

  1. rst_0.o: rst_0.s
  2. arm-none-eabi-as -a -o rst_0.o rst_0.s

Para satisfazer a dependência da linha 1, o utilitário MAKE executa o comando que esta na linha 2. Simples assim. O arquivo makefile completo para o nosso promeiro programa está abaixo:

  1. flash.bin: rst_0.bin
  2. dd if=/dev/zero of=flash.bin bs=4096 count=16
  3. dd if=rst_0.bin of=flash.bin bs=4096 conv=notrunc
  4. rst_0.bin: rst_0.elf
  5. arm-none-eabi-objcopy -O binary rst_0.elf rst_0.bin
  6. rst_0.elf: rst_0.o
  7. arm-none-eabi-ld -Ttext=0x00000000 -o rst_0.elf rst_0.o
  8. arm-none-eabi-nm rst_0.elf
  9. rst_0.o: rst_0.s
  10. arm-none-eabi-as -a -o rst_0.o rst_0.s
  11. clean:
  12. rm *.bin
  13. rm *.elf
  14. rm *.o

Todas as dependências estão satisfeitas por comandos. Notem uma dependência nova na linha 13. Na verdade, podemos executar o utilitário MAKE dizendo a ele qual dependência queremos satisfazer.  A linha 13 permite uma opção para limpar todos os arquivos de saída dos procedimentos executados. Vejamos sua execução:

  1. U:\arm_00>make clean
  2. rm *.bin
  3. rm *.elf
  4. rm *.o
  6. U:\arm_00>
A dependência clean executa o comando rm (remove) para excluir os arquivos desejados.

Finalmente, eis a execução de nosso makefile para gerar nosso primeiro programa:


  1. U:\arm_00>make
  2. arm-none-eabi-as -a -o rst_0.o rst_0.s
  3. ARM GAS rst_0.s page 1
  6. 1 // Primeiro programa para ARM Cortex-M0
  7. 2
  8. 3 .code 16 // Define c├│digo como THUMB
  9. 4 .globl _start // Necessario para o linker
  10. 5
  11. 6 .equ STACK_INIT,0x020002000
  12. 7
  13. 8 .text // Inicio da área de código
  14. 9 _start:
  15. 10
  16. 11 // Inicio do Vector Table
  17. 12
  18. 13 0000 00200020 .word STACK_INIT // Inicio da pilha
  19. 14 0004 00000000 .word reset_handler // Endereco do Reset Handler
  20. 15
  21. 16 // define o label como função para que o linker
  22. 17 // resolva como c├│digo THUMB
  23. 18
  24. 19 .type reset_handler, function
  25. 20
  26. 21 reset_handler: // inicio do tratamento do reset
  27. 22
  28. 23 0008 0320 mov r0, #3 // carrega r0 com o valor 3
  29. 24 000a 0421 mov r1, #4 // carrega r1 com o valor 4
  30. 25 000c 0A18 add r2, r1, r0 // soma r0 e r1 guardando em r2
  31. 26
  32. 27 000e FEE7 _stop: b . // loop infinito
  33. ♀ARM GAS rst_0.s page 2
  36. DEFINED SYMBOLS
  37. rst_0.s:9 .text:00000000 _start
  38. rst_0.s:6 *ABS*:20002000 STACK_INIT
  39. rst_0.s:21 .text:00000008 reset_handler
  40. .text:00000000 $d
  41. rst_0.s:23 .text:00000008 $t
  42. rst_0.s:27 .text:0000000e _stop
  44. NO UNDEFINED SYMBOLS
  45. arm-none-eabi-ld -Ttext=0x00000000 -o rst_0.elf rst_0.o
  46. arm-none-eabi-nm rst_0.elf
  47. 00008010 T __bss_end__
  48. 00008010 T __bss_start
  49. 00008010 T __bss_start__
  50. 00008010 T __data_start
  51. 00008010 T __end__
  52. 00008010 T _bss_end__
  53. 00008010 T _edata
  54. 00008010 T _end
  55. 00080000 T _stack
  56. 00000000 T _start
  57. 0000000e t _stop
  58. 00000008 t reset_handler
  59. 20002000 a STACK_INIT
  60. arm-none-eabi-objcopy -O binary rst_0.elf rst_0.bin
  61. dd if=/dev/zero of=flash.bin bs=4096 count=16
  62. 16+0 records in
  63. 16+0 records out
  64. 65536 bytes (66 kB) copied, 0 seconds, Infinity B/s
  65. dd if=rst_0.bin of=flash.bin bs=4096 conv=notrunc
  66. 0+1 records in
  67. 0+1 records out
  68. 16 bytes (16 B) copied, 0 seconds, Infinity B/s
  70. U:\arm_00>

Por último, para deixarmos mais fácil a leitura das saídas das sequências de comandos, usaremos o comando @echo para sinalizar o que está sendo executado:

  1. flash.bin: rst_0.bin
  2. @echo //////////////////////////////////////////////////
  3. @echo Gerando a imagem final para carga na memoria flash
  4. @echo //////////////////////////////////////////////////
  5. dd if=/dev/zero of=flash.bin bs=4096 count=16
  6. dd if=rst_0.bin of=flash.bin bs=4096 conv=notrunc
  7. rst_0.bin: rst_0.elf
  8. @echo //////////////////////////////////////////////////
  9. @echo Extraindo o arquivo binado sem os simbolos
  10. @echo //////////////////////////////////////////////////
  11. arm-none-eabi-objcopy -O binary rst_0.elf rst_0.bin
  12. rst_0.elf: rst_0.o
  13. @echo //////////////////////////////////////////////////
  14. @echo Executando o linker
  15. @echo //////////////////////////////////////////////////
  16. arm-none-eabi-ld -Ttext=0x00000000 -o rst_0.elf rst_0.o
  17. @echo //////////////////////////////////////////////////
  18. @echo Mostrando os simbolos apos o linker
  19. @echo //////////////////////////////////////////////////
  20. arm-none-eabi-nm rst_0.elf
  21. rst_0.o: rst_0.s
  22. @echo //////////////////////////////////////////////////
  23. @echo Montando o programa assembly
  24. @echo //////////////////////////////////////////////////
  25. arm-none-eabi-as -a -o rst_0.o rst_0.s
  26. clean:
  27. @echo //////////////////////////////////////////////////
  28. @echo Eliminando os arquivos de saida
  29. @echo //////////////////////////////////////////////////
  30. rm *.bin
  31. rm *.elf
  32. rm *.o

A execução ficaria assim:

  1. U:\arm_00>make
  2. //////////////////////////////////////////////////
  3. Montando o programa assembly
  4. //////////////////////////////////////////////////
  5. arm-none-eabi-as -a -o rst_0.o rst_0.s
  6. ARM GAS rst_0.s page 1
  9. 1 // Primeiro programa para ARM Cortex-M0
  10. 2
  11. 3 .code 16 // Define c├│digo como THUMB
  12. 4 .globl _start // Necessario para o linker
  13. 5
  14. 6 .equ STACK_INIT,0x020002000
  15. 7
  16. 8 .text // Inicio da área de código
  17. 9 _start:
  18. 10
  19. 11 // Inicio do Vector Table
  20. 12
  21. 13 0000 00200020 .word STACK_INIT // Inicio da pilha
  22. 14 0004 00000000 .word reset_handler // Endereco do Reset Handler
  23. 15
  24. 16 // define o label como função para que o linker
  25. 17 // resolva como c├│digo THUMB
  26. 18
  27. 19 .type reset_handler, function
  28. 20
  29. 21 reset_handler: // inicio do tratamento do reset
  30. 22
  31. 23 0008 0320 mov r0, #3 // carrega r0 com o valor 3
  32. 24 000a 0421 mov r1, #4 // carrega r1 com o valor 4
  33. 25 000c 0A18 add r2, r1, r0 // soma r0 e r1 guardando em r2
  34. 26
  35. 27 000e FEE7 _stop: b . // loop infinito
  36. ♀ARM GAS rst_0.s page 2
  39. DEFINED SYMBOLS
  40. rst_0.s:9 .text:00000000 _start
  41. rst_0.s:6 *ABS*:20002000 STACK_INIT
  42. rst_0.s:21 .text:00000008 reset_handler
  43. .text:00000000 $d
  44. rst_0.s:23 .text:00000008 $t
  45. rst_0.s:27 .text:0000000e _stop
  47. NO UNDEFINED SYMBOLS
  48. //////////////////////////////////////////////////
  49. Executando o linker
  50. //////////////////////////////////////////////////
  51. arm-none-eabi-ld -Ttext=0x00000000 -o rst_0.elf rst_0.o
  52. //////////////////////////////////////////////////
  53. Mostrando os simbolos apos o linker
  54. //////////////////////////////////////////////////
  55. arm-none-eabi-nm rst_0.elf
  56. 00008010 T __bss_end__
  57. 00008010 T __bss_start
  58. 00008010 T __bss_start__
  59. 00008010 T __data_start
  60. 00008010 T __end__
  61. 00008010 T _bss_end__
  62. 00008010 T _edata
  63. 00008010 T _end
  64. 00080000 T _stack
  65. 00000000 T _start
  66. 0000000e t _stop
  67. 00000008 t reset_handler
  68. 20002000 a STACK_INIT
  69. //////////////////////////////////////////////////
  70. Extraindo o arquivo binado sem os simbolos
  71. //////////////////////////////////////////////////
  72. arm-none-eabi-objcopy -O binary rst_0.elf rst_0.bin
  73. //////////////////////////////////////////////////
  74. Gerando a imagem final para carga na memoria flash
  75. //////////////////////////////////////////////////
  76. dd if=/dev/zero of=flash.bin bs=4096 count=16
  77. 16+0 records in
  78. 16+0 records out
  79. 65536 bytes (66 kB) copied, 0 seconds, Infinity B/s
  80. dd if=rst_0.bin of=flash.bin bs=4096 conv=notrunc
  81. 0+1 records in
  82. 0+1 records out
  83. 16 bytes (16 B) copied, 0 seconds, Infinity B/s
  85. U:\arm_00>

Pode parecer muito esforço para algo simples mas, quando uma aplicação tem muitos fontes, o utilitário MAKE facilitará o trabalho uma vez que ele sabe quais dependências precisam ser satisfeitas apenas executando procedimentos que estão desatualizados pela data dos arquivos.
Postado por às
Marcadores: , , , ,

Nenhum comentário:

Postar um comentário

Assinar: Postar comentários (Atom)