Como posso usar um servidor de compilação com o Keil uVision4 (MDK-ARM), criar um script de compilação, usar um makefile?

Gostaria de executar compilações diárias, ou fazer check-in / confirmar compilações acionadas de projetos baseados no Keil MDK-ARM. Até agora, resolvi tudo com o recurso de arquivo em lote do IDE. Isso exige que você construa o projeto pelo menos uma vez com o IDE, depois faça o check-in do arquivo em lotes e dos arquivos associados .__ie ._iacriados pelo IDE.

Além disso, o IDE coloca muitas coisas específicas do usuário no arquivo em lotes, como a variável PATH do Windows. Isso pode se tornar um problema para vários desenvolvedores, porque o arquivo em lotes para construção pode ser alterado em cada confirmação de um desenvolvedor diferente.

Por fim, basta acompanhar os vários switches para armcc , armasm e ArmLink .

Existe uma maneira de usar um makefile mais padrão para criar projetos Keil uVision? Existe um método de converter um arquivo de projeto do uVision em um script de construção mais sustentável?

arm compiler keil

— rmaVT
fonte

Eu acho ótimo que você esteja implementando um servidor de compilação. Infelizmente, não tenho experiência com o sistema de desenvolvimento Keil, então não posso realmente ajudá-lo. Gostaria de encorajá-lo a postar uma solução, se você resolver o problema.

— semaj

Eu construo projetos Keil por meio de script em lote sem nenhuma dependência PATH (além das próprias ferramentas Keil) ou arquivos __i / _ia. Você pode compartilhar mais informações sobre isso?

— Digikata 03/04

@digikata Estou usando a opção do IDE para gerar um arquivo em lotes. Isso está descrito na documentação do Keil. Há também um método controlado por linha de comando descrito aqui , mas tive dificuldade em obter a saída apropriada do console a partir desse comando. O segundo método inicia um novo processo e oferece a opção de copiar a janela de saída em um arquivo de saída - não é um bom método para um servidor de construção.

— RmaVT

Para referência futura, o escopo desta pergunta está em uma área de sobreposição que compartilhamos com outros sites do Stack Exchange. Perguntas sobre cadeias de ferramentas específicas do incorporado, como Keil, são definitivamente bem-vindas aqui! Eles também são bem-vindos no Stack Overflow , mas não hesite em perguntar em qualquer lugar.

— Kevin Vermeer

@ KevinVermeer - Sim, eu estava prestes a dizer a mesma coisa. rmaVT, você pode encontrar navegando pelas perguntas com a tag "keil" no SO, tão educacionais quanto as perguntas com a tag "keil" no EE SE .

— Davidcary

Respostas:

Este é o melhor método que inventei recentemente:

Nas opções de construção, selecione criar arquivo em lote.

Quando você inicia uma compilação a partir do IDE, um arquivo em lotes e vários arquivos de texto são criados com base nas opções definidas no IDE. Você precisa acompanhar esses arquivos gerados pelo IDE no controle de origem:

*.bastão
* .ini
*.__Eu
*._I a
* .lnp
* .sct

Então foo.bat pode ser iniciado a partir de um script de construção.

Embora isso crie arquivos extras que precisam ser rastreados no controle de origem, se você deseja criar de forma confiável a partir do arquivo em lotes gerado, remove a necessidade de confiar no arquivo de projeto Keil (foo.uvproj) e no IDE. Acho mais fácil comparar diferenças e, assim, rastrear alterações nos arquivos de texto gerados (* .__i) que contêm sinalizadores de compilador do que no arquivo .uvproj. Além disso, o arquivo em lotes chama diretamente as várias ferramentas, armasm, armcc, armlink. Isso fornece a saída direta de cada uma dessas etapas, bem como um potencial aparentemente melhor para migrar um projeto para uma cadeia de ferramentas diferente no futuro, se necessário.

Percebo que essa resposta parece muito com a minha pergunta original, mas realmente não conheço uma maneira melhor de executar uma compilação com script com as ferramentas de Keil. Pedi para ver o que poderia surgir dos outros. Não discordo completamente da resposta de @digikata, mas prefiro ter sinalizadores de compilador e o mapa de memória em um formato mais fácil para rastrear e usar mais ferramentas de estilo unix para compilação, em vez de iniciar uma compilação tudo em um com o IDE. Acho que a compilação do multifuncional do IDE funciona bem na minha estação de trabalho, mas não no servidor de compilação.

EDIT : O servidor de compilação é executado no Windows Server 2003. Devo confessar que desisti de usar a interface da linha de comando IDE em vez de um arquivo em lotes. Isso se tornou muito difícil de gerenciar.

— rmaVT
fonte

Uma pergunta sobre este trabalho - qual sistema operacional seu servidor de construção está executando? Linux, Windows 7, Windows Server 2003, Windows Server 2008?

— CrimsonX

Obrigado por responder a pergunta! Parece que a cadeia de ferramentas de braço funciona no Windows Server 2003 e 2008 R2, conforme a Documentação de Keil . Uma pergunta de acompanhamento referente à sua edição: Como você lida com as alterações no arquivo uvproj (por exemplo, adicionando novos arquivos ao projeto para compilação)? Você precisa alterar manualmente as opções de compilação em um arquivo promovido para o servidor de construção?

— CrimsonX

Você precisa colocar o arquivo .uvproj sob controle de origem. Isso funciona muito bem, embora algumas preferências do usuário ainda sejam deixadas no arquivo, apesar do arquivo .userxxxxx que também é gerado. O servidor de compilação só precisa abrir o mesmo "projeto" e compilá-lo.

— RmaVT

Eu chamo o Keil IDE via linha de comando para criar (não um arquivo em lotes gerado) de dentro de um Makefile. Geralmente, é melhor bloquear os arquivos do projeto por meio do scm ou fazer uma cópia de construção de referência renomeando os nomes relevantes do projeto ao fazer isso.

O IDE fica perfeitamente feliz em trabalhar com arquivos de projeto somente leitura, portanto, se você os bloquear, o mais irritante é que você precisará desbloqueá-los para alterar as configurações, salvar e fazer o check-in novamente. Se você estiver em uma estabilidade estável ponto no projeto, isso é bem menor - até desejável.

Se você fizer uma cópia de referência, a compilação tenderá a ser interrompida conforme as configurações do projeto forem alteradas - especialmente quando os arquivos do projeto forem adicionados ou descartados da compilação. Capturar explicitamente essas alterações não é necessariamente ruim, mas é uma etapa extra necessária para manter as compilações.

De qualquer forma, redirecionar a saída para um arquivo de log através da opção "-o" permite acessar o log de saída completo. O log não sai uma linha de cada vez, mas parece estar lá. (Na verdade, analiso o formato de erro Keil no GNU fmt para integração com o ambiente eclipse CDT. Isso me permite pular diretamente para erros / avisos após a compilação)

A compilação da linha de comando também gera os arquivos __i, __ia, para que eles também não precisem entrar no controle de versão do servidor de compilação.

Espero que isto ajude.

— Digikata
fonte