Le script d'install du sdk du rpi pico commenté


  • Salut à tous,
    Je ne sais pas ce qui m'a pris (!!) mais je me suis décidé à essayé de comprendre cette après-midi de tempête le script d'install pour le sdk du rpi pico (fondation raspberry pi).
    Le sdk permet de programmer le microcontrôleur rp2040 tout juste sorti en c/c++ et assembleur.
    La notice du sdk est ici :
    https://datasheets.raspberrypi.com/pico/getting-started-with-pico.pdf
    Dedans on propose pour programmer ce microcontrôleur de le faire à partir d'un rpi4.
    Le script d'install (script shell bash) est ici :
    https://raw.githubusercontent.com/raspberrypi/pico-setup/master/pico_setup.sh
    Voici le contenu du script commenté, j'ai appris pas mal de choses sur cette install automatique (ne pas hésiter à me faire vos retours, je débute (enfin presque) dans les scripts shell. Au passage, je me suis aidé d'un petit livre qui me suis régulièrement pour la ligne de commande (et que je recommande ) :
    "La ligne de commande par l'exemple" de Vincent Fourmond (14.90 euro à l'époque)

    #!/bin/bash
    
    # set -e demande au script de s'arrêter en cas de code de retour erreur sur une commande
    set -e
    
    # avec la commande grep, on cherche la chaîne "Raspberry" dans /proc/cpuinfo qui donne des infos sur le processeur utilisé
    if grep -q Raspberry /proc/cpuinfo; then
        echo "Running on a Raspberry Pi"
    else
        echo "Not running on a Raspberry Pi. Use at your own risk!"
    fi
    
    # Number of cores when running make : on met le nombre de coeurs à 4, ça peut permettre de faire des compilations de code avec Gcc(et autres) plus rapides
    JNUM=4
    
    # Where will the output go? : le dossier (de sortie) de l'installation du sdk pico
    OUTDIR="$(pwd)/pico"
    
    # Install dependencies : installation des paquets logiciels complémentaires (dépendances)
    # Utile pour l'installation du paquet debian "git" (logiciel en ligne de commande de versionning de fichier utilisé par de nombreux développeurs)
    GIT_DEPS="git"
    # Utile pour l'installation des paquets cmake (utilitaire de construction logicielle), gcc-arm-non-eabi (toolchain pour compiler sur processeur M0 et autres), gcc (compilateur et accessoires), g++ (compilateur c++)
    SDK_DEPS="cmake gcc-arm-none-eabi gcc g++"
    # Utile pour l'installation des paquets gdb-multiarch (débogueur multi architecture), automake(), autoconf (système de création de fichier de config automatisé), build-essential (utilitaires de construction), texinfo (sortie de texte au format gnu texinfo), libtool (), libtool (), libftdi-dev (librairie C pour l'utilisation des communications UART), libusb...(librairie pour l'utilisation de USB);
    OPENOCD_DEPS="gdb-multiarch automake autoconf build-essential texinfo libtool libftdi-dev libusb-1.0-0-dev"
    # Wget to download the deb (WGET = utilitaire pour charger du contenu web/ftp en ligne de commande)
    VSCODE_DEPS="wget"
    #Minicom : console série en ligne de commande
    UART_DEPS="minicom"
    
    # Build full list of dependencies : une chaîne de caractère contenant la liste des paquets à installer
    DEPS="$GIT_DEPS $SDK_DEPS"
    
    # Les doubles crochets correspondent au nouveau style pour les tests bash. == est pour l'égalité entre deux chaînes de caractères pour bash (c'est = pour d'autres shells).
    if [[ "$SKIP_OPENOCD" == 1 ]]; then
        echo "Skipping OpenOCD (debug support)"
    else
        DEPS="$DEPS $OPENOCD_DEPS"
    fi
    
    if [[ "$SKIP_VSCODE" == 1 ]]; then
        echo "Skipping VSCODE"
    else
        DEPS="$DEPS $VSCODE_DEPS"
    fi
    
    echo "Installing Dependencies"
    sudo apt update
    # Le paramètres -y demande de répondre automatiquement yes à l'install des paquets apt
    sudo apt install -y $DEPS
    
    echo "Creating $OUTDIR"
    # Create pico directory to put everything in : on créer le dossier pico pour mettre tout dedans
    mkdir -p $OUTDIR
    cd $OUTDIR
    
    # Clone sw repos : les variables contenant les parties de dossiers pour les téléchargement github
    GITHUB_PREFIX="https://github.com/raspberrypi/"
    GITHUB_SUFFIX=".git"
    SDK_BRANCH="master"
    
    # l'action va être faite pour les repositeries : sdk, examples, extras  et playground (que l'on peut voir à l'adresse : https://github.com/orgs/raspberrypi/repositories?type=all
    for REPO in sdk examples extras playground
    do
        DEST="$OUTDIR/pico-$REPO"
    # si la variable $DEST correspond à un dossier (renvoie true)
        if [ -d $DEST ]; then
            echo "$DEST already exists so skipping"
        else
    #constitution de l'adresse complète du repository
            REPO_URL="${GITHUB_PREFIX}pico-${REPO}${GITHUB_SUFFIX}"
            echo "Cloning $REPO_URL"
    # le -b correspond au nom d'une branche
            git clone -b $SDK_BRANCH $REPO_URL
    
            # Any submodules
            cd $DEST
            git submodule update --init
            cd $OUTDIR
    
            # Define PICO_SDK_PATH in ~/.bashrc
            VARNAME="PICO_${REPO^^}_PATH"
            echo "Adding $VARNAME to ~/.bashrc"
    # on envoie la sortie echo dans le fichier de config .bashrc il s'agit d'un affectation de variable (VARNAME prend le contenu de DEST) 
    # et on exporte VARNAME comme une variable d'environnement (le fait de mettre dans .bashrc rend la chose non temporaire.
            echo "export $VARNAME=$DEST" >> ~/.bashrc
            export ${VARNAME}=$DEST
        fi
    done
    
    cd $OUTDIR
    
    # Pick up new variables we just defined : on recharge la config dans .bashrc avec la commande "source"
    source ~/.bashrc
    
    # Build a couple of examples
    cd "$OUTDIR/pico-examples"
    mkdir build
    cd build
    # on construit les exemples
    cmake ../ -DCMAKE_BUILD_TYPE=Debug
    
    # on fait un make pour blink et hello_world
    for e in blink hello_world
    do
        echo "Building $e"
        cd $e
    # on met l'option de make avec plusieurs processeurs (option "-j")
        make -j$JNUM
        cd ..
    done
    
    cd $OUTDIR
    
    # Picoprobe and picotool
    for REPO in picoprobe picotool
    do
        DEST="$OUTDIR/$REPO"
        REPO_URL="${GITHUB_PREFIX}${REPO}${GITHUB_SUFFIX}"
    # on récupère le dépôt en local pour picoprobe et picotool
        git clone $REPO_URL
    
        # Build both
        cd $DEST
        mkdir build
        cd build
        cmake ../
        make -j$JNUM
    
        if [[ "$REPO" == "picotool" ]]; then
            echo "Installing picotool to /usr/local/bin/picotool"
    # on copie picotool vers local/bin
            sudo cp picotool /usr/local/bin/
        fi
    
        cd $OUTDIR
    done
    
    # si opencd est bien un dossier
    if [ -d openocd ]; then
        echo "openocd already exists so skipping"
        SKIP_OPENOCD=1
    fi
    
    if [[ "$SKIP_OPENOCD" == 1 ]]; then
        echo "Won't build OpenOCD"
    else
        # Build OpenOCD
        echo "Building OpenOCD"
        cd $OUTDIR
        # Should we include picoprobe support (which is a Pico acting as a debugger for another Pico)
        INCLUDE_PICOPROBE=1
        OPENOCD_BRANCH="rp2040"
        OPENOCD_CONFIGURE_ARGS="--enable-ftdi --enable-sysfsgpio --enable-bcm2835gpio"
        if [[ "$INCLUDE_PICOPROBE" == 1 ]]; then
            OPENOCD_CONFIGURE_ARGS="$OPENOCD_CONFIGURE_ARGS --enable-picoprobe"
        fi
    
        git clone "${GITHUB_PREFIX}openocd${GITHUB_SUFFIX}" -b $OPENOCD_BRANCH --depth=1
        cd openocd
        ./bootstrap
        ./configure $OPENOCD_CONFIGURE_ARGS
        make -j$JNUM
    # on installe openocd
        sudo make install
    fi
    
    cd $OUTDIR
    
    # Liam needed to install these to get it working : la variable qui contient les paquets nécessaires pour l'install de vscode
    EXTRA_VSCODE_DEPS="libx11-xcb1 libxcb-dri3-0 libdrm2 libgbm1 libegl-mesa0"
    if [[ "$SKIP_VSCODE" == 1 ]]; then
        echo "Won't include VSCODE"
    else
    # vérification si vscode.deb est un fichier (-f)
        if [ -f vscode.deb ]; then
            echo "Skipping vscode as vscode.deb exists"
        else
            echo "Installing VSCODE"
    # on récupère le type de processeur avec uname et on le passe dans grep
            if uname -m | grep -q aarch64; then
                VSCODE_DEB="https://aka.ms/linux-arm64-deb"
            else
                VSCODE_DEB="https://aka.ms/linux-armhf-deb"
            fi
    # on télécharge vscode.deb plus le deb du proc avec wget
            wget -O vscode.deb $VSCODE_DEB
            sudo apt install -y ./vscode.deb
    # on télécharge les paquets nécessaires
            sudo apt install -y $EXTRA_VSCODE_DEPS
    
    # à partir de vscode, on installe des extensions (débeugage de arm cortex, des tools cmakes, et des outils cplus plus)
            # Get extensions
            code --install-extension marus25.cortex-debug
            code --install-extension ms-vscode.cmake-tools
            code --install-extension ms-vscode.cpptools
        fi
    fi
    
    # Enable UART
    if [[ "$SKIP_UART" == 1 ]]; then
        echo "Skipping uart configuration"
    else
    # on installe la console série minicom
        sudo apt install -y $UART_DEPS
        echo "Disabling Linux serial console (UART) so we can use it for pico"
    # on désactive la sortie habituelle uart pour pouvoir utiliser la sortie uart gpio en utilisant l'utilitaire raspi-config en ligne de commande https://raspberry-pi.fr/activer-port-serie-raspberry-pi/
        sudo raspi-config nonint do_serial 2
        echo "You must run sudo reboot to finish UART setup"
    fi
    # Voilà, je me suis bien amusé à comprendre tout ça !
    
    

  • Belle transition avec la présentation de @livrecinq le 5 mars dernier autour de la programmation.

    Commentaire ou pas ? les avis divergent. Comment s'y prendre alors ? Un article (en anglais) sur le sujet https://stackoverflow.blog/2021/12/23/best-practices-for-writing-code-comments/.


  • @Olivier
    Intéressant ces recommandations (j'aime bien l'histoire de ripjsb !). A lire à tête reposée.
    En ce qui me concerne, quadruple objectif :

    • découvrir le shell plus en profondeur (je fais déjà des scripts basiques mais il est bon d'apprendre du code d'autrui).
    • autodocumenter pour comprendre.
    • comprendre l'environnement de dev pico rp2040
    • permettre à d'autres de comprendre (d'où ma publication).

  • Il existe une liste très complète sur les Shell à l'adresse https://github.com/alebcay/awesome-shell. Une autre sur le bash à l'adresse https://github.com/awesome-lists/awesome-bash.

    https://github.com/search?q=bash&l=shell&type=Repositories à saisir dans la barre d'adresse du navigateur web pour filtrer les projets en bash sur Github tagués avec l'étiquette langage Shell. Un bon moyen comme tu le disais d'apprendre du code des autres.


  • @yannick85 Super boulot, très utile : merci !

Sujets suggérés