Inizia a sviluppare STM32 su Linux: 4 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:00

In questo Instructable, ti mostrerò quanto è facile iniziare a sviluppare programmi STM32 su Linux. Ho iniziato a utilizzare Linux come macchina principale 2 anni fa e non sono stato deluso. Tutto funziona più velocemente e meglio di Windows. Ovviamente è meno conveniente di tanto in tanto, ma ti costringe a imparare le cose più a fondo in modo da poterlo usare.

Ad ogni modo, in questo istruibile, parte di una serie che sto iniziando qui E su youtube riguarda come avviarlo. Assicurati di guardare anche il mio video su YouTube in cui spiego tutto come un segmento e puoi codificare insieme a me.

In questa serie ti mostrerò come puoi sviluppare utilizzando solo un editor di testo come Notepad, SublimeText o Atom, quindi non hai bisogno di alcun software proprietario o IDE. Questo è il più semplice possibile ed è sorprendentemente facile.

Passaggio 1: scarica tutto ciò di cui hai bisogno

È necessario scaricare tre parti affinché tutto funzioni:

• Compilatore GCC per ARM
• File del firmware STM32
• Utilità St-link
• Progetto di esempio

Il compilatore è il software principale che compila il nostro codice C con tutti gli altri file di libreria in un linguaggio macchina comprensibile dal nostro controller stm32. Scarica l'ultima versione precompilata di questo compilatore.

La cartella contenente il firmware STM32 è quella che contiene tutti i file di avvio e core necessari per il funzionamento del processore principale. Useremo la libreria di periferiche standard che è stata superata da HAL. Mi piace di più StPeriphLibrary poiché le aziende che lavorano su questi processori li usano perché è robusto, vecchio e supportato. È anche più robusto. Non taglia il lavoro che devi fare per inizializzare una periferica o accendere un LED ma, quindi, ti costringe a imparare come funzionano questi processori. Con ciò hai più conoscenza dei meccanismi interni, dando così un senso alla programmazione di qualsiasi attività.

L'ultimo software da scaricare è l'utilità st-link. È mantenuto su github e viene utilizzato per trasferire file binari compilati al processore utilizzando stlink IC sulla scheda che funge da programmatore/debugger SWD / JTAG.

Inoltre ho fornito una cartella di progetto di esempio di cui parlerò in seguito e puoi scaricarla. Si trova all'interno della prima cartella VIDEO1.

Passaggio 2: installazione del software

Dopo aver scaricato tutti i file ti suggerisco di inserirli all'interno di una cartella comune in quanto vengono utilizzati tutti insieme per lo stesso scopo. Ho messo tutte le cartelle all'interno di una cartella chiamata "Embedded" nella mia directory HOME.

Inizieremo con la più semplice, le librerie STM32. La cartella che hai scaricato può essere semplicemente lasciata lì. Assicurati solo di scavare in giro per vedere dove sono archiviati i file appropriati. Pertanto puoi cambiare e modificare il MakeFile principale in modo che funzioni con la tua piattaforma.

Il secondo più semplice è il compilatore. Inoltre, non è necessario eseguire alcuna operazione, ma renderemo il compilatore una funzione accessibile a livello globale in modo da poter chiamare il compilatore da qualsiasi cartella indipendentemente dal percorso. Tutti i passaggi possono essere eseguiti nel terminale o nella GUI, ma mi piace usare il terminale poiché quando hai esperienza diventa più veloce e più facile e ti incoraggio a usare di più il terminale, se ne hai paura. Ecco i passaggi:

1. Vai nella tua cartella home "/home/YOURUSERNAME/" o "~/" o digita cd nel terminale
2. apri il file ".bashrc" digitando: nano.bashrc
3. scorri verso il basso fino alla fine del file e aggiungi questa riga: export PATH=$PATH:~/Embedded/gcc-arm-none-eabi-8-2018-q4/bin
4. uscire salvando: CTRL+X, fare clic su Y, INVIO
5. esegui il comando: source.bashrc per aggiornare i sorgenti del terminale
6. controlla se tutto funziona digitando: arm-none-eabi-gcc --version, dovrebbe mostrare l'ultima versione del compilatore

Per installare st-link, estrai l'archivio che hai scaricato nella cartella Embedded. Quindi segui questi passaggi:

1. Esegui: fai
2. Vai nella cartella "build/Release": cd build/Release
3. Digita ls e vedrai due eseguibili chiamati "st-flash" e "st-util"
4. Sposta quei due nella directory principale stlink: mv st-flash st-util../../

5. Puoi, se desideri utilizzare queste due funzioni, modificare di nuovo globalmente il file ".bashrc" aggiungendo:

   export PATH=$PATH:~/Embedded/stlink/

È tutto! Hai tutto ciò di cui hai bisogno. Ora vai a prendere il tuo editor di testo preferito. Usa solo uno standard, uno più intelligente come SublimeText o Atom, è quello che uso.

Passaggio 3: impostazione di un progetto di esempio

Ora creeremo un progetto di esempio che puoi utilizzare per avviare ogni progetto. È come un modello con tutte le impostazioni principali già gestite.

Puoi scaricarlo sul mio MEGA, il link è sul primo passaggio di questo istruibile e sotto ogni mio video di YouTube. All'interno c'è il file main.c vuoto insieme ad alcuni file di avvio per questo processore e il Makefile. Makefile è quello che dice al compilatore C dove trovare il compilatore arm, come compilare e dove sono tutte le librerie. Per ottenere questi file appropriati per il tuo progetto, puoi andare nella cartella della libreria STM32 e cercare le cartelle "progetto" o "esempi". All'interno vedrai e copierai questi file: main.c, Makefile e XXX_conf.h, system_XXX.c. Inoltre avrai bisogno del file linker stm32_flash.ld che si trova nella cartella:

"/FLASH_Program/TrueSTUDIO/FLASH_Program/" che si trova all'interno della cartella di esempio o semplicemente cerca il file.

Makefile può essere trovato online o copiato dalla mia cartella, ma dovrai cambiare alcune cose. Diamo un'occhiata al mio file make e cosa potresti cambiare.

# Percorso alla cartella Stlink per caricare il codice sulla scheda

STLINK=~/Embedded/stlink # Metti qui i tuoi file sorgente (*.c) SRCS=main.c system_stm32f4xx.c # File sorgenti delle librerie #SRCS += stm32f4xx_rcc.c #SRCS += stm32f4xx_gpio.c # I binari verranno generati con questo nome (.elf,.bin,.hex) PROJ_NAME=test # Inserisci qui la directory del codice della libreria STM32F4, cambia YOURUSERNAME nel tuo STM_COMMON=/home/matej/Embedded/STM32F4-Discovery_FW_V1.1.0 # Impostazioni del compilatore. Modifica solo CFLAGS per includere altri file di intestazione. CC=arm-none-eabi-gcc OBJCOPY=arm-none-eabi-objcopy # Flag del compilatore CFLAGS = -g -O2 -Wall -Tstm32_flash.ld CFLAGS += -DUSE_STDPERIPH_DRIVER CFLAGS += -mlittle-endian -mthumb -mcpu= cortex-m4 -mthumb-interwork CFLAGS += -mfloat-abi=hard -mfpu=fpv4-sp-d16 CFLAGS += -I. # Include file dalle librerie STM CFLAGS += -I$(STM_COMMON)/Libraries/CMSIS/Include CFLAGS += -I$(STM_COMMON)/Libraries/CMSIS/ST/STM32F4xx/Include CFLAGS += -I$(STM_COMMON)/ Libraries/STM32F4xx_StdPeriph_Driver/inc CFLAGS += -I$(STM_COMMON)/Utilities/STM32F4-Discovery # aggiungi il file di avvio per compilare SRCS += $(STM_COMMON)/Libraries/CMSIS/ST/STM32Fxx4xx/Source/STU. s OBJS = $(SRCS:.c=.o) vpath %.c $(STM_COMMON)/Libraries/STM32F4xx_StdPeriph_Driver/src \. PHONY: proj all: proj proj: $(PROJ_NAME).elf $(PROJ_NAME).elf: $(SRCS) $(CC) $(CFLAGS) $^ -o $@ $(OBJCOPY) -O ihex $(PROJ_NAME).elf $(PROJ_NAME).hex $(OBJCOPY) -O binary $(PROJ_NAME).elf $(NOME_PROJ).bin clean: rm -f *.o $(NOME_PROJ).elf $(NOME_PROJ).hex $(NOME_PROJ).bin # Flasha l'STM32F4 masterizza: proj $(STLINK)/st-flash write $(PROJ_NAME).bin 0x80000000

• Puoi modificare la prima riga per cambiare il percorso della cartella dell'utilità stlink

• Puoi cambiare riga alla destinazione della tua cartella con le librerie e YOURUSERNAME

  STM_COMMON=/home/YOURUSERNAME/Embedded/STM32F4-Discovery_FW_V1.1.0

• Controlla anche la sezione dove sono collegate tutte le librerie. Questo può cambiare a seconda della piattaforma che stai utilizzando, quindi controlla le modifiche nell'albero dei file. Tutto il resto che include percorsi a determinati file, come la riga successiva con il file di avvio, può essere modificato.

Dopo aver modificato tutte queste cose all'interno del Makefile puoi verificare se funziona aprendo un terminale all'interno della tua directory e digitando: make. Se compila tutto senza problemi, allora sei a posto. In caso contrario, guarda gli errori del compilatore e modifica il Makefile.

Inoltre, quando uso Atom, metto due pezzi di codice fianco a fianco. Di solito main.c e Makefile a sinistra poiché è necessario modificare Makefile solo una volta e le librerie a destra. Puoi vedere nell'immagine che ho aperto la cartella contenente i file.c e.h per ogni libreria. Puoi vedere tutto questo nei video.

Passaggio 4: finito

Ora che hai il Makefile configurato e il compilatore funzionante, puoi usare questa cartella per tutti i progetti come modello, quindi assicurati di salvare una copia di questa cartella.

Inoltre puoi testare i programmi st-flash e st-info collegando la tua scheda di sviluppo e digitando nel terminale:

st-info --probe

Puoi vedere la piattaforma che il software stlink riconosce e la famiglia IC insieme alla cache e altre cose. Puoi digitare:

st-informazioni

per vedere tutti i parametri disponibili.

Ora puoi iniziare a programmare. Nel prossimo tutorial e video, ti mostrerò le basi di GPIO e orologi. Questi due sono le basi per tutto il resto poiché quasi tutto ciò con cui la scheda interagisce è su GPIO e tutto funziona sull'orologio e vedrai lo schema per programmare questi processori.

Fino ad allora, grazie per aver guardato il mio tutorial e il mio video su YouTube, se non l'hai ancora fatto.