STMicroelectronics STM32WBA-serien Komma igång

Produktinformation

Specifikationer:

• Produktnamn: STM32CubeWBA MCU-paket
• Tillverkare: STMicroelectronics
• Kompatibilitet: STM32WBA-serien mikrokontroller
• Licensiering: BSD-licens med öppen källkod

Produktanvändningsinstruktioner

Huvudfunktioner i STM32CubeWBA MCU-paket:
STM32CubeWBA MCU-paketet tillhandahåller alla nödvändiga inbäddade mjukvarukomponenter för att utveckla applikationer på STM32WBA-seriens mikrokontroller. Den är mycket portabel inom STM32-serien och levereras med HAL och LL API:er, examples och middleware-komponenter.

Arkitektur överview:
Arkitekturen för STM32CubeWBA MCU-paketet består av tre nivåer – applikationer, bibliotek och protokollbaserade komponenter, hårdvaruabstraktionslager, BSP-drivrutiner, kärndrivrutiner och låglager-API:er.

FAQ

• Vad ingår i STM32CubeWBA MCU-paketet?
  Paketet innehåller API:er för lågt lager (LL) och hårdvaruabstraktionslager (HAL), exampläser, applikationer, mellanprogramkomponenter som FileX/LevelX, NetX Duo, mbed-crypto-bibliotek och mer.
• Är STM32CubeWBA MCU-paketet kompatibelt med STM32CubeMX-kodgeneratorn?
  Ja, paketet är helt kompatibelt med STM32CubeMX-kodgeneratorn för att generera initialiseringskod.

Introduktion

• STM32Cube är ett originalinitiativ från STMicroelectronics för att förbättra designers produktivitet avsevärt genom att minska utvecklingsansträngning, tid och kostnad. STM32Cube täcker hela STM32-portföljen.
  STM32Cube innehåller:
  • En uppsättning användarvänliga verktyg för mjukvaruutveckling för att täcka projektutveckling från idé till förverkligande, bland annat:
    • STM32CubeMX, ett grafiskt programvarukonfigurationsverktyg som tillåter automatisk generering av C-initieringskod med hjälp av grafiska guider
    • STM32CubeIDE, ett allt-i-ett-utvecklingsverktyg med perifer konfiguration, kodgenerering, kodkompilering och felsökningsfunktioner
    • STM32CubeCLT, en allt-i-ett kommandoradsutvecklingsverktyg med kodkompilering, kortprogrammering och felsökningsfunktioner
    • STM32CubeProgrammer (STM32CubeProg), ett programmeringsverktyg tillgängligt i grafiska och kommandoradsversioner
    • STM32CubeMonitor (STM32CubeMonitor, STM32CubeMonPwr, STM32CubeMonRF, STM32CubeMonUCPD), kraftfulla övervakningsverktyg för att finjustera beteendet och prestanda för STM32-applikationer i realtid
  • STM32Cube MCU och MPU-paket, omfattande inbäddade mjukvaruplattformar specifika för varje mikrokontroller och mikroprocessorserie (som STM32CubeWBA för STM32WBA-serien), som inkluderar:
    • STM32Cube hårdvaruabstraktionslager (HAL), säkerställer maximerad portabilitet över STM32-portföljen
    • STM32Cube låglager-API:er, säkerställer bästa prestanda och fotavtryck med en hög grad av användarkontroll över hårdvara
    • En konsekvent uppsättning mellanprogramkomponenter som ThreadX, FileX / LevelX, NetX Duo, USBX, pekbibliotek, mbed-crypto, TFM, MCUboot, OpenBL och STM32_WPAN (inklusive Bluetooth® Low Energy profiles och tjänster, Mesh, Zigbee®, OpenThread, Matter och 802.15.4 MAC-lager)
    • Alla inbäddade programvaruverktyg med kompletta uppsättningar av kringutrustning och applicerande examples
  • STM32Cube Expansion Packages, som innehåller inbäddade programvarukomponenter som kompletterar funktionerna i STM32Cube MCU och MPU-paket med:
    • Middleware-tillägg och applicerande lager
    • Exampfiler som körs på vissa specifika STMicroelectronics-utvecklingskort
• Denna användarmanual beskriver hur du kommer igång med STM32CubeWBA MCU-paketet.
  • Avsnitt 2 STM32CubeWBAs huvudfunktioner beskriver huvudfunktionerna i STM32CubeWBA MCU-paketet.
  • Avsnitt 3 STM32CubeWBA-arkitektur överview ger en överview av STM32CubeWBA-arkitekturen och MCU-paketstrukturen.

Allmän information

STM32CubeWBA MCU-paketet körs på STM32 32-bitars mikrokontroller baserade på Arm® Cortex®-M33-processorn med Arm® TrustZone® och FPU.
Notera: Arm och TrustZone är registrerade varumärken som tillhör Arm Limited (eller dess dotterbolag) i USA och/eller någon annanstans.

STM32CubeWBA huvudfunktioner

• STM32CubeWBA MCU-paketet körs på STM32 32-bitars mikrokontroller baserade på Arm® Cortex®-M33-processorn med TrustZone® och FPU.
• STM32CubeWBA samlar, i ett enda paket, alla generiska inbäddade mjukvarukomponenter som krävs för att utveckla en applikation för STM32WBA-seriens mikrokontroller. I linje med STM32Cube-initiativet är denna uppsättning komponenter mycket portabel, inte bara inom STM32WBA-seriens mikrokontroller utan även till andra STM32-serier.
• STM32CubeWBA är helt kompatibel med STM32CubeMX-kodgeneratorn för att generera initialiseringskod. Paketet inkluderar låglager (LL) och hårdvaruabstraktionslager (HAL) API:er som täcker mikrokontrollerns hårdvara, tillsammans med en omfattande uppsättning ex.amples som körs på STMicroelectronics-kort. HAL- och LL-API:erna är tillgängliga i en BSD-licens med öppen källkod för användarens bekvämlighet.
• STM32CubeWBA MCU-paketet innehåller också en omfattande mellanprogramskomponent konstruerad kring Microsoft® Azure® RTOS-mellanprogramvara och andra interna stackar och öppen källkod, med motsvarande ex.amples.
• De kommer med gratis, användarvänliga licensvillkor:
  • Integrerad och fullfjädrad Azure® RTOS: Azure® RTOS ThreadX
  • CMSIS-RTOS-implementering med Azure® RTOS ThreadX
  • USB-värd- och enhetsstackar kommer med många klasser: Azure® RTOS USBX
  • Avancerad file system och flashöversättningslager: FileX / NivåX
  • Industriell nätverksstack: optimerad för prestanda med många IoT-protokoll: NetX Duo
  • OpenBootloader
  • Arm® Trusted Firmware-M (TF‑M) integrationslösning
  • mbed-kryptobibliotek
  • ST Network Library
  • STMTouch beröringsavkännande bibliotekslösning
• Flera applikationer och demonstrationer som implementerar alla dessa mellanprogramkomponenter finns också i STM32CubeWBA MCU-paketet.
• STM32CubeWBA MCU-paketets komponentlayout illustreras i figur 1. STM32CubeWBA MCU-paketkomponenter .

  

STM32CubeWBA arkitektur överview

STM32CubeWBA MCU-paketlösning är byggd kring tre oberoende nivåer som enkelt interagerar enligt beskrivningen i figur 2. STM32CubeWBA MCU-paketarkitektur.

Nivå 0

Denna nivå är uppdelad i tre underskikt:

• Styrelsestödspaket (BSP).
• Hårdvaruabstraktionslager (HAL):
  • HAL perifera drivrutiner
  • Låglagers drivrutiner
• Grundläggande perifer användning examples.

Styrelsestödspaket (BSP)
Detta lager erbjuder en uppsättning API:er i förhållande till hårdvarukomponenterna i hårdvarukorten (som LCD-, Audio-,\microSD™- och MEMS-drivrutiner). Den består av två delar:

• Komponentdrivrutin:
  Denna drivrutin är relaterad till den externa enheten på kortet och inte till STM32-enheten. Komponentdrivrutinen tillhandahåller specifika API:er till BSP-drivrutinens externa komponenter och kan vara portabel på vilket annat kort som helst.
• BSP drivrutin:
  BSP-drivrutinen gör det möjligt att länka komponentdrivrutinerna till ett specifikt kort och ger en uppsättning användarvänliga
  API:er. API-namnregeln är BSP_FUNCT_Action().
  Example: BSP_LED_Init(), BSP_LED_On()
  BSP är baserad på en modulär arkitektur som möjliggör enkel portering på vilken hårdvara som helst genom att bara implementera rutinerna på låg nivå.

Hårdvaruabstraktionslager (HAL) och låglager (LL)
STM32CubeWBA HAL och LL är komplementära och täcker ett brett spektrum av applikationskrav:

• HAL-drivrutinerna erbjuder funktionsorienterade och mycket portabla API:er på hög nivå. De döljer MCU och perifer komplexitet för slutanvändaren.
  HAL-drivrutinerna tillhandahåller generiska funktionsorienterade API:er med flera instanser, som förenklar implementering av användarapplikationer genom att tillhandahålla processer som är färdiga att använda. Till exempelample, för kringutrustning för kommunikation (I2S, UART och andra), tillhandahåller den API:er som möjliggör initiering och konfigurering av kringutrustningen, hanterar dataöverföring baserat på avfrågnings-, avbrotts- eller DMA-process och hanterar kommunikationsfel som kan uppstå under kommunikation. HAL-drivrutinens API:er är uppdelade i två kategorier:
  1. Generiska API:er, som tillhandahåller gemensamma och generiska funktioner till alla mikrokontroller i STM32-serien.
  2. Extension APIs, som tillhandahåller specifika och anpassade funktioner för en specifik familj eller ett specifikt artikelnummer.
• Lågskikts-API:erna tillhandahåller lågnivå-API:er på registernivå, med bättre optimering men mindre portabilitet.
  • De kräver en djup kunskap om MCU och kringutrustning.
  • LL-drivrutinerna är designade för att erbjuda ett snabbt och lätt expertorienterat lager som är närmare hårdvaran än HAL. I motsats till HAL tillhandahålls inte LL API:er för kringutrustning där optimerad åtkomst inte är en nyckelfunktion, eller för de som kräver tung mjukvarukonfiguration eller komplex stack på övre nivån.
  • LL-drivrutinerna har:
    • En uppsättning funktioner för att initiera perifera huvudfunktioner enligt de parametrar som specificeras i datastrukturer.
    • En uppsättning funktioner för att fylla initialiseringsdatastrukturer med återställningsvärdena som motsvarar varje fält.
    • Funktion för perifer avinitialisering (perifera register återställda till sina standardvärden).
    • En uppsättning inline-funktioner för direkt- och atomregisteråtkomst.
    • Fullständigt oberoende av HAL och förmåga att användas i fristående läge (utan HAL-drivrutiner).
    • Full täckning av de kringutrustning som stöds.

Grundläggande perifer användning examples
Detta lager omsluter exampläser byggda över STM32 kringutrustning med endast HAL- och BSP-resurser.

Nivå 1

Denna nivå är uppdelad i två underskikt:

• Mellanvarukomponenter
• Exampfiler baserade på mellanvarukomponenterna

Mellanvarukomponenter

• Mellanvaran är en uppsättning bibliotek som täcker Bluetooth® Low Energy (Linklayer, HCI, Stack), Thread®, Zigbee®,
• Matter, OpenBootloader, Microsoft® Azure® RTOS, TF‑M, MCUboot och mbed-crypto.
• Horisontell interaktion mellan komponenterna i detta lager görs genom att anropa de utvalda API:erna.
• Vertikal interaktion med låglagerdrivrutinerna görs genom specifika callbacks och statiska makron implementerade i bibliotekssystemets anropsgränssnitt.
• Huvudfunktionerna för varje mellanprogramskomponent är följande:
  • Microsoft® Azure® RTOS
    • Azure® RTOS ThreadX: Ett realtidsoperativsystem (RTOS), designat för inbäddade system med två funktionella lägen.
      • Common mode: Vanliga RTOS-funktioner som trådhantering och synkronisering, minnespoolhantering, meddelandehantering och händelsehantering.
      • Modulläge: Ett avancerat användarläge som tillåter laddning och urladdning av förlänkade ThreadX-moduler i farten genom en modulhanterare.
    • NetX Duo
    • FileX
    • USBX
  • Bluetooth® Low Energy (BLE): Implementerar Bluetooth® Low Energy-protokollet för länk- och stacklagren.
  • MCUboot (programvara med öppen källkod)
  • Zigbee®-protokoll för stacken och relaterade kluster.
  • Thread®-protokollstack och länklager.
  • Arm® betrodd firmware-M, TF-M (programvara med öppen källkod): Referensimplementering av Arm®-plattformens säkerhetsarkitektur (PSA) för TrustZone® med tillhörande säkra tjänster.
  • mbed-crypto (programvara med öppen källkod): Mbed-crypto-mellanvaran tillhandahåller en PSA-kryptografi API-implementering.
  • STM32 Touch sensing bibliotek: Robust STMTouch kapacitiv touch sensing lösning som stöder närhet, touchkey, linjära och roterande touchsensorer. Den är baserad på en beprövad princip för förvärv av ytladdningsöverföring.

Exampfiler baserade på mellanvarukomponenterna
Varje middleware-komponent kommer med ett eller flera examples (även kallade applikationer) som visar hur man använder det. Integration exampfiler som använder flera mellanprogramkomponenter tillhandahålls också.

STM32CubeWBA firmwarepaket överview

Stödda enheter och hårdvara i STM32WBA-serien

• STM32Cube erbjuder ett mycket portabelt hårdvaruabstraktionslager (HAL) byggt kring en generisk arkitektur. Det tillåter principen om uppbyggnad av lager, som att använda mellanvarulagret för att implementera sina funktioner utan att på djupet veta vilken MCU som används. Detta förbättrar bibliotekskodens återanvändbarhet och säkerställer en enkel portabilitet till andra enheter.
• Dessutom, tack vare sin skiktade arkitektur, erbjuder STM32CubeWBA fullt stöd för alla STM32WBA-serier.
• Användaren behöver bara definiera rätt makro i stm32wbaxx.h.
• Tabell 1 visar makrot som ska definieras beroende på vilken enhet i STM32WBA-serien som används. Detta makro måste också definieras i kompilatorns förprocessor.
  Tabell 1. Makron för STM32WBA-serien

  Makro definierat i stm32wbaxx.h	Enheter i STM32WBA-serien
  stm32wba52xx	STM32WBA52CGU6, STM32WBA52KGU6, STM32WBA52CEU6, STM32WBA52KEU6
  stm32wba55xx	STM32WBA55CGU6, STM32WBA55CGU6U, STM32WBA55CGU7, STM32WBA55CEU6, STM32WBA55CEU7

   
• STM32CubeWBA har en rik uppsättning exampfiler och applikationer på alla nivåer vilket gör det enkelt att förstå och använda alla HAL-drivrutiner eller mellanprogramkomponenter. Dessa exampkörs på STMicroelectronics-korten som anges i Tabell 2.
  Tabell 2. Skivor för STM32WBA-serien

  Styrelse	Board STM32WBA-stödda enheter
  NUCLEO-WBA52CG	STM32WBA52CGU6
  NUCLEO-WBA55CG	STM32WBA55CGU6
  STM32WBA55-DK1	STM32WBA55CGU7

• STM32CubeWBA MCU-paketet kan köras på vilken kompatibel hårdvara som helst. Användaren uppdaterar helt enkelt BSP-drivrutinerna för att porta det medföljande exampfiler på kortet, om det senare har samma hårdvarufunktioner (som LED, LCD-skärm och knappar).

Firmware-paketet överview

• STM32CubeWBA-paketlösningen tillhandahålls i ett enda zip-paket med strukturen som visas i figur 3. STM32CubeWBA firmwarepaketstruktur.

  

• För varje bräda, en uppsättning examples är försedd med förkonfigurerade projekt för EWARM-, MDK-ARM- och STM32CubeIDE-verktygskedjor.
• Figur 4. STM32CubeWBA examples överview visar projektstrukturen för korten NUCLEO-WBA52CG, NUCLEO-WBA55CG och STM32WBA55G-DK1.

  

• Exampfilerna klassificeras beroende på vilken STM32Cube-nivå de gäller, och de heter enligt följande:
  • Nivå 0 examples kallas Examples, examples_LL och examples_MIX. De använder respektive HAL-drivrutiner, LL-drivrutiner och en blandning av HAL- och LL-drivrutiner utan någon middleware-komponent.
  • Nivå 1 exampfiler kallas applikationer. De tillhandahåller typiska användningsfall för varje mellanprogramkomponent. Alla firmwareapplikationer för ett givet kort kan byggas snabbt tack vare mallprojekt som finns tillgängliga i katalogerna Templ ates och Templates_LL.

TrustZone®-aktiverade projekt

• TrustZone®-aktiverat Exampläsnamnen innehåller prefixet _TrustZone. Regeln tillämpas även för applikationer (förutom för TFM och SBSFU, som är inbyggda för TrustZone®).
• TrustZone®-aktiverat examples och applikationer är försedda med en multiprojektstruktur som består av säkra och osäkra delprojekt som presenteras i figur 5. Säker och osäkra projektstruktur för flera projekt.
• TrustZone®-aktiverade projekt utvecklas enligt enhetsmallen CMSIS-5, utökad till att inkludera systempartitioneringshuvudet file dela_ .h, som huvudsakligen är ansvarig för uppsättningen av den säkra attributenheten (SAU), FPU:n och tilldelningen av säkra/icke-säkra avbrott i det säkra exekveringsläget.
• Denna inställning utförs i den säkra CMSIS SystemInit()-funktionen, som anropas vid uppstart innan den säkra applikationens main()-funktion öppnas. Se Arm® TrustZone®-M-dokumentationen för programvaruriktlinjer.

  

• STM32CubeWBA-paketets firmware-paket tillhandahåller standardminnespartitionering i partitionen _ .h files tillgängliga under: \Drivers\CMSIS\Device\ST\STM32WBAxx\Include\T-emplates
• I dessa partitioner files är SAU inaktiverad som standard. Följaktligen används IDAU-minnesmappningen för säkerhetstillskrivning. Se figur Säker/icke-säker partitionering med TrustZone®-teknik i referensmanualen till RM0495.
• Om användaren aktiverar SAU, är en standard SAU-regionskonfiguration fördefinierad i partitionen files enligt följande:
  • SAU region 0: 0x08080000 – 0x081FFFFF (osäker säker hälften av flashminnet (512 Kbyte))
  • SAU region 1: 0x0BF88000 – 0x0BF97FFF (osäkert systemminne)
  • SAU region 2: 0x0C07E000 – 0x0C07FFFF (säker, osäker anropsbar)
  • SAU region 3: 0x20010000 – 0x2001FFFF (icke-säker SRAM2 (64 Kbyte))
  • SAU region 4: 0x40000000 – 0x4FFFFFFF (icke-säkert perifert mappat minne)
• För att matcha standardpartitioneringen måste enheterna i STM32WBAxx-serien ha följande byte för användaralternativ:
  • TZEN = 1 (TrustZone®-aktiverad enhet)
  • SECWM1_PSTRT = 0x0 SECWM1_PEND = 0x3F (64 av 128 sidor internt flashminne är inställt som säkert) Obs: Det interna flashminnet är helt säkert som standard i TZEN = 1. Användaralternativbyte SECWM1_PSTRT/SECWM1_PEND måste ställas in enligt applikationen minneskonfiguration (SAU-regioner, om SAU är aktiverat). Säkra/osäkra applikationer projekt länkare files måste också anpassas.
• alla examples har samma struktur:
  • \Inc-mappen som innehåller alla rubriker files.
  • Src-mappen som innehåller källkoden.
  • \EWARM, \MDK-ARM och \STM32CubeIDE mappar som innehåller det förkonfigurerade projektet för varje verktygskedja.
  • readme.md och readme.html som beskriver exampbeteendet och den behövde miljön för att få det att fungera.
  • ioc file som tillåter användare att öppna det mesta av firmware examples inom STM32CubeMX.

Komma igång med STM32CubeWBA

Kör ett första HAL example

Det här avsnittet förklarar hur enkelt det är att köra det första example inom STM32CubeWBA. Den använder som en illustration genereringen av en enkel LED-växel som körs på NUCLEO-WBA52CG-kortet:

1. Ladda ner STM32CubeWBA MCU-paketet.
2. Packa upp den i en valfri katalog.
3. Se till att inte ändra paketstrukturen som visas i figur 1. Det rekommenderas också att kopiera paketet på en plats nära din rotvolym (vilket betyder C:\ST eller G:\Tests), eftersom vissa IDE:er stöter på problem när sökvägen längden är för lång.

Att köra ett första TrustZone®-aktiverat example

• Innan du laddar och kör en TrustZone®-aktiverad example, det är obligatoriskt att läsa exampläs mig file för någon specifik konfiguration, vilket säkerställer att säkerheten är aktiverad enligt beskrivningen i avsnitt 4.2.1 TrustZone®-aktiverade projekt (TZEN=1 (användaralternativbyte)).
  1. Bläddra till \Projects\NUCLEO-WBA52CG\Examples.
  2. Öppna \GPIO, sedan \GPIO_IOToggle_TrustZone-mappar.
  3. Öppna projektet med din föredragna verktygskedja. En snabb överview om hur man öppnar, bygger och kör ett exampfilen med de stödda verktygskedjorna ges nedan.
  4. Bygg om i ordning alla säkra och osäkra projekt files och ladda de säkra och osäkra bilderna i målminnet.
  5. Kör exetample: regelbundet växlar den säkra applikationen LD2 varje sekund, och den osäkra applikationen växlar LD3 dubbelt så snabbt. För mer information, se readme file av example.
• För att öppna, bygga och köra ett exampFölj stegen nedan med de verktygskedjor som stöds:
  • VARM:
    1. Under exampi mappen, öppna undermappen \EWARM.
    2. Starta arbetsytan Project.eww
    3. Bygg om det säkra projektet xxxxx_S files: [Projekt]>[Återbygga alla].
    4. Ställ in det osäkra projektet xxxxx_NS som aktivt program (högerklicka på xxxxx_NS-projektet [Ange som aktivt])
    5. Bygg om det osäkra projektet xxxxx_NS files: [Projekt]>[Återbygga alla].
    6. Flasha den osäkra binära filen med [Projekt]>[Ladda ner]>[Ladda ner aktiv applikation] .
    7. Ställ in applikationen xxxxx_S som aktiv (högerklicka på xxxxx_S-projektet [Set as Active].
    8. Flasha den säkra binära filen med [Ladda ner och felsöka] (Ctrl+D).
    9. Kör programmet: [Debug]>[Go(F5)]
  • MDK-ARM:
    1. Öppna \MDK-ARM-verktygskedjan.
    2. Öppna arbetsytan Multiprojects file Project.uvmpw.
    3. Välj xxxxx_s-projektet som aktivt program ([Ange som aktivt projekt]).
    4. Bygg xxxxx_s-projektet.
    5. Välj xxxxx_ns-projektet som aktivt projekt ([Ange som aktivt projekt]).
    6. Bygg xxxxx_ns-projektet.
    7. Ladda den osäkra binära filen ([F8]). Detta laddar ner \MDK-ARM\xxxxx_ns\Exe\xxxxx_ns.axf till flashminnet)
    8. Välj Project_s-projektet som aktivt projekt ([Ange som aktivt projekt]).
    9. Ladda den säkra binären ([F8]). Detta laddar ner \MDK-ARM\xxxxx_s\Exe\xxxxx_s.axf till flashminnet).
    10. Kör exetample.
  • STM32CubeIDE:
    1. Öppna verktygskedjan STM32CubeIDE.
    2. Öppna arbetsytan Multiprojects file .projekt.
    3. Bygg om xxxxx_Secure-projektet.
    4. Bygg om xxxxx_NonSecure-projektet.
    5. Starta applikationen [Debug as STM32 Cortex-M C/C++] för det säkra projektet.
    6. I fönstret [Redigera konfiguration], välj panelen [Startup] och lägg till ladda bilden och symbolerna för det osäkra projektet.
       Viktig: Det osäkra projektet måste laddas före det säkra projektet.
    7. Klicka på [Ok].
    8. Kör exetample om felsökningsperspektiv.

Att köra ett första TrustZone®-inaktiverat example

• Innan du laddar och kör en TrustZone®-inaktiverad example, det är obligatoriskt att läsa exampläs mig file för någon specifik konfiguration. Om det inte finns några specifika omnämnanden, se till att kortenheten har säkerhetsinaktiverats (TZEN=0 (användaralternativbyte)). Se FAQ för att göra den valfria regressionen till TZEN = 0
  1. Bläddra till \Projects\NUCLEO-WBA52CG\Examples.
  2. Öppna \GPIO, sedan \GPIO_EXTI-mappar.
  3. Öppna projektet med din föredragna verktygskedja. En snabb överview om hur man öppnar, bygger och kör ett exampfilen med de stödda verktygskedjorna ges nedan.
  4. Bygg om alla files och ladda din bild i målminnet.
  5. Kör exetample: Varje gång [ANVÄNDARE] trycks ned, växlar LD1-lampan. För mer information, se readme file av example.
• För att öppna, bygga och köra ett exampFölj stegen nedan med de verktygskedjor som stöds:
  • VARM:
    1. Under exampi mappen, öppna undermappen \EWARM.
    2. Starta arbetsytan Project.eww (arbetsytans namn kan ändras från ett example till en annan).
    3. Bygg om alla files: [Projekt]>[Återbygga alla].
    4. Ladda projektbilden: [Project]>[Debug].
    5. Kör program: [Debug]>[Go (F5)].
  • MDK-ARM:
    1. Under exampi mappen, öppna undermappen \MDK-ARM.
    2. Starta arbetsytan Project.uvproj (arbetsytans namn kan ändras från ett example till en annan).
    3. Bygg om alla files:[Projekt]>[Bygg om alla mål files].
    4. Ladda projektbilden: [Debug]>[Start/Stop Debug Session].
    5. Kör program: [Debug]>[Kör (F5)].
  • STM32CubeIDE:
    1. Öppna verktygskedjan STM32CubeIDE.
    2. Klick [File]>[Byt arbetsyta]>[Övrigt] och bläddra till STM32CubeIDE-arbetsytans katalog.
    3. Klick [File]>[Importera] , välj [Allmänt]>[Befintliga projekt till arbetsytan] och klicka sedan på [Nästa].
    4. Bläddra till STM32CubeIDE-arbetsytans katalog och välj projektet.
    5. Bygg om alla projekt files: Välj projektet i fönstret [Project Explorer] och klicka sedan på menyn [Project]>[Build project].
    6. Kör programmet: [Kör]>[Debug (F11)]

Utveckla en anpassad applikation

Notera: Programvaran måste aktivera instruktionscachen (ICACHE) för att få en 0 wait-state-exekvering från flashminnet och nå maximal prestanda och bättre strömförbrukning.

Använda STM32CubeMX för att utveckla eller uppdatera en applikation

• I STM32CubeWBA MCU-paketet, nästan alla projekt exampfiler genereras med verktyget STM32CubeMX för att initiera systemet, kringutrustning och mellanprogram.
• Den direkta användningen av ett befintligt projekt example från STM32CubeMX-verktyget kräver STM32CubeMX 6.10.0 eller högre:
  • Efter installationen av STM32CubeMX, öppna och vid behov uppdatera ett föreslaget projekt. Det enklaste sättet att öppna ett befintligt projekt är att dubbelklicka på *.ioc file så att STM32CubeMX automatiskt öppnar projektet och dess källa files.
  • STM32CubeMX genererar initialiseringskällkoden för sådana projekt. Huvudapplikationens källkod finns i kommentarerna "USER CODE BEGIN" och "USER CODE END". Om IP-valet och inställningen ändras, uppdaterar STM32CubeMX initieringsdelen av koden men bevarar huvudapplikationens källkod.
• För att utveckla ett anpassat projekt i STM32CubeMX, följ steg-för-steg-processen:
  1. Välj den STM32-mikrokontroller som matchar den erforderliga uppsättningen kringutrustning.
  2. Konfigurera all nödvändig inbäddad programvara med hjälp av en pinout-konfliktlösare, en klockträdsinställningshjälp, en strömförbrukningskalkylator och verktyget som utför MCU-periferikonfiguration (som GPIO eller USART) och mellanprogramstackar (som USB).
  3. Generera initierings C-koden baserat på den valda konfigurationen. Denna kod är redo att användas inom flera utvecklingsmiljöer. Användarkoden sparas vid nästa kodgenerering.
• För mer information om STM32CubeMX, se användarmanualen STM32CubeMX för STM32-konfiguration och initialisering C-kodgenerering (UM1718).
• För en lista över tillgängliga projekt examples för STM32CubeWBA, se applikationsanmärkningen STM32Cube firmware examples för STM32WBA-serien (AN5929).

Drivrutinsapplikationer

HAL-applikation
Det här avsnittet beskriver de steg som krävs för att skapa en anpassad HAL-applikation med STM32CubeWBA:

1. Skapa ett projekt
   • För att skapa ett nytt projekt, börja antingen från mallprojektet som tillhandahålls för varje bräda under \Projects\ \Mallar eller från något tillgängligt projekt under \Projects\ \Exempel eller \Projekt\ \Applikationer (där hänvisar till kortets namn, såsom STM32CubeWBA).
   • Mallprojektet tillhandahåller en tom huvudslingafunktion. Det är dock en bra utgångspunkt för att förstå STM32CubeWBA-projektinställningarna. Mallen har följande egenskaper:
     • Den innehåller HAL-källkoden, CMSIS och BSP-drivrutiner, som är den minsta uppsättning komponenter som krävs för att utveckla en kod på ett givet kort.
     • Den innehåller de inkluderade sökvägarna för alla firmwarekomponenter.
     • Den definierar de enheter i STM32WBA-serien som stöds, vilket gör att CMSIS- och HAL-drivrutinerna kan konfigureras korrekt.
     • Det ger användaren färdig att använda fileär förkonfigurerad enligt nedan:
       HAL initierad med standardtidsbasen med Arm® core SysTick. SysTick ISR implementerad för HAL_Delay() ändamål.
       Notera: När du kopierar ett befintligt projekt till en annan plats, se till att alla inkluderade sökvägar är uppdaterade.
2. Lägg till nödvändig mellanprogramvara till användarprojektet (valfritt)
   För att identifiera källan fileska läggas till i projektet file listan, se dokumentationen som tillhandahålls för varje mellanprogram. Se ansökningarna under \Projects\STM32xxx_yyy\Applications\ (var hänvisar till mellanvarustacken, såsom ThreadX) för att veta vilken källa files och inkluderar sökvägar måste läggas till.
3. Konfigurera firmwarekomponenterna
   HAL- och middleware-komponenterna erbjuder en uppsättning konfigurationsalternativ för byggtid med hjälp av makron #define som deklareras i en rubrik file. En mallkonfiguration file finns inom varje komponent, som måste kopieras till projektmappen (vanligtvis konfigurationen file heter xxx_conf_template.h, ordet _template måste tas bort när du kopierar det till projektmappen). Konfigurationen file ger tillräckligt med information för att förstå effekten av varje konfigurationsalternativ. Mer detaljerad information finns i dokumentationen för varje komponent.
4. Starta HAL-biblioteket
   Efter att ha hoppat till huvudprogrammet måste applikationskoden anropa HAL_Init() API för att initiera HAL-biblioteket, som utför följande uppgifter:
   • Konfiguration av flashminnets prefetch och SysTick-avbrottsprioritet (genom makron definierade i st m32wbaxx_hal_conf.h).
   • Konfiguration av SysTick för att generera ett avbrott varje millisekund vid SysTick-avbrottsprioriteten TICK_INT_PRIO definierad i stm32wbaxx_hal_conf.h.
   • Inställning av NVIC-gruppprioritet till 0.
   • Anrop av HAL_MspInit() callback funktion definierad i stm32wbaxx_hal_msp.c användare file för att utföra globala hårdvaruinitieringar på låg nivå.
5. Konfigurera systemklockan
   Systemklockkonfigurationen görs genom att anropa de två API:er som beskrivs nedan:
   • HAL_RCC_OscConfig(): detta API konfigurerar de interna och externa oscillatorerna. Användaren väljer att konfigurera en eller alla oscillatorer.
   • HAL_RCC_ClockConfig(): detta API konfigurerar systemklockkällan, flashminnets latens och AHB- och APB-förskalare.
6. Initiera kringutrustningen
   • Skriv först den perifera HAL_PPP_MspInit-funktionen. Fortsätt enligt följande:
     • Aktivera den perifera klockan.
     • Konfigurera de perifera GPIO:erna.
     • Konfigurera DMA-kanalen och aktivera DMA-avbrott (om det behövs).
     • Aktivera perifert avbrott (om det behövs).
   • Redigera stm32xxx_it.c för att anropa de nödvändiga avbrottshanterarna (perifera och DMA), om det behövs.
   • Skrivprocessen kompletta återuppringningsfunktioner, om ett perifert avbrott eller DMA planeras att användas.
   • I användarens main.c file, initiera den perifera handtagsstrukturen och anropa sedan funktionen HAL_PPP_Init() för att initiera den perifera enheten.
7. Utveckla en applikation
   • Vid denna stage, systemet är klart och utvecklingen av användarapplikationskoden kan starta.
   • HAL tillhandahåller intuitiva och färdiga API:er för att konfigurera kringutrustningen. Den stöder polling, avbrott och en DMA-programmeringsmodell för att tillgodose alla applikationskrav. För mer information om hur du använder varje kringutrustning, se det rika exampsetet som ingår i STM32CubeWBA MCU-paketet.
     Försiktighet: I standard-HAL-implementeringen används SysTick-timern som en tidsbas: den genererar avbrott med regelbundna tidsintervall. Om HAL_Delay() anropas från den perifera ISR-processen, se till att SysTick-avbrottet har en högre prioritet (numeriskt lägre) än det perifera avbrottet. Annars blockeras uppringarens ISR-process. Funktioner som påverkar tidsbaskonfigurationer deklareras som __svaga för att göra åsidosättning möjlig vid andra implementeringar i användaren file (med en allmän timer, t.example, eller annan tidskälla). För mer information, se HAL_TimeBase example.

LL ansökan
Det här avsnittet beskriver de steg som krävs för att skapa en anpassad LL-applikation med STM32CubeWBA.

1. Skapa ett projekt
   • För att skapa ett nytt projekt, börja antingen från Templates_LL-projektet som tillhandahålls för varje bräda under \Projects\ \Templates_LL, eller från något tillgängligt projekt under \Projects\ \Examples_LL ( hänvisar till kortets namn, såsom NUCLEO-WBA32CG).
   • Mallprojektet tillhandahåller en tom huvudslingafunktion, vilket är en bra utgångspunkt för att förstå projektinställningarna för STM32CubeWBA. Mallens huvudegenskaper är följande:
     • Den innehåller källkoderna för LL- och CMSIS-drivrutinerna, som är den minsta uppsättning komponenter som behövs för att utveckla kod på ett givet kort.
     • Den innehåller de inkluderade sökvägarna för alla nödvändiga firmwarekomponenter.
     • Den väljer den enhet i STM32WBA-serien som stöds och tillåter korrekt konfiguration av CMSIS- och LL-drivrutinerna.
     • Det ger användaren redo att använda files som är förkonfigurerade enligt följande:
       ◦ main.h: LED och USER_BUTTON definition abstraktionsskikt.
       ◦ main.c: Systemklockkonfiguration för maximal frekvens.
2. Flytta ett befintligt projekt till en annan styrelse
   För att stödja ett befintligt projekt på ett annat måltavla, utgå från Templates_LL-projektet som tillhandahålls för varje bräda och tillgängligt under \Projects\ \Templates_LL.
   • Välj ett LL example: För att hitta tavlan där LL exampfiler är utplacerade, se listan över LL examples STM32CubeProjectsList.html.
3. Porta LL exampde:
   • Kopiera/klistra in mappen Templates_LL – för att behålla den ursprungliga källan – eller uppdatera det befintliga Templates_LL-projektet direkt.
   • Sedan består porteringen huvudsakligen av att ersätta Templates_LL files av Examples_LL riktat projekt.
   • Behåll alla brädspecifika delar. Av tydlighetsskäl flaggas brädspecifika delar med specifika tags:

     

   • De viktigaste porteringsstegen är alltså följande:
     • Byt ut stm32wbaxx_it.h file
     • Byt ut stm32wbaxx_it.c file
     • Byt ut huvud.h file och uppdatera den: Behåll LED- och användarknappdefinitionen för LL-mallen under BOARD SPECIFIC CONFIGURATION tags.
     • Byt ut huvud.c file och uppdatera den:
   • Behåll klockkonfigurationen för mallfunktionen SystemClock_Config() LL under BOARD SPECIFIC CONFIGURATION tags.
   • Beroende på LED-definitionen, byt ut varje LDx-förekomst med en annan LDy tillgänglig i main.h file.
   • Med dessa ändringar, example körs nu på måltavlan

Säkerhetsapplikationer
Detta paket levereras med säkerhetsapplikationer.

SBSFU-ansökningar

• SBSFU tillhandahåller en Root of Trust-lösning, inklusive Secure Boot och Secure Firmware Update-funktioner (baserad på MCUboot).
• Lösningen används innan applikationen körs.
• Lösningen ger ett example av en säker tjänst (GPIO-växling), som är isolerad från den osäkra applikationen. Den osäkra applikationen vid körning kan fortfarande använda den här lösningen.

TFM-applikationer
TFM tillhandahåller en Root of Trust-lösning inklusive Secure Boot och Secure Firmware Update-funktioner
(baserat på MCUboot). Lösningen används innan applikationen körs. Lösningen tillhandahåller TFM-säkra tjänster som är isolerade från den osäkra applikationen. Den osäkra applikationen vid körning kan fortfarande använda den här lösningen.

RF-applikationer
RF-applikationen beskrivs i denna applikationsanmärkning: Bygga trådlösa applikationer med STM32WBA-seriens mikrokontroller (AN5928).

Få STM32CubeWBA release uppdateringar
De senaste STM32CubeWBA MCU-paketutgåvorna och patchar är tillgängliga från STM32WBA-serien. De kan hämtas från knappen CHECK FOR UPDATE i STM32CubeMX. För mer information, se avsnitt 3 i användarmanualen STM32CubeMX för STM32-konfiguration och initiering C-kodgenerering (UM1718).

FAQ

• När ska jag använda HAL istället för LL-drivrutiner?
  • HAL-drivrutiner erbjuder högnivå- och funktionsorienterade API:er, med en hög nivå av portabilitet. Produkt eller perifer komplexitet är dold för slutanvändare.
  • LL-drivrutiner erbjuder API:er på låglagerregisternivå, med bättre optimering men mindre portabel. De kräver djupgående kunskaper om produkt- eller IP-specifikationer.
• Kan jag använda HAL- och LL-drivrutiner tillsammans? Om jag kan, vilka är begränsningarna?
  • Det är möjligt att använda både HAL- och LL-drivrutiner. Använd HAL för IP-initieringsfasen och hantera sedan I/O-operationerna med LL-drivrutiner.
  • Den stora skillnaden mellan HAL och LL är att HAL-drivrutiner måste skapa och använda handtag för drifthantering medan LL-drivrutiner fungerar direkt på perifera register. Exetamples_MIX example illustrerar hur man blandar HAL och LL.
• Hur är LL-initierings-API:er aktiverade?
  • Definitionen av LL-initierings-API:er och tillhörande resurser (strukturer, bokstaver och prototyper) betingas av kompileringsväxeln USE_FULL_LL_DRIVER.
  • För att kunna använda LL-initierings-API:er, lägg till denna switch i verktygskedjans kompilatorförprocessor.
• Hur kan STM32CubeMX generera kod baserad på inbäddad programvara?
  STM32CubeMX har inbyggd kunskap om STM32-mikrokontroller, inklusive deras kringutrustning och programvara som gör det möjligt att tillhandahålla en grafisk representation till användaren och generera *.h eller *.c files baserat på användarkonfiguration.

VIKTIGT MEDDELANDE – LÄS NOGGRANT

• STMicroelectronics NV och dess dotterbolag (“ST”) förbehåller sig rätten att göra ändringar, korrigeringar, förbättringar, modifieringar och förbättringar av ST-produkter och/eller av detta dokument när som helst utan föregående meddelande. Köpare bör skaffa den senaste relevanta informationen om ST-produkter innan de lägger beställningar. ST-produkter säljs i enlighet med ST:s försäljningsvillkor som gäller vid tidpunkten för ordererkännande.
• Köparen är ensam ansvarig för val, urval och användning av ST-produkter och ST tar inget ansvar för applikationshjälp eller design av köparens produkter.
• Ingen licens, uttrycklig eller underförstådd, till någon immateriell rättighet beviljas av ST häri.
• Återförsäljning av ST-produkter med bestämmelser som skiljer sig från den information som anges häri upphäver all garanti som beviljats ​​av ST för sådan produkt.
• ST och ST-logotypen är varumärken som tillhör ST. För ytterligare information om ST-varumärken, se www.st.com/trademarks. Alla andra produkt- eller tjänstnamn tillhör sina respektive ägare.
• Informationen i detta dokument ersätter och ersätter information som tidigare tillhandahållits i tidigare versioner av detta dokument.
• © 2023 STMicroelectronics – Alla rättigheter reserverade

Dokument/resurser

STMicroelectronics STM32WBA-serien Komma igång [pdf] Användarmanual STM32WBA-serien Komma igång, komma igång, komma igång

Referenser

• Användarmanual