ci: support series with only one x

Signed-off-by: Frederic Pillon <[email protected]>

Author: fpistm

CI/update/stm32cube.py

@@ -1,11 +1,11 @@
 import argparse
-import collections
 import fileinput
 import json
 import re
 import subprocess
 import stm32wrapper
 import sys
+from collections import OrderedDict
 from jinja2 import Environment, FileSystemLoader
 from packaging import version
 from pathlib import Path
@@ -14,7 +14,7 @@
 
 script_path = Path(__file__).parent.resolve()
 sys.path.append(str(script_path.parent))
-from utils import copyFile, copyFolder, createFolder, deleteFolder, genSTM32List
+from utils import copyFile, copyFolder, createFolder, deleteFolder, genSTM32Dict
 from utils import defaultConfig, execute_cmd, getRepoBranchName
 
 if sys.platform.startswith("win32"):
@@ -45,12 +45,15 @@
 hal_dest_path = system_dest_path / hal_src_path
 cmsis_dest_path = system_dest_path / hal_src_path / "CMSIS" / "Device" / "ST"
 
+nx = "xx"  # Default number of x in STM32 series
+
 stm32_list = []  # series
-cube_versions = collections.OrderedDict()  # key: serie name, value: cube version
-cube_HAL_versions = collections.OrderedDict()  # key: serie name, value: HAL version
-cube_CMSIS_versions = collections.OrderedDict()  # key: serie name, value: CMSIS version
-core_HAL_versions = collections.OrderedDict()  # key: serie name, value: HAL version
-core_CMSIS_versions = collections.OrderedDict()  # key: serie name, value: CMSIS version
+stm32_dict = OrderedDict()  # key: serie, value: nx
+cube_versions = OrderedDict()  # key: serie name, value: cube version
+cube_HAL_versions = OrderedDict()  # key: serie name, value: HAL version
+cube_CMSIS_versions = OrderedDict()  # key: serie name, value: CMSIS version
+core_HAL_versions = OrderedDict()  # key: serie name, value: HAL version
+core_CMSIS_versions = OrderedDict()  # key: serie name, value: CMSIS version
 
 # MD to update
 md_CMSIS_path = "STM32YYxx_CMSIS_version.md"
@@ -123,7 +126,7 @@ def checkConfig():
 
 def updateStm32Def(serie):
     print(f"Adding top HAL include for {serie}...")
-    regex_serie = re.compile(r"defined\(STM32(\w+)xx\)")
+    regex_serie = re.compile(rf"defined\(STM32(\w+){nx}\)")
     # Add the new STM32YY entry
     added = False
     serie_found = ""
@@ -142,23 +145,23 @@ def updateStm32Def(serie):
                 pcond = "if"
             else:
                 pcond = "elif"
-            print(f"#{pcond} defined(STM32{serie}xx)")
-            print(f'  #include "stm32{serie.lower()}xx.h"')
+            print(f"#{pcond} defined(STM32{serie}{nx})")
+            print(f'  #include "stm32{serie.lower()}{nx}.h"')
             print(line.replace("#if", "#elif"), end="")
             added = True
         else:
             print(line, end="")
 
 
 def updateHalConfDefault(serie):
-    system_serie = system_dest_path / f"STM32{serie}xx"
-    hal_conf_base = f"stm32{serie.lower()}xx_hal_conf"
+    system_serie = system_dest_path / f"STM32{serie}{nx}"
+    hal_conf_base = f"stm32{serie.lower()}{nx}_hal_conf"
     hal_conf_default = system_serie / f"{hal_conf_base}_default.h"
 
     regex_module = re.compile(r"#define HAL_(\w+)_MODULE_ENABLED")
 
-    old_guard = f"STM32{serie}xx_HAL_CONF_H"
-    new_guard = f"STM32{serie}xx_HAL_CONF_DEFAULT_H"
+    old_guard = f"STM32{serie}{nx}_HAL_CONF_H"
+    new_guard = f"STM32{serie}{nx}_HAL_CONF_DEFAULT_H"
     module_sel = "Module Selection"
 
     new_include = """/**
@@ -191,16 +194,16 @@ def updateHalConfDefault(serie):
 
 def createSystemFiles(serie):
     print(f"Creating system files for {serie}...")
-    system_serie = system_dest_path / f"STM32{serie}xx"
+    system_serie = system_dest_path / f"STM32{serie}{nx}"
     createFolder(system_serie)
     # Generate stm32yyxx_hal_conf_file.h
     stm32_hal_conf_file = system_serie / stm32yyxx_hal_conf_file.replace(
         "yy", serie.lower()
-    )
+    ).replace("xx", nx)
     with open(stm32_hal_conf_file, "w", newline="\n") as out_file:
-        out_file.write(stm32yyxx_hal_conf_file_template.render(serie=serie))
+        out_file.write(stm32yyxx_hal_conf_file_template.render(serie=serie, nx=nx))
     # Copy system_stm32*.c file from CMSIS device template
-    system_stm32_path = cmsis_dest_path / f"STM32{serie}xx" / "Source" / "Templates"
+    system_stm32_path = cmsis_dest_path / f"STM32{serie}{nx}" / "Source" / "Templates"
     filelist = sorted(system_stm32_path.glob("system_stm32*.c"))
     file_number = len(filelist)
     if file_number:
@@ -217,8 +220,8 @@ def createSystemFiles(serie):
     else:
         print("No system files found!")
     # Copy stm32yyxx_hal_conf_default.h file
-    hal_conf_base = f"stm32{serie.lower()}xx_hal_conf"
-    hal_serie_path = hal_dest_path / f"STM32{serie}xx_HAL_Driver"
+    hal_conf_base = f"stm32{serie.lower()}{nx}_hal_conf"
+    hal_serie_path = hal_dest_path / f"STM32{serie}{nx}_HAL_Driver"
     hal_conf_file = hal_serie_path / "Inc" / f"{hal_conf_base}_template.h"
     hal_conf_default = system_serie / f"{hal_conf_base}_default.h"
     copyFile(hal_conf_file, hal_conf_default)
@@ -307,10 +310,30 @@ def checkSTLocal():
 
 
 def updateSTRepo():
+    global nx
     # Handle STM32Cube repo
     for serie in stm32_list:
         repo_name = f"{repo_generic_name}{serie}"
         repo_path = repo_local_path / repo_name
+        if upargs.add:
+            # Series can have only one x,
+            # find directory starting with STM32 and ending with HAL_Driver
+            # in hal_src_path folder then check number of x
+            for f in (repo_path / hal_src_path).iterdir():
+                if f.is_dir():
+                    if f.name.startswith(f"STM32{serie}xx_HAL_Driver"):
+                        nx = "xx"
+                        break
+                    elif f.name.startswith(f"STM32{serie}x_HAL_Driver"):
+                        nx = "x"
+                        break
+            else:
+                print(
+                    f"Could not find HAL_Driver for {serie} in {repo_path / hal_src_path}"
+                )
+                exit(1)
+            stm32_dict[serie] = nx
+        nx = stm32_dict[serie]
         gh_STM32Cube = urljoin(gh_st, f"{repo_name}.git")
         print(f"Updating {repo_name}...")
         if repo_path.exists():
@@ -428,39 +451,39 @@ def checkVersion(serie, repo_path):
     HAL_file = (
         repo_path
         / hal_src_path
-        / f"STM32{userie}xx_HAL_Driver"
+        / f"STM32{userie}{nx}_HAL_Driver"
         / "Src"
-        / f"stm32{lserie}xx_hal.c"
+        / f"stm32{lserie}{nx}_hal.c"
     )
     with open(HAL_file, "r") as fp:
         data = fp.read()
         if "HAL_VERSION_MAIN" not in data:
             HAL_file = (
                 repo_path
                 / hal_src_path
-                / f"STM32{userie}xx_HAL_Driver"
+                / f"STM32{userie}{nx}_HAL_Driver"
                 / "Inc"
-                / f"stm32{lserie}xx_hal.h"
+                / f"stm32{lserie}{nx}_hal.h"
             )
     cube_HAL_versions[serie] = parseVersion(HAL_file, patterns)
     if upargs.add:
         core_HAL_versions[serie] = "0.0.0"
     else:
         HAL_file = (
             hal_dest_path
-            / f"STM32{userie}xx_HAL_Driver"
+            / f"STM32{userie}{nx}_HAL_Driver"
             / "Src"
-            / f"stm32{lserie}xx_hal.c"
+            / f"stm32{lserie}{nx}_hal.c"
         )
         with open(HAL_file, "r") as fp:
             data = fp.read()
             if "HAL_VERSION_MAIN" not in data:
                 HAL_file = (
                     repo_path
                     / hal_dest_path
-                    / f"STM32{userie}xx_HAL_Driver"
+                    / f"STM32{userie}{nx}_HAL_Driver"
                     / "Inc"
-                    / f"stm32{lserie}xx_hal.h"
+                    / f"stm32{lserie}{nx}_hal.h"
                 )
         core_HAL_versions[serie] = parseVersion(HAL_file, patterns)
 
@@ -479,16 +502,25 @@ def checkVersion(serie, repo_path):
     CMSIS_file = (
         repo_path
         / cmsis_src_path
-        / f"STM32{userie}xx"
+        / f"STM32{userie}{nx}"
         / "Include"
-        / f"stm32{lserie}xx.h"
+        / f"stm32{lserie}{nx}.h"
     )
+    # Some CMSIS folder have a uppercase x
+    if not CMSIS_file.is_file():
+        CMSIS_file = (
+            repo_path
+            / cmsis_src_path
+            / f"STM32{userie}{nx.upper()}"
+            / "Include"
+            / f"stm32{lserie}{nx}.h"
+        )
     cube_CMSIS_versions[serie] = parseVersion(CMSIS_file, patterns)
     if upargs.add:
         core_CMSIS_versions[serie] = "0.0.0"
     else:
         CMSIS_file = (
-            cmsis_dest_path / f"STM32{userie}xx" / "Include" / f"stm32{lserie}xx.h"
+            cmsis_dest_path / f"STM32{userie}{nx}" / "Include" / f"stm32{lserie}{nx}.h"
         )
         core_CMSIS_versions[serie] = parseVersion(CMSIS_file, patterns)
 
@@ -834,12 +866,14 @@ def updateOpenAmp():
 
 
 def updateCore():
+    global nx
     for serie in stm32_list:
         if upargs.path:
             cube_path = local_cube_path
         else:
             cube_name = f"{repo_generic_name}{serie}"
             cube_path = repo_local_path / cube_name
+        nx = stm32_dict[serie.removeprefix("STM32")]
         core_HAL_ver = core_HAL_versions[serie]
         cube_HAL_ver = cube_HAL_versions[serie]
         core_CMSIS_ver = core_CMSIS_versions[serie]
@@ -848,23 +882,25 @@ def updateCore():
         HAL_updated = False
         CMSIS_updated = False
         openamp_updated = False
-        hal_commit_msg = """system({0}) {4} STM32{1}xx HAL Drivers to v{2}
+        hal_commit_msg = """system({0}) {4} STM32{1}{5} HAL Drivers to v{2}
 
 Included in STM32Cube{1} FW {3}""".format(
             serie.lower(),
             serie,
             cube_HAL_ver,
             cube_version,
             "add" if upargs.add else "update",
+            nx,
         )
-        cmsis_commit_msg = """system({0}): {4} STM32{1}xx CMSIS Drivers to v{2}
+        cmsis_commit_msg = """system({0}): {4} STM32{1}{5} CMSIS Drivers to v{2}
 
 Included in STM32Cube{1} FW {3}""".format(
             serie.lower(),
             serie,
             cube_CMSIS_ver,
             cube_version,
             "add" if upargs.add else "update",
+            nx,
         )
         wrapper_commit_msg = (
             f"core({serie.lower()}): {'add' if upargs.add else 'update'} wrapped files"
@@ -879,11 +915,11 @@ def updateCore():
                     f"Updating {serie} HAL from version {core_HAL_ver} to {cube_HAL_ver}..."
                 )
             # First delete old HAL version
-            HAL_serie_core_path = hal_dest_path / f"STM32{serie}xx_HAL_Driver"
+            HAL_serie_core_path = hal_dest_path / f"STM32{serie}{nx}_HAL_Driver"
             deleteFolder(HAL_serie_core_path)
             # Copy new one
             HAL_serie_cube_path = (
-                cube_path / hal_src_path / f"STM32{serie}xx_HAL_Driver"
+                cube_path / hal_src_path / f"STM32{serie}{nx}_HAL_Driver"
             )
             copyFolder(
                 HAL_serie_cube_path,
@@ -903,10 +939,21 @@ def updateCore():
                     f"Updating {serie} CMSIS from version {core_CMSIS_ver} to {cube_CMSIS_ver}..."
                 )
             # First delete CMSIS folder
-            CMSIS_serie_dest_path = cmsis_dest_path / f"STM32{serie}xx"
+            CMSIS_serie_dest_path = cmsis_dest_path / f"STM32{serie}{nx}"
             deleteFolder(CMSIS_serie_dest_path)
             # Copy new one
-            CMSIS_serie_cube_path = cube_path / cmsis_src_path / f"STM32{serie}xx"
+            CMSIS_serie_cube_path = cube_path / cmsis_src_path / f"STM32{serie}{nx}"
+            # Check if path exists
+            if not CMSIS_serie_cube_path.exists():
+                # Try to find the upper case version, ex: WB0X
+                CMSIS_serie_cube_path = (
+                    cube_path / cmsis_src_path / f"STM32{serie}{nx.upper()}"
+                )
+            if not CMSIS_serie_cube_path.exists():
+                print(f"Could not find CMSIS serie {serie} in {CMSIS_serie_cube_path}!")
+                exit(1)
+            # Copy CMSIS files
+            # note: that dest path uses lower x case
             copyFolder(
                 CMSIS_serie_cube_path,
                 CMSIS_serie_dest_path,
@@ -919,12 +966,12 @@ def updateCore():
 
         if upargs.add:
             system_commit_msg = (
-                f"system({serie.lower()}): add STM32{serie}xx system source files"
+                f"system({serie.lower()}): add STM32{serie}{nx} system source files"
             )
             update_hal_conf_commit_msg = (
-                f"system({serie.lower()}): update STM32{serie}xx hal default config"
+                f"system({serie.lower()}): update STM32{serie}{nx} hal default config"
             )
-            update_stm32_def_commit_msg = f"core({serie}): add top HAL include"
+            update_stm32_def_commit_msg = f"core({serie.lower()}): add top HAL include"
             # Create system files
             createSystemFiles(serie)
             # Commit all system files
@@ -934,7 +981,7 @@ def updateCore():
             commitFiles(core_path, update_hal_conf_commit_msg)
             print("\tPlease, review carefully all the system files added!")
             print("\tAdd #ifndef/#endif to all definitions which should be")
-            print(f"\tredefinable in the stm32{serie.lower()}xx_hal_conf_default.h")
+            print(f"\tredefinable in the stm32{serie.lower()}{nx}_hal_conf_default.h")
             # Update stm32_def to add top HAL include
             updateStm32Def(serie)
             commitFiles(core_path, update_stm32_def_commit_msg)
@@ -1008,14 +1055,19 @@ def updateCore():
 
 
 def main():
+    global stm32_dict
     global stm32_list
     # check config have to be done first
     checkConfig()
-    stm32_list = genSTM32List(hal_dest_path, upargs.serie)
     if not upargs.local:
         updateCoreRepo()
     else:
         checkCoreRepo()
+    stm32_dict = genSTM32Dict(hal_dest_path, upargs.serie)
+    stm32_list = sorted(list(stm32_dict.keys()))
+    if not stm32_list:
+        print(f"{upargs.serie} is not supported yet. Consider using -a instead of -s")
+        exit(1)
     if upargs.add:
         if upargs.add.upper() not in stm32_list:
             stm32_list = [upargs.add.upper()]