STMicroelectronics Série STM32WBA Primeiros passos

Informações do produto

Especificações:

• Nome do produto: Pacote MCU STM32CubeWBA
• Fabricante: STMicroeletrônica
• Compatibilidade: Microcontroladores da série STM32WBA
• Licenciamento: Licença BSD de código aberto

Instruções de uso do produto

Principais características do pacote STM32CubeWBA MCU:
O pacote STM32CubeWBA MCU fornece todos os componentes de software embarcados necessários para o desenvolvimento de aplicações em microcontroladores da série STM32WBA. É altamente portátil dentro da série STM32 e vem com APIs HAL e LL, ex.amparquivos e componentes de middleware.

Arquitetura acabadaview:
A arquitetura do pacote STM32CubeWBA MCU consiste em três níveis – aplicativos, biblioteca e componentes baseados em protocolo, camada de abstração de hardware, drivers BSP, drivers principais e APIs de camada baixa.

Perguntas frequentes

• O que está incluído no pacote MCU STM32CubeWBA?
  O pacote inclui APIs de camada baixa (LL) e camada de abstração de hardware (HAL), ex.amparquivos, aplicativos, componentes de middleware como FileX/LevelX, NetX Duo, bibliotecas mbed-crypto e muito mais.
• O pacote STM32CubeWBA MCU é compatível com o gerador de código STM32CubeMX?
  Sim, o pacote é totalmente compatível com o gerador de código STM32CubeMX para geração de código de inicialização.

Introdução

• STM32Cube é uma iniciativa original da STMicroelectronics para melhorar significativamente a produtividade do designer, reduzindo o esforço, tempo e custo de desenvolvimento. STM32Cube cobre todo o portfólio STM32.
  STM32Cube inclui:
  • Um conjunto de ferramentas de desenvolvimento de software de fácil utilização para cobrir o desenvolvimento do projeto desde a concepção até a realização, entre as quais estão:
    • STM32CubeMX, uma ferramenta de configuração de software gráfico que permite a geração automática de código de inicialização C usando assistentes gráficos
    • STM32CubeIDE, uma ferramenta de desenvolvimento tudo-em-um com configuração de periféricos, geração de código, compilação de código e recursos de depuração
    • STM32CubeCLT, um conjunto completo de ferramentas de desenvolvimento de linha de comando com compilação de código, programação de placa e recursos de depuração
    • STM32CubeProgrammer (STM32CubeProg), uma ferramenta de programação disponível nas versões gráfica e de linha de comando
    • STM32CubeMonitor (STM32CubeMonitor, STM32CubeMonPwr, STM32CubeMonRF, STM32CubeMonUCPD), poderosas ferramentas de monitoramento para ajustar o comportamento e o desempenho de aplicativos STM32 em tempo real
  • Pacotes STM32Cube MCU e MPU, plataformas abrangentes de software incorporado específicas para cada série de microcontroladores e microprocessadores (como STM32CubeWBA para a série STM32WBA), que incluem:
    • STM32Cube hardware abstraction layer (HAL), garantindo portabilidade maximizada em todo o portfólio STM32
    • APIs de camada baixa STM32Cube, garantindo o melhor desempenho e pegadas com um alto grau de controle do usuário sobre o hardware
    • Um conjunto consistente de componentes de middleware, como ThreadX, FileX / LevelX, NetX Duo, USBX, biblioteca de toque, mbed-crypto, TFM, MCUboot, OpenBL e STM32_WPAN (incluindo Bluetooth® Low Energy profilese serviços, Mesh, Zigbee®, OpenThread, Matter e camada MAC 802.15.4)
    • Todos os utilitários de software embutidos com conjuntos completos de periféricos e aplicativos exampos
  • Pacotes de expansão STM32Cube, que contêm componentes de software incorporados que complementam as funcionalidades dos pacotes STM32Cube MCU e MPU com:
    • Extensões de middleware e camadas de aplicativos
    • Examparquivos em execução em algumas placas de desenvolvimento STMicroelectronics específicas
• Este manual do usuário descreve como começar a usar o pacote STM32CubeWBA MCU.
  • A Seção 2 Principais recursos do STM32CubeWBA descreve os principais recursos do pacote STM32CubeWBA MCU.
  • Seção 3 Arquitetura STM32CubeWBA acimaview fornece um excessoview da arquitetura STM32CubeWBA e da estrutura do pacote MCU.

informações gerais

O pacote STM32CubeWBA MCU é executado em microcontroladores STM32 de 32 bits baseados no processador Arm® Cortex®-M33 com Arm® TrustZone® e FPU.
Observação: Arm e TrustZone são marcas registradas da Arm Limited (ou de suas subsidiárias) nos Estados Unidos e / ou em outro lugar.

Principais características do STM32CubeWBA

• O pacote STM32CubeWBA MCU é executado em microcontroladores STM32 de 32 bits baseados no processador Arm® Cortex®-M33 com TrustZone® e FPU.
• O STM32CubeWBA reúne, em um único pacote, todos os componentes genéricos de software embarcado necessários para desenvolver uma aplicação para os microcontroladores da série STM32WBA. Em linha com a iniciativa STM32Cube, este conjunto de componentes é altamente portátil, não apenas dentro dos microcontroladores da série STM32WBA, mas também para outras séries STM32.
• O STM32CubeWBA é totalmente compatível com o gerador de código STM32CubeMX, para gerar código de inicialização. O pacote inclui APIs de camada baixa (LL) e camada de abstração de hardware (HAL) que cobrem o hardware do microcontrolador, juntamente com um extenso conjunto de examparquivos rodando em placas STMicroelectronics. As APIs HAL e LL estão disponíveis em uma licença BSD de código aberto para conveniência do usuário.
• O pacote STM32CubeWBA MCU também contém um componente de middleware abrangente construído em torno do middleware Microsoft® Azure® RTOS e outras pilhas internas e de código aberto, com o ex correspondenteamples.
• Eles vêm com termos de licença gratuitos e fáceis de usar:
  • Azure® RTOS integrado e completo: Azure® RTOS ThreadX
  • Implementação CMSIS-RTOS com Azure® RTOS ThreadX
  • Pilhas de host e dispositivos USB com muitas classes: Azure® RTOS USBX
  • Avançado file camada de tradução do sistema e flash: FileX / NívelX
  • Pilha de rede de nível industrial: otimizada para desempenho com muitos protocolos IoT: NetX Duo
  • OpenBootloader
  • Solução de integração Arm® Trusted Firmware-M (TF‑M)
  • bibliotecas mbed-crypto
  • Biblioteca ST Networkok
  • Solução de biblioteca de detecção de toque STMTouch
• Vários aplicativos e demonstrações que implementam todos esses componentes de middleware também são fornecidos no pacote STM32CubeWBA MCU.
• O layout do componente do pacote STM32CubeWBA MCU é ilustrado na Figura 1. Componentes do pacote STM32CubeWBA MCU.

  

Arquitetura STM32CubeWBA acimaview

A solução do pacote STM32CubeWBA MCU é construída em torno de três níveis independentes que interagem facilmente conforme descrito na Figura 2. Arquitetura do pacote STM32CubeWBA MCU.

Nível 0

Este nível é dividido em três subcamadas:

• Pacote de apoio ao conselho (BSP).
• Camada de abstração de hardware (HAL):
  • Drivers periféricos HAL
  • Drivers de camada baixa
• Uso básico de periféricos examples.

Pacote de suporte ao conselho (BSP)
Esta camada oferece um conjunto de APIs relativas aos componentes de hardware nas placas de hardware (como drivers LCD, Áudio,\ microSD™ e MEMS). É composto por duas partes:

• Driver de componente:
  Este driver está relacionado ao dispositivo externo da placa e não ao dispositivo STM32. O driver do componente fornece APIs específicas para os componentes externos do driver BSP e pode ser portátil em qualquer outra placa.
• Motorista BSP:
  O driver BSP permite vincular os drivers dos componentes a uma placa específica e fornece um conjunto de recursos fáceis de usar.
  APIs. A regra de nomenclatura da API é BSP_FUNCT_Action().
  Examparquivo: BSP_LED_Init(), BSP_LED_On()
  O BSP é baseado em uma arquitetura modular que permite fácil portabilidade para qualquer hardware, apenas implementando rotinas de baixo nível.

Camada de abstração de hardware (HAL) e camada baixa (LL)
O STM32CubeWBA HAL e LL são complementares e cobrem uma ampla gama de requisitos de aplicação:

• Os drivers HAL oferecem APIs altamente portáteis e orientadas a funções de alto nível. Eles ocultam o MCU e a complexidade periférica para o usuário final.
  Os drivers HAL fornecem APIs genéricas de múltiplas instâncias orientadas a recursos, que simplificam a implementação de aplicativos do usuário, fornecendo processos prontos para uso. Para exampPor exemplo, para os periféricos de comunicação (I2S, UART e outros), fornece APIs que permitem inicializar e configurar o periférico, gerenciar a transferência de dados com base em polling, interrupção ou processo DMA e tratar erros de comunicação que possam surgir durante a comunicação. As APIs do driver HAL são divididas em duas categorias:
  1. APIs genéricas, que fornecem funções comuns e genéricas para todos os microcontroladores da série STM32.
  2. APIs de extensão, que fornecem funções específicas e personalizadas para uma família específica ou um número de peça específico.
• As APIs de camada inferior fornecem APIs de baixo nível no nível do registro, com melhor otimização, mas menos portabilidade.
  • Eles exigem um conhecimento profundo das especificações do MCU e dos periféricos.
  • Os drivers LL são projetados para oferecer uma camada rápida, leve e orientada para especialistas, mais próxima do hardware do que o HAL. Ao contrário do HAL, as APIs LL não são fornecidas para periféricos onde o acesso otimizado não é um recurso importante ou para aqueles que exigem configuração pesada de software ou pilha complexa de nível superior.
  • O recurso dos drivers LL:
    • Um conjunto de funções para inicializar recursos principais periféricos de acordo com os parâmetros especificados nas estruturas de dados.
    • Um conjunto de funções para preencher estruturas de dados de inicialização com os valores de redefinição correspondentes a cada campo.
    • Função para desinicialização de periféricos (registros periféricos restaurados aos seus valores padrão).
    • Um conjunto de funções inline para acesso direto e atômico ao registro.
    • Total independência de HAL e capacidade de uso em modo autônomo (sem drivers HAL).
    • Cobertura total dos recursos periféricos suportados.

Uso básico de periféricos exampos
Esta camada envolve o examparquivos construídos sobre os periféricos STM32 usando apenas os recursos HAL e BSP.

Nível 1

Este nível é dividido em duas subcamadas:

• Componentes de middleware
• Examparquivos baseados nos componentes de middleware

Componentes de middleware

• O middleware é um conjunto de bibliotecas que cobrem Bluetooth® Low Energy (Linklayer, HCI, Stack), Thread®, Zigbee®,
• Matter, OpenBootloader, Microsoft® Azure® RTOS, TF‑M, MCUboot e mbed-crypto.
• A interação horizontal entre os componentes desta camada é feita chamando as APIs apresentadas.
• A interação vertical com os drivers de camada inferior é feita através de callbacks específicos e macros estáticas implementadas na interface de chamada do sistema da biblioteca.
• Os principais recursos de cada componente de middleware são os seguintes:
  • RTOS do Microsoft® Azure®
    • Azure® RTOS ThreadX: um sistema operacional em tempo real (RTOS), projetado para sistemas incorporados com dois modos funcionais.
      • Modo comum: funcionalidades comuns do RTOS, como gerenciamento e sincronização de threads, gerenciamento de pool de memória, mensagens e manipulação de eventos.
      • Modo de módulo: um modo de usuário avançado que permite carregar e descarregar módulos ThreadX pré-vinculados dinamicamente por meio de um gerenciador de módulo.
    • NetX Duo
    • FileX
    • USBX
  • Bluetooth® Low Energy (BLE): Implementa o protocolo Bluetooth® Low Energy para as camadas Link e Stack.
  • MCUboot (software de código aberto)
  • Protocolos Zigbee® para pilha e clusters relacionados.
  • Pilha de protocolo Thread® e camada de link.
  • Firmware-M confiável Arm®, TF-M (software de código aberto): Implementação de referência da arquitetura de segurança da plataforma Arm® (PSA) para TrustZone® com os serviços seguros associados.
  • mbed-crypto (software de código aberto): O middleware mbed-crypto fornece uma implementação de API de criptografia PSA.
  • Biblioteca de detecção de toque STM32: Solução robusta de detecção de toque capacitiva STMTouch, compatível com sensores de proximidade, teclas de toque, lineares e rotativos. É baseado em um princípio comprovado de aquisição de transferência de carga superficial.

Examparquivos baseados nos componentes de middleware
Cada componente de middleware vem com um ou mais examparquivos (também chamados de aplicativos) mostrando como usá-los. Integração exampTambém são fornecidos arquivos que usam vários componentes de middleware.

Pacote de firmware STM32CubeWBA encerradoview

Dispositivos e hardware da série STM32WBA suportados

• STM32Cube oferece uma camada de abstração de hardware (HAL) altamente portátil construída em torno de uma arquitetura genérica. Ele permite o princípio de camadas construídas, como usar a camada de middleware para implementar suas funções sem saber em profundidade qual MCU é usado. Isso melhora a reutilização do código da biblioteca e garante fácil portabilidade para outros dispositivos.
• Além disso, graças à sua arquitetura em camadas, o STM32CubeWBA oferece suporte completo para todas as séries STM32WBA.
• O usuário só precisa definir a macro correta em stm32wbaxx.h.
• A Tabela 1 mostra a macro a ser definida dependendo do dispositivo da série STM32WBA utilizado. Esta macro também deve ser definida no pré-processador do compilador.
  Tabela 1. Macros para a série STM32WBA

  Macro definida em stm32wbaxx.h	Dispositivos da série STM32WBA
  stm32wba52xx	STM32WBA52CGU6, STM32WBA52KGU6, STM32WBA52CEU6, STM32WBA52KEU6
  stm32wba55xx	STM32WBA55CGU6, STM32WBA55CGU6U, STM32WBA55CGU7, STM32WBA55CEU6, STM32WBA55CEU7

   
• STM32CubeWBA apresenta um rico conjunto de examparquivos e aplicativos em todos os níveis, facilitando a compreensão e o uso de qualquer driver HAL ou componentes de middleware. Esses exampOs arquivos são executados nas placas STMicroelectronics listadas na Tabela 2.
  Tabela 2. Placas para a série STM32WBA

  Quadro	Dispositivos suportados pela placa STM32WBA
  NÚCLEO-WBA52CG	STM32WBA52CGU6
  NÚCLEO-WBA55CG	STM32WBA55CGU6
  STM32WBA55-DK1	STM32WBA55CGU7

• O pacote STM32CubeWBA MCU pode ser executado em qualquer hardware compatível. O usuário simplesmente atualiza os drivers BSP para portar o ex fornecidoamparquivos na placa, se esta tiver os mesmos recursos de hardware (como LED, display LCD e botões).

Pacote de firmware encerradoview

• A solução do pacote STM32CubeWBA é fornecida em um único pacote zip com a estrutura mostrada na Figura 3. Estrutura do pacote de firmware STM32CubeWBA.

  

• Para cada placa, um conjunto de examparquivos são fornecidos com projetos pré-configurados para conjuntos de ferramentas EWARM, MDK-ARM e STM32CubeIDE.
• Figura 4. STM32CubeWBA exampacabouview mostra a estrutura do projeto das placas NUCLEO‑WBA52CG, NUCLEO-WBA55CG e STM32WBA55G-DK1.

  

• O exampOs arquivos são classificados dependendo do nível STM32Cube ao qual se aplicam e são nomeados da seguinte forma:
  • Nível 0 examparquivos são chamados de Exampeles, Examples_LL e Examples_MIX. Eles usam respectivamente drivers HAL, drivers LL e uma combinação de drivers HAL e LL sem qualquer componente de middleware.
  • Nível 1 examparquivos são chamados de Aplicativos. Eles fornecem casos de uso típicos de cada componente de middleware. Qualquer aplicativo de firmware para uma determinada placa pode ser construído rapidamente graças aos projetos de modelo disponíveis nos diretórios Templates e Templates_LL.

Projetos habilitados para TrustZone®

• Ex habilitado para TrustZone®amples nomes contêm o prefixo _TrustZone. A regra é aplicada também para Aplicativos (exceto para TFM e SBSFU, que são nativos para TrustZone®).
• Ex habilitado para TrustZone®ampOs arquivos e aplicativos são fornecidos com uma estrutura de multiprojetos composta de subprojetos seguros e não seguros, conforme apresentado na Figura 5. Estrutura de projetos multiprojetos seguros e não seguros.
• Os projetos habilitados para TrustZone® são desenvolvidos de acordo com o modelo de dispositivo CMSIS-5, estendido para incluir o cabeçalho de particionamento do sistema file partição_ .h, que é o principal responsável pela configuração da unidade de atributos seguros (SAU), da FPU e da atribuição de interrupções seguras/não seguras no estado de execução seguro.
• Esta configuração é executada na função CMSIS SystemInit() segura, que é chamada na inicialização antes de entrar na função main() do aplicativo seguro. Consulte a documentação do Arm® TrustZone®-M sobre diretrizes de software.

  

• O pacote de firmware do pacote STM32CubeWBA fornece particionamento de memória padrão na partição _ .h fileestá disponível em: \Drivers\CMSIS\Device\ST\STM32WBAxx\Include\T emplates
• Nestas partições files, o SAU fica desabilitado por padrão. Consequentemente, o mapeamento de memória IDAU é utilizado para atribuição de segurança. Consulte a figura Particionamento seguro/não seguro usando tecnologia TrustZone® no manual de referência RM0495.
• Se o usuário ativar o SAU, uma configuração padrão de regiões SAU será predefinida na partição fileé o seguinte:
  • Região SAU 0: 0x08080000 – 0x081FFFFF (metade segura não segura da memória flash (512 Kbytes))
  • Região SAU 1: 0x0BF88000 – 0x0BF97FFF (memória do sistema não segura)
  • Região SAU 2: 0x0C07E000 – 0x0C07FFFF (chamável seguro e não seguro)
  • Região SAU 3: 0x20010000 – 0x2001FFFF (SRAM2 não segura (64 Kbytes))
  • Região SAU 4: 0x40000000 – 0x4FFFFFFF (memória mapeada periférica não segura)
• Para corresponder ao particionamento padrão, os dispositivos da série STM32WBAxx devem ter os seguintes bytes de opção do usuário definidos:
  • TZEN = 1 (dispositivo habilitado para TrustZone®)
  • SECWM1_PSTRT = 0x0 SECWM1_PEND = 0x3F (64 de 128 páginas de memória flash interna configuradas como seguras) Observação: A memória flash interna é totalmente segura por padrão em TZEN = 1. Os bytes de opção do usuário SECWM1_PSTRT/ SECWM1_PEND devem ser configurados de acordo com a aplicação configuração de memória (regiões SAU, se SAU estiver habilitado). Vinculador de projetos de aplicativos seguros/não seguros files também devem estar alinhados.
• Todos os exampeles têm a mesma estrutura:
  • Pasta \Inc contendo todos os cabeçalhos files.
  • Pasta Src contendo o código fonte.
  • Pastas \EWARM, \MDK-ARM e \STM32CubeIDE contendo o projeto pré-configurado para cada conjunto de ferramentas.
  • readme.md e readme.html descrevendo o example comportamento e ambiente necessário para fazê-lo funcionar.
  • COI file que permite aos usuários abrir a maior parte do firmware examparquivos dentro do STM32CubeMX.

Primeiros passos com STM32CubeWBA

Executando um primeiro ex HALample

Esta seção explica como é simples executar o primeiro examparquivo dentro do STM32CubeWBA. Ele usa como ilustração a geração de um simples alternador de LED rodando na placa NUCLEO-WBA52CG:

1. Baixe o pacote STM32CubeWBA MCU.
2. Descompacte-o em um diretório de sua preferência.
3. Certifique-se de não modificar a estrutura do pacote mostrada na Figura 1. Também é recomendado copiar o pacote em um local próximo ao seu volume raiz (ou seja, C:\ST ou G:\Tests), pois alguns IDEs encontram problemas quando o caminho o comprimento é muito longo.

Executando um primeiro ex habilitado para TrustZone®ample

• Antes de carregar e executar um ex habilitado para TrustZone®ample, é obrigatória a leitura do exampleia-me file para qualquer configuração específica, o que garante que a segurança esteja habilitada conforme descrito na Seção 4.2.1 Projetos habilitados para TrustZone® (TZEN=1 (byte de opção do usuário)).
  1. Navegue até \Projetos\NUCLEO-WBA52CG\Examples.
  2. Abra \GPIO e depois as pastas \GPIO_IOToggle_TrustZone.
  3. Abra o projeto com seu conjunto de ferramentas preferido. Um rápido fimview sobre como abrir, construir e administrar um exampO arquivo com os conjuntos de ferramentas suportados é fornecido abaixo.
  4. Reconstrua em sequência todos os projetos seguros e não seguros filese carregue as imagens seguras e não seguras na memória de destino.
  5. Execute o example: regularmente, o aplicativo seguro alterna o LD2 a cada segundo, e o aplicativo não seguro alterna o LD3 duas vezes mais rápido. Para obter mais detalhes, consulte o leia-me file do exampeu.
• Para abrir, construir e executar um examparquivo com os conjuntos de ferramentas suportados, siga as etapas abaixo:
  • EQUENTE:
    1. Sob o example, abra a subpasta \EWARM.
    2. Inicie o espaço de trabalho Project.eww
    3. Reconstrua o projeto seguro xxxxx_S files: [Projeto]>[Reconstruir tudo].
    4. Defina o projeto não seguro xxxxx_NS como aplicativo ativo (clique com o botão direito no projeto xxxxx_NS [Definir como ativo])
    5. Reconstrua o projeto não seguro xxxxx_NS files: [Projeto]>[Reconstruir tudo].
    6. Atualize o binário não seguro com [Project]>[Download]>[Download active application] .
    7. Defina o aplicativo xxxxx_S como ativo (clique com o botão direito no projeto xxxxx_S [Definir como ativo].
    8. Atualize o binário seguro com [Download and Debug] (Ctrl+D).
    9. Execute o programa: [Depurar]>[Go(F5)]
  • MDK-ARM:
    1. Abra a cadeia de ferramentas \MDK-ARM.
    2. Abra o espaço de trabalho Multiprojetos file Projeto.uvmpw.
    3. Selecione o projeto xxxxx_s como aplicativo ativo ([Definir como projeto ativo]).
    4. Construa o projeto xxxxx_s.
    5. Selecione o projeto xxxxx_ns como projeto ativo ([Definir como projeto ativo]).
    6. Construa o projeto xxxxx_ns.
    7. Carregue o binário não seguro ([F8]). Isso baixa \MDK-ARM\xxxxx_ns\Exe\xxxxx_ns.axf para a memória flash)
    8. Selecione o projeto Project_s como projeto ativo ([Definir como projeto ativo]).
    9. Carregue o binário seguro ([F8]). Isso baixa \MDK-ARM\xxxxx_s\Exe\xxxxx_s.axf para a memória flash).
    10. Execute o exampeu.
  • STM32CubeIDE:
    1. Abra o conjunto de ferramentas STM32CubeIDE.
    2. Abra o espaço de trabalho Multiprojetos file .projeto.
    3. Recrie o projeto xxxxx_Secure.
    4. Recrie o projeto xxxxx_NonSecure.
    5. Inicie o aplicativo [Debug as STM32 Cortex-M C/C++] para o projeto seguro.
    6. Na janela [Editar configuração], selecione o painel [Inicializar] e adicione carregar a imagem e os símbolos do projeto não seguro.
       Importante: O projeto não seguro deve ser carregado antes do projeto seguro.
    7. Clique OK].
    8. Execute o example na perspectiva de depuração.

Executando um primeiro ex desativado do TrustZone®ample

• Antes de carregar e executar um TrustZone® desativado example, é obrigatória a leitura do exampleia-me file para qualquer configuração específica. Caso não haja menções específicas, certifique-se de que o dispositivo da placa esteja com a segurança desabilitada (TZEN=0 (byte de opção do usuário)). Veja FAQ para fazer a regressão opcional para TZEN = 0
  1. Navegue até \Projetos\NUCLEO-WBA52CG\Examples.
  2. Abra \GPIO e depois as pastas \GPIO_EXTI.
  3. Abra o projeto com seu conjunto de ferramentas preferido. Um rápido fimview sobre como abrir, construir e administrar um exampO arquivo com os conjuntos de ferramentas suportados é fornecido abaixo.
  4. Reconstruir tudo filese carregue sua imagem na memória de destino.
  5. Execute o examparquivo: Cada vez que o botão [USER] é pressionado, o LED LD1 alterna. Para obter mais detalhes, consulte o leia-me file do exampeu.
• Para abrir, construir e executar um examparquivo com os conjuntos de ferramentas suportados, siga as etapas abaixo:
  • EQUENTE:
    1. Sob o example, abra a subpasta \EWARM.
    2. Inicie o espaço de trabalho Project.eww (o nome do espaço de trabalho pode mudar de um example para outro).
    3. Reconstruir tudo files: [Projeto]>[Reconstruir tudo].
    4. Carregue a imagem do projeto: [Project]>[Debug].
    5. Execute o programa: [Depurar]>[Go (F5)].
  • MDK-ARM:
    1. Sob o example, abra a subpasta \MDK-ARM.
    2. Inicie o espaço de trabalho Project.uvproj (o nome do espaço de trabalho pode mudar de um example para outro).
    3. Reconstruir tudo files:[Projeto]>[Reconstruir todos os destinos files].
    4. Carregue a imagem do projeto: [Debug]>[Start/Stop Debug Session].
    5. Execute o programa: [Depurar]>[Executar (F5)].
  • STM32CubeIDE:
    1. Abra o conjunto de ferramentas STM32CubeIDE.
    2. Clique em [File]>[Switch Workspace]>[Other] e navegue até o diretório do espaço de trabalho STM32CubeIDE.
    3. Clique em [File]>[Importar] , selecione [Geral]>[Projetos existentes no espaço de trabalho] e clique em [Avançar].
    4. Navegue até o diretório do espaço de trabalho STM32CubeIDE e selecione o projeto.
    5. Reconstruir todo o projeto files: Selecione o projeto na janela [Project Explorer] e clique no menu [Project]>[Build project].
    6. Execute o programa: [Executar]>[Depurar (F11)]

Desenvolvendo um aplicativo personalizado

Observação: O software deve habilitar o cache de instruções (ICACHE) para obter uma execução em estado de espera 0 da memória flash e atingir o desempenho máximo e um melhor consumo de energia.

Usando STM32CubeMX para desenvolver ou atualizar um aplicativo

• No pacote STM32CubeWBA MCU, quase todos os projetos exampOs arquivos são gerados com a ferramenta STM32CubeMX para inicializar o sistema, periféricos e middleware.
• O uso direto de um projeto existente exampO arquivo da ferramenta STM32CubeMX requer STM32CubeMX 6.10.0 ou superior:
  • Após a instalação do STM32CubeMX, abra e se necessário atualize um projeto proposto. A maneira mais simples de abrir um projeto existente é clicar duas vezes no arquivo *.ioc file para que STM32CubeMX abra automaticamente o projeto e sua fonte files.
  • STM32CubeMX gera o código-fonte de inicialização de tais projetos. O código fonte principal da aplicação está contido nos comentários “USER CODE BEGIN” e “USER CODE END”. Caso a seleção e configuração do IP sejam modificadas, o STM32CubeMX atualiza a parte de inicialização do código, mas preserva o código-fonte principal do aplicativo.
• Para desenvolver um projeto customizado no STM32CubeMX, siga o passo a passo:
  1. Selecione o microcontrolador STM32 que corresponda ao conjunto necessário de periféricos.
  2. Configure todo o software embarcado necessário usando um solucionador de conflitos de pinagem, um auxiliar de configuração de árvore de relógio, uma calculadora de consumo de energia e o utilitário que executa configuração de periféricos MCU (como GPIO ou USART) e pilhas de middleware (como USB).
  3. Gere o código C de inicialização com base na configuração selecionada. Este código está pronto para uso em vários ambientes de desenvolvimento. O código do usuário é mantido na próxima geração de código.
• Para obter mais informações sobre STM32CubeMX, consulte o manual do usuário STM32CubeMX para configuração STM32 e geração de código C de inicialização (UM1718).
• Para obter uma lista dos projetos disponíveis examparquivos para STM32CubeWBA, consulte a nota de aplicação do firmware STM32Cube examparquivos para a série STM32WBA (AN5929).

Aplicativos de driver

Aplicação HAL
Esta seção descreve as etapas necessárias para criar um aplicativo HAL personalizado usando STM32CubeWBA:

1. Criar um projeto
   • Para criar um novo projeto, comece a partir do projeto modelo fornecido para cada quadro em \Projetos\ \Modelos ou de qualquer projeto disponível em \Projetos\ \Exemplos ou \Projetos\ \Aplicativos (onde refere-se ao nome da placa, como STM32CubeWBA).
   • O projeto Template fornece uma função de loop principal vazia. No entanto, é um bom ponto de partida para compreender as configurações do projeto STM32CubeWBA. O modelo possui as seguintes características:
     • Ele contém o código-fonte HAL, CMSIS e drivers BSP, que são o conjunto mínimo de componentes necessários para desenvolver um código em uma determinada placa.
     • Ele contém os caminhos incluídos para todos os componentes do firmware.
     • Define os dispositivos da série STM32WBA suportados, permitindo que os drivers CMSIS e HAL sejam configurados corretamente.
     • Ele fornece ao usuário pronto para uso fileestá pré-configurado conforme mostrado abaixo:
       HAL inicializado com a base de tempo padrão com Arm® core SysTick. SysTick ISR implementado para propósito HAL_Delay().
       Observação: Ao copiar um projeto existente para outro local, certifique-se de que todos os caminhos incluídos estejam atualizados.
2. Adicione o middleware necessário ao projeto do usuário (opcional)
   Para identificar a fonte files a serem adicionados ao projeto file lista, consulte a documentação fornecida para cada middleware. Consulte os aplicativos em \Projects\STM32xxx_yyy\Applications\ (onde refere-se à pilha de middleware, como ThreadX) para saber qual fonte files e caminhos de inclusão devem ser adicionados.
3. Configurar os componentes do firmware
   Os componentes HAL e de middleware oferecem um conjunto de opções de configuração em tempo de construção usando macros #define declaradas em um cabeçalho file. Uma configuração de modelo file é fornecido dentro de cada componente, que deve ser copiado para a pasta do projeto (geralmente a configuração file é denominado xxx_conf_template.h, a palavra _template precisa ser removida ao copiá-lo para a pasta do projeto). A configuração file fornece informações suficientes para compreender o impacto de cada opção de configuração. Informações mais detalhadas estão disponíveis na documentação fornecida para cada componente.
4. Inicie a biblioteca HAL
   Após saltar para o programa principal, o código da aplicação deve chamar a API HAL_Init() para inicializar a biblioteca HAL, que realiza as seguintes tarefas:
   • Configuração da pré-busca da memória flash e prioridade de interrupção do SysTick (através de macros definidas em st m32wbaxx_hal_conf.h).
   • Configuração do SysTick para gerar uma interrupção a cada milissegundo na prioridade de interrupção do SysTick TICK_INT_PRIO definida em stm32wbaxx_hal_conf.h.
   • Configuração da prioridade do grupo NVIC como 0.
   • Chamada da função de retorno de chamada HAL_MspInit() definida no usuário stm32wbaxx_hal_msp.c file para executar inicializações globais de hardware de baixo nível.
5. Configurar o relógio do sistema
   A configuração do relógio do sistema é feita chamando as duas APIs descritas abaixo:
   • HAL_RCC_OscConfig(): esta API configura os osciladores internos e externos. O usuário escolhe configurar um ou todos os osciladores.
   • HAL_RCC_ClockConfig(): esta API configura a origem do relógio do sistema, a latência da memória flash e os pré-escaladores AHB e APB.
6. Inicialize o periférico
   • Primeiro escreva a função periférica HAL_PPP_MspInit. Proceda da seguinte forma:
     • Habilite o relógio periférico.
     • Configure os GPIOs periféricos.
     • Configure o canal DMA e habilite a interrupção DMA (se necessário).
     • Habilite a interrupção periférica (se necessário).
   • Edite stm32xxx_it.c para chamar os manipuladores de interrupção necessários (periférico e DMA), se necessário.
   • Escreva funções de retorno de chamada completas do processo, se uma interrupção periférica ou DMA for planejada para ser usada.
   • No usuário main.c file, inicialize a estrutura do identificador do periférico e chame a função HAL_PPP_Init() para inicializar o periférico.
7. Desenvolva um aplicativo
   • Neste stage, o sistema está pronto e o desenvolvimento do código do aplicativo do usuário pode ser iniciado.
   • O HAL fornece APIs intuitivas e prontas para uso para configurar o periférico. Ele suporta polling, interrupções e um modelo de programação DMA, para acomodar quaisquer requisitos de aplicação. Para obter mais detalhes sobre como usar cada periférico, consulte o rico exampconjunto de arquivos fornecido no pacote STM32CubeWBA MCU.
     Cuidado: Na implementação HAL padrão, o temporizador SysTick é usado como base de tempo: ele gera interrupções em intervalos de tempo regulares. Se HAL_Delay() for chamado a partir do processo ISR periférico, certifique-se de que a interrupção SysTick tenha uma prioridade mais alta (numericamente menor) que a interrupção periférica. Caso contrário, o processo ISR do chamador será bloqueado. Funções que afetam as configurações da base de tempo são declaradas como __weak para tornar possível a substituição no caso de outras implementações no usuário file (usando um temporizador de uso geral, por ex.amparquivo ou outra fonte de tempo). Para obter mais detalhes, consulte o exemplo HAL_TimeBaseampeu.

Aplicação LL
Esta seção descreve as etapas necessárias para criar um aplicativo LL personalizado usando STM32CubeWBA.

1. Criar um projeto
   • Para criar um novo projeto, comece pelo projeto Templates_LL fornecido para cada quadro em \Projetos\ \Templates_LL, ou de qualquer projeto disponível em \Projects\ \Examples_LL ( refere-se ao nome da placa, como NUCLEO-WBA32CG).
   • O projeto modelo fornece uma função de loop principal vazia, que é um bom ponto de partida para entender as configurações do projeto para STM32CubeWBA. As principais características do modelo são as seguintes:
     • Ele contém os códigos-fonte dos drivers LL e CMSIS, que são o conjunto mínimo de componentes necessários para desenvolver o código em uma determinada placa.
     • Ele contém os caminhos incluídos para todos os componentes de firmware necessários.
     • Ele seleciona o dispositivo da série STM32WBA suportado e permite a configuração correta dos drivers CMSIS e LL.
     • Ele fornece ao usuário pronto para uso files que são pré-configurados da seguinte forma:
       ◦ main.h: Camada de abstração de definição de LED e USER_BUTTON.
       ◦ main.c: Configuração do relógio do sistema para frequência máxima.
2. Portar um projeto existente para outro quadro
   Para apoiar um projeto existente em outro quadro de destino, comece pelo projeto Templates_LL fornecido para cada quadro e disponível em \Projetos\ \Modelos_LL.
   • Selecione um ex LLample: Para encontrar o quadro em que LL examparquivos são implantados, consulte a lista de LL exampo STM32CubeProjectsList.html.
3. Transferir o LL exampem:
   • Copie/cole a pasta Templates_LL – para manter a fonte inicial – ou atualize diretamente o projeto Temp lates_LL existente.
   • Então a portabilidade consiste principalmente em substituir Templates_LL fileé pelo Exampprojeto direcionado les_LL.
   • Guarde todas as peças específicas da placa. Por razões de clareza, as partes específicas da placa são sinalizadas com tags:

     

   • Assim, as principais etapas da portabilidade são as seguintes:
     • Substitua o stm32wbaxx_it.h file
     • Substitua o stm32wbaxx_it.c file
     • Substitua o main.h file e atualizá-lo: Mantenha a definição do LED e do botão do usuário do modelo LL em BOARD SPECIFIC CONFIGURATION tags.
     • Substitua o main.c file e atualize-o:
   • Mantenha a configuração do relógio da função do modelo SystemClock_Config() LL em BOARD SPECIFIC CONFIGURATION tags.
   • Dependendo da definição do LED, substitua cada ocorrência de LDx por outra LDy disponível no main.h file.
   • Com essas modificações, o example agora é executado no quadro de destino

Aplicativos de segurança
Este pacote é entregue com aplicativos de segurança.

Aplicações SBSFU

• SBSFU fornece uma solução Root of Trust, incluindo funcionalidades de inicialização segura e atualização segura de firmware (baseada em MCUboot).
• A solução é usada antes de executar o aplicativo.
• A solução fornece um examparquivo de um serviço seguro (alternância GPIO), que é isolado do aplicativo não seguro. O aplicativo não seguro em tempo de execução ainda pode usar esta solução.

Aplicações TFM
O TFM fornece uma solução Root of Trust incluindo funcionalidades de inicialização segura e atualização segura de firmware
(baseado em MCUboot). A solução é usada antes de executar o aplicativo. A solução fornece serviços seguros TFM isolados do aplicativo não seguro. O aplicativo não seguro em tempo de execução ainda pode usar esta solução.

Aplicações de RF
A aplicação RF é descrita nesta nota de aplicação: Construindo aplicações sem fio com microcontroladores da série STM32WBA (AN5928).

Obtendo atualizações de lançamento do STM32CubeWBA
Os últimos lançamentos e patches do pacote STM32CubeWBA MCU estão disponíveis na série STM32WBA. Eles podem ser recuperados no botão CHECK FOR UPDATE no STM32CubeMX. Para obter mais detalhes, consulte a Seção 3 do manual do usuário STM32CubeMX para configuração STM32 e geração de código C de inicialização (UM1718).

Perguntas frequentes

• Quando devo usar drivers HAL em vez de drivers LL?
  • Os drivers HAL oferecem APIs de alto nível e orientadas a funções, com alto nível de portabilidade. A complexidade do produto ou periférico fica oculta para os usuários finais.
  • Os drivers LL oferecem APIs de nível de registro de camada baixa, com melhor otimização, mas menos portáveis. Eles exigem conhecimento profundo das especificações do produto ou da propriedade intelectual.
• Posso usar drivers HAL e LL juntos? Se eu puder, quais são as restrições?
  • É possível usar drivers HAL e LL. Use o HAL para a fase de inicialização do IP e depois gerencie as operações de E/S com drivers LL.
  • A principal diferença entre HAL e LL é que os drivers HAL exigem a criação e uso de identificadores para gerenciamento de operações, enquanto os drivers LL operam diretamente em registros periféricos. O examples_MIX example ilustra como misturar HAL e LL.
• Como as APIs de inicialização LL são habilitadas?
  • A definição de APIs de inicialização LL e recursos associados (estruturas, literais e protótipos) é condicionada pela opção de compilação USE_FULL_LL_DRIVER.
  • Para poder usar APIs de inicialização LL, inclua essa opção no pré-processador do compilador da cadeia de ferramentas.
• Como o STM32CubeMX pode gerar código baseado em software embarcado?
  STM32CubeMX possui conhecimento integrado de microcontroladores STM32, incluindo seus periféricos e software que permite fornecer uma representação gráfica ao usuário e gerar *.h ou *.c files com base na configuração do usuário.

AVISO IMPORTANTE – LEIA COM ATENÇÃO

• A STMicroelectronics NV e suas subsidiárias (“ST”) reservam-se o direito de fazer alterações, correções, aprimoramentos, modificações e melhorias nos produtos ST e/ou neste documento a qualquer momento, sem aviso prévio. Os compradores devem obter as informações relevantes mais recentes sobre os produtos ST antes de fazer pedidos. Os produtos ST são vendidos de acordo com os termos e condições de venda da ST em vigor no momento do reconhecimento do pedido.
• Os compradores são os únicos responsáveis ​​pela escolha, seleção e uso dos produtos ST e a ST não assume nenhuma responsabilidade pela assistência na aplicação ou pelo design dos produtos dos compradores.
• Nenhuma licença, expressa ou implícita, para qualquer direito de propriedade intelectual é concedida pela ST aqui.
• A revenda de produtos ST com disposições diferentes das informações aqui estabelecidas anulará qualquer garantia concedida pela ST para tal produto.
• ST e o logotipo ST são marcas registradas da ST. Para obter informações adicionais sobre as marcas registradas da ST, consulte www.st.com/trademarks. Todos os outros nomes de produtos ou serviços são de propriedade de seus respectivos proprietários.
• As informações neste documento substituem e substituem informações fornecidas anteriormente em quaisquer versões anteriores deste documento.
• © 2023 STMicroelectronics – Todos os direitos reservados

Documentos / Recursos

STMicroelectronics Série STM32WBA Primeiros passos [pdf] Manual do Usuário Série STM32WBA Primeiros passos, Primeiros passos, Começados

Referências

• Manual do usuário