"multiple definition of first defined here". STM32, AC6 Studio

Those are linker errors. You are probably doing something like this:

main.c:

#include "lib.h"

init.c:

#include "lib.h"

When the linker inspects the symbols and types in main.c and init.c, it finds that exact same symbols have been defined in each of them, therefore the error. Normally a header files only declare symbols, not define them, but there are some creative uses of conditional code that can get around this:

lib.h (please think of a more descriptive name for this file)

#if defined IN_INIT_C
  volatile SYSCFG_t* mysyscfg=(volatile SYSCFG_t*)MYSYSCFG; // Definition
#else
  extern volatile SYSCFG_T* mysyscfg; // Declaration
#endif

Now in init.c and only in that file:

#define IN_INIT_C
#include "lib.h"

Or you can simply place the definition in init.c and simplify your header by only placing declarations therein.

You should also read the Q&A's provided by this search:

https://stackoverflow.com/search?q=%5Bc%5Ddifference+between+declaration+and+definition

It's a bad idea to define variables in an include-file. The reason is that you won't be able to include that include-file in more than one c-file. If you do, you'll get the errors that you have now.

So the code you have posted shal be moved to a c-file and in the include-file you just put:

extern volatile SYSCFG_t* mysyscfg;

extern volatile RCC_AHB2ENR_t* myrcc_ahb2enr;

extern volatile RCC_APB2ENR_t* myrcc_apb2enr;

extern volatile GPIO_t* mygpiob;

extern volatile GPIO_t* mygpioe;

extern volatile GPIO_t* mygpioa;

Then the include-file can be included in multiple c-files without problems.

As other people already stated do not define object or functions (except static inline ones) in the header files.

You also try to reinvent the wheel - all the register definitions are already in the STM provide CMSIS files.

Your approach is also inefficient. It will generate unnecessary code when you access your variables.

#include <stdint.h>

#define __IO volatile

typedef struct
{
  __IO uint32_t MODER;    /*!< GPIO port mode register,               Address offset: 0x00      */
  __IO uint32_t OTYPER;   /*!< GPIO port output type register,        Address offset: 0x04      */
  __IO uint32_t OSPEEDR;  /*!< GPIO port output speed register,       Address offset: 0x08      */
  __IO uint32_t PUPDR;    /*!< GPIO port pull-up/pull-down register,  Address offset: 0x0C      */
  __IO uint32_t IDR;      /*!< GPIO port input data register,         Address offset: 0x10      */
  __IO uint32_t ODR;      /*!< GPIO port output data register,        Address offset: 0x14      */
  __IO uint32_t BSRR;     /*!< GPIO port bit set/reset register,      Address offset: 0x18      */
  __IO uint32_t LCKR;     /*!< GPIO port configuration lock register, Address offset: 0x1C      */
  __IO uint32_t AFR[2];   /*!< GPIO alternate function registers,     Address offset: 0x20-0x24 */
} GPIO_TypeDef;

volatile GPIO_TypeDef *MYGPIOA = (volatile GPIO_TypeDef *)0x40000000;

#define GPIOA ((GPIO_TypeDef *)0x40000000)

void foo(uint32_t val)
{
    MYGPIOA -> MODER = val;
}

void bar(uint32_t val)
{
    GPIOA -> MODER = val;
}

as you see the #define way generates less instructions. That is the reason why in the CMSIS headers it is done this way. You also unnecessary waste memory for the pointers.

foo:
        ldr     r3, .L3
        ldr     r3, [r3]
        str     r0, [r3]
        bx      lr
.L3:
        .word   .LANCHOR0
bar:
        mov     r3, #1073741824
        str     r0, [r3]
        bx      lr
MYGPIOA:
        .word   1073741824

https://godbolt.org/z/8K19js