STM32: mein erstes Programm

[elektrozaun (Gast)]

hallo,

aller Anfang ist schwer, besonders, wenn es so viele Möglichkeiten und 
so viel widersprüchliche Tipps im Netz gibt. Deshalb versuche ich, den 
STM32 mit möglichst wenig Werkzeug zu programmieren. Also keine standard 
peripherals library oder IDE, nur arm-none-eabi-Pakete von Debian. Ob 
mit oder ohne newlib wird sich noch zeigen.

Im Moment fehlt mir vor allem ein Linker Script, da geht es total 
durcheinander. Per Default wird nach 0x8000 gelinkt, mit dem 
redboot-Script aus der newlib nach 0x20000, aber am Anfang steht 
"deregister_tm_clones"?! Für einen cortex-M3 würde ich 0x0 oder 
0x08000000 erwarten (was ist besser?).

Die andere Frage: ist mein Machwerk noch halbwegs verständlich, 
besonders "gpio.h" kombiniert mit "peri.ld"?

CC      = arm-none-eabi-gcc
OBJCOPY = arm-none-eabi-objcopy
OBJDUMP = arm-none-eabi-objdump

CFLAGS  = -mthumb -mcpu=cortex-m3 -Wall -Wextra -std=c99 -pedantic
CFLAGS  += -O2
# CFLAGS  += -nostdlib
LDFLAGS = -T /usr/lib/arm-none-eabi/newlib/armv7-m/redboot.ld

ELF     = test
SRC     = main.c sleep.c
OBJ     = $(patsubst %.c, %.o, $(SRC))


all:    $(ELF)

$(ELF): Makefile .depend peri.ld $(OBJ)
        $(CC) -o $(ELF) $(CFLAGS) $(OBJ) $(LDFLAGS) peri.ld

dump:
        $(OBJDUMP) -d -t -C $(ELF)

clean:
        rm -f $(ELF)
        rm -f $(OBJ)
        rm -f .depend

.depend: $(SRC)
        $(CC) -MM $(SRC) > .depend

-include .depend

/* Linker script: memory map STM32F205C */

_start       =     0x8000;

flash        = 0x08000000;
system_rom   = 0x1FFF0000;
otp_flash    = 0x1FFF7800;
option_bytes = 0x1FFFC000;

ram          = 0x20000000;

peri         = 0x40000000;
   tim2      = peri + 0x00000;
   tim3      = peri + 0x00400;
   gpioa     = peri + 0x20000;
   gpiob     = peri + 0x20400;
   gpioc     = peri + 0x20800;
   gpiod     = peri + 0x20C00;
   gpioe     = peri + 0x21000;
   gpiof     = peri + 0x21400;
   gpiog     = peri + 0x21800;
   gpioh     = peri + 0x21C00;
   gpioi     = peri + 0x22000;
   crc       = peri + 0x23000;
   rcc       = peri + 0x23800;

backup_ram   = 0x40024000;

scs          = 0xE000E000;
   systick   = scs + 0x010;
   scb       = scs + 0xD00;

/* STM32F205 GPIO */
#include <stdint.h>

#define __IO volatile

/*!< Peripheral base address in the alias region
#define PERIPH_BASE           ((uint32_t)0x40000000)
#define AHB1PERIPH_BASE       (PERIPH_BASE + 0x00020000)
#define GPIOD_BASE            (AHB1PERIPH_BASE + 0x0C00)
 */

typedef struct
{
  __IO uint32_t moder;   /* mode register          */
  __IO uint32_t otyper;  /* output type            */
  __IO uint32_t ospeedr; /* output speed           */
  __IO uint32_t pupdr;   /* pull-up/pull-down      */
  __IO uint32_t idr;     /* input data             */
  __IO uint32_t odr;     /* output data            */
  __IO uint32_t bsrr;    /* bit set/reset register */
  __IO uint32_t lckr;    /* configuration lock     */
  __IO uint32_t afr[2];  /* alternate functions    */
} GPIO_struct;

#define MODE_INPUT   0
#define MODE_OUTPUT  1
#define MODE_ALT     2
#define MODE_ANALOG  3
#define SPEED_LOW    0
#define SPEED_MEDIUM 1
#define SPEED_FAST   2
#define SPEED_HIGH   3
#define PULL_NONE    0
#define PULL_UP      1
#define PULL_DOWN    2

/* test.h -- Board-spezifisches */
#define LED_GELB_ON  (0x01000000)
#define LED_GELB_OFF (0x00000100)

#define HSI_Hz ((int)16e6)
#define HSE_Hz ((int)10e6)

typedef struct {
  int  pllclk;  /* Hz */
  int  apb1clk;
  int  apb2clk;
  int  fclk;
  int  fclk_MHz;
} board_struct;

void  msleep (int ms);
void  usleep (int us);

#include "test.h"
#include "gpio.h"

extern GPIO_struct  gpioa, gpiob, gpiod;

void
_exit (int rv __attribute__((unused)))
{
  crash:  goto crash;
}


int
main (void)
{
  for (;;) {
    gpiod.bsrr = LED_GELB_ON;
    msleep (200);
    gpiod.bsrr = LED_GELB_OFF;
    msleep (800);
  }
/* return 0; */
}

#include <assert.h>
#include "test.h"
#include "scs.h"

extern systick_struct systick;

board_struct  board = { .fclk_MHz = HSI_Hz / (int)1e6 };


void
msleep (int ms)
{
  for (; ms > 0; ms--)  usleep (1000);
}


void
usleep (int us)
{
int  ticks, t0;

  if (us < 0)  return;
//assert (us <= 1000);

  if (systick.csr & CLKSOURCE) {
    ticks = us * board.fclk_MHz;
  }
  else {
    ticks = (us * board.fclk_MHz) / 8;  /* reset default */
  }

  t0 = systick.cvr - ticks;
  if (t0 < 0) {
    t0 += systick.rvr;
    while (systick.cvr < t0)  __asm__("NOP");
  }
  while (systick.cvr > t0)  __asm__("NOP");
}