README.md

diagram.json

#include "system.h"
#include "gpio.h"
#include "uart.h"

void setup() {
  port_enable(pin_port(PinC13));
  pin_mode(PinC13, Output);
  uart_enable_tx_only(9600);
  uart_print("hello\n");
}

void loop() {
  if (system_ticks() % 500 < 200)
    pin_reset(PinC15);
  else
    pin_set(PinC15);
}


blink.c

#include <stm32f1xx.h>
#include "gpio.h"

typedef GPIO_TypeDef gpio_t;
#define GPIO(x) ((gpio_t *) (0x40010800 + 0x400 * (x)))

typedef enum {
	INPUT,
	OUTPUT_10MHZ,
	OUTPUT_2MHZ,
	OUTPUT_50MHZ,
} gpio_crx_mod_t;

typedef enum {
	INPUT_ANALOG = 0,
	INPUT_FLOAT = 1,
	INPUT_PULL = 2,
	OUTPUT_PUSHPULL = 0,
	OUTPUT_OPENDRAIN = 1,
	ALTERNATE_OUTPUT_PUSHPULL = 2,
	ALTERNATE_OUTPUT_OPENDRAIN = 3,
} gpio_crx_cnf_t;

void port_enable(port_t port) {
	if (port == PortA) RCC->APB2ENR |= RCC_APB2ENR_IOPAEN;
	if (port == PortB) RCC->APB2ENR |= RCC_APB2ENR_IOPBEN;
	if (port == PortC) RCC->APB2ENR |= RCC_APB2ENR_IOPCEN;
	if (port == PortD) RCC->APB2ENR |= RCC_APB2ENR_IOPDEN;
}

void pin_mode(pin_t pin, pin_mode_t mode) {
	gpio_crx_mod_t mod = 0;
	gpio_crx_cnf_t cnf = 0;
	switch (mode) {
		case Input:
			mod = INPUT; cnf = INPUT_FLOAT;
			break;
		case InputPullUp:
			mod = INPUT; cnf = INPUT_PULL;
			break;
		case InputPullDown:
			mod = INPUT; cnf = INPUT_PULL;
			break;
		case InputAnalog:
			mod = INPUT; cnf = INPUT_ANALOG;
			break;
		case Output:
			mod = OUTPUT_10MHZ; cnf = OUTPUT_PUSHPULL;
			break;
		case OutputOpenDrain:
 			mod = OUTPUT_10MHZ; cnf = OUTPUT_OPENDRAIN;
			break;
		case AlternateOutput:
 			mode = OUTPUT_10MHZ; cnf = ALTERNATE_OUTPUT_PUSHPULL;
			break;
		case AlternateOutputOpenDrain:
 			mod = OUTPUT_10MHZ; cnf = ALTERNATE_OUTPUT_OPENDRAIN;
			break;
	}
	uint32_t val, mask;
	gpio_t * gpio = GPIO(pin_port(pin));
	if (pin_number(pin) < 8) {
		val = ((cnf << 2) + mod) << (4 * pin_number(pin));
		mask = 0xf << (4 * pin_number(pin));
		gpio->CRL = (gpio->CRL & ~mask) | val;
	} else {
		val = ((cnf << 2) + mod) << (4 * (pin_number(pin) - 8));
		mask = 0xf << (4 * (pin_number(pin) - 8));
		gpio->CRH = (gpio->CRH & ~mask) | val;
	}
}

void pin_set(pin_t pin) {
	gpio_t * gpio = GPIO(pin_port(pin));
	gpio->BSRR |= pin_mask(pin);
}

void pin_reset(pin_t pin) {
	gpio_t * gpio = GPIO(pin_port(pin));
	gpio->BRR |= pin_mask(pin);
}


gpio.c

#ifndef _gpio_h
#define _gpio_h

typedef enum {
	PortA = 0,
	PortB = 1,
	PortC = 2,
	PortD = 2,
} port_t;

typedef enum {
	PinA0  = 0x0000,
	PinA1  = 0x0001,
	PinA2  = 0x0002,
	PinA3  = 0x0003,
	PinA4  = 0x0004,
	PinA5  = 0x0005,
	PinA6  = 0x0006,
	PinA7  = 0x0007,
	PinA8  = 0x0008,
	PinA9  = 0x0009,
	PinA10 = 0x000A,
	PinA11 = 0x000B,
	PinA12 = 0x000C,
	PinA13 = 0x000D,
	PinA14 = 0x000E,
	PinA15 = 0x000F,
	PinB0  = 0x0100,
	PinB1  = 0x0101,
	PinB2  = 0x0102,
	PinB3  = 0x0103,
	PinB4  = 0x0104,
	PinB5  = 0x0105,
	PinB6  = 0x0106,
	PinB7  = 0x0107,
	PinB8  = 0x0108,
	PinB9  = 0x0109,
	PinB10 = 0x010A,
	PinB11 = 0x010B,
	PinB12 = 0x010C,
	PinB13 = 0x010D,
	PinB14 = 0x010E,
	PinB15 = 0x010F,
	PinC0  = 0x0200,
	PinC1  = 0x0201,
	PinC2  = 0x0202,
	PinC3  = 0x0203,
	PinC4  = 0x0204,
	PinC5  = 0x0205,
	PinC6  = 0x0206,
	PinC7  = 0x0207,
	PinC8  = 0x0208,
	PinC9  = 0x0209,
	PinC10 = 0x020A,
	PinC11 = 0x020B,
	PinC12 = 0x020C,
	PinC13 = 0x020D,
	PinC14 = 0x020E,
	PinC15 = 0x020F,
	PinD0  = 0x0300,
	PinD1  = 0x0301,
	PinD2  = 0x0302,
	PinD3  = 0x0303,
	PinD4  = 0x0304,
	PinD5  = 0x0305,
	PinD6  = 0x0306,
	PinD7  = 0x0307,
	PinD8  = 0x0308,
	PinD9  = 0x0309,
	PinD10 = 0x030A,
	PinD11 = 0x030B,
	PinD12 = 0x030C,
	PinD13 = 0x030D,
	PinD14 = 0x030E,
	PinD15 = 0x030F,
} pin_t;

typedef enum {
	Input,
	InputFloat = Input,
	InputPullUp,
	InputPullDown,
	InputAnalog,
	Output ,
	OutputOpenDrain,
	AlternateOutput,
	AlternateOutputPushPull = AlternateOutput,
	AlternateOutputOpenDrain,
} pin_mode_t;

#define pin_port(pin) ((port_t) (pin >> 8))
#define pin_number(pin) (pin & 0xFF)
#define pin_mask(pin) ((uint16_t)(1 << pin_number(pin)))
#ifdef __cplusplus
extern "C" {
#endif
void port_enable(port_t port);
void port_disable(port_t port);
void pin_mode(pin_t pin, pin_mode_t mode);
void pin_set(pin_t pin);
void pin_reset(pin_t pin);
#ifdef __cplusplus
extern "C" {
#endif
#endif


gpio.h

#include <stm32f1xx.h>
#include "spi.h"

#define SPIGPIO GPIOA
#define SCK 5 // 3
#define MISO 6 // 4
#define MOSI 7 // 5

void spi_enable() {
	RCC->APB2ENR |= RCC_APB2ENR_IOPAEN // port clock
			| RCC_APB2ENR_AFIOEN // alt function clock
			| RCC_APB2ENR_SPI1EN; //	spi clock
	GPIOA->CRL &= 0x000FFFFF;
	GPIOA->CRL |= 0xD4D00000; // pb6 input/float, pb7 & pb5 output/alt-func open-drain
	SPI1->CR1 = SPI_CR1_SSM | SPI_CR1_SSI // software slave select
			| SPI_CR1_MSTR | SPI_CR1_SPE // spi master
			| (5 << SPI_CR1_BR_Pos); // baudrate
	AFIO->MAPR &= ~AFIO_MAPR_SPI1_REMAP;
}

void spi_disable() {
	SPI1->CR1 = 0;
	RCC->APB2ENR &= ~RCC_APB2ENR_SPI1EN;
}

uint8_t spi_transfer8(uint8_t data) {
	SPI1->DR = data;
	while (!(SPI1->SR & SPI_SR_RXNE));
	return SPI1->DR;
}

void spi_transfer(uint8_t * data, uint8_t len) {
	uint8_t *p = data;
	SPI1->DR = *p;
	while (--len > 0) {
		uint8_t out = *(p + 1);
		while (!(SPI1->SR & SPI_SR_RXNE));
		uint8_t in = SPI1->DR;
		while (!(SPI1->SR & SPI_SR_TXE));
		SPI1->DR = out;
		*p++ = in;
	}
}


spi.c

#ifndef _spi_h_
#define _spi_h_
#include <stdint.h>
#include <stdbool.h>

#ifdef __cplusplus
extern "C" {
#endif
void spi_enable();
void spi_disable();
uint8_t spi_transfer8(uint8_t data);
void spi_transfer(uint8_t * data, uint8_t len);
#ifdef __cplusplus
}
#endif
#endif


spi.h

#include <stm32f1xx.h>
#include "system.h"
#include <stdint.h>

/*__attribute__((naked, noreturn)) void Reset_Handler(void) {
	extern void system_init();
	extern long _sbss, _ebss, _sdata, _edata, _sidata;
	// memset .bss to zero
	for (long *dst = &_sbss; dst < &_ebss; dst++)
		*dst = 0;
	// copy .data section to RAM region
	for (long *dst = &_sdata, *src = &_sidata; dst < &_edata;)
		*dst++ = *src++;
	system_init();
	setup();
	while (1)
		loop();
}*/

static volatile uint32_t _system_ticks;

void SysTick_Handler() {
	_system_ticks++;
}

uint32_t system_ticks() {
	__disable_irq();
	uint32_t v = _system_ticks;
	__enable_irq();
	return v;
}

void system_init(void) {
	/*FLASH->ACR &=~FLASH_ACR_LATENCY_0; // latency 2 wait states
	FLASH->ACR |= FLASH_ACR_LATENCY_1;
	RCC->CR |= RCC_CR_HSEON; // enable hse
	while (!(RCC->CR & RCC_CR_HSERDY));
	RCC->CFGR |= RCC_CFGR_PLLSRC // HSE as PLL input
		| RCC_CFGR_PPRE1_DIV2 // APB1 prescale 2 (<36MHz)
		| RCC_CFGR_PLLMULL9; // clk = 8 * 9 = 72Mhz
	RCC->CR |= RCC_CR_PLLON;
	while (!(RCC->CR & RCC_CR_PLLRDY));
	RCC->CFGR |= RCC_CFGR_SW_PLL; // PLL as system clock source*/
	SystemCoreClockUpdate();
	SysTick_Config(SystemCoreClock / 1000);
	///SysTick_Config(8000);
	__enable_irq();
}

int main() {
	system_init();
	setup();
	while (1)
		loop();
}


system.c

#ifndef _system_h
#define _system_h
#include <stdint.h>

#ifdef __cplusplus
extern "C" {
#endif
uint32_t system_ticks();
void setup();
void loop();
#ifdef __cplusplus
}
#endif
#endif


system.h

#include <stm32f1xx.h>
#include "uart.h"
//#include <string.h>

static uint8_t tx_buffer[UART_TX_BUFFER_SIZE + 1];
static uint8_t tx_head;
static uint8_t tx_tail;

static uint8_t rx_buffer[UART_RX_BUFFER_SIZE + 1];
static uint8_t rx_head;
static uint8_t rx_tail;

void _uart_enable(uint32_t baudrate, bool enable_tx, bool enable_rx) {
	RCC->APB1ENR |= RCC_APB1ENR_USART2EN;
	RCC->APB2ENR |= RCC_APB2ENR_IOPAEN; // port A
	// pins a2 and a3 for usart2
	GPIOA->CRL &= (GPIO_CRL_MODE2 | GPIO_CRL_CNF2 | GPIO_CRL_MODE3 | GPIO_CRL_CNF3);
	GPIOA->CRL |= ((0x1 << GPIO_CRL_MODE2_Pos) | (0x2 << GPIO_CRL_CNF2_Pos) |
		(0x0 << GPIO_CRL_MODE3_Pos) | (0x1 << GPIO_CRL_CNF3_Pos));
	// baudrate
	uint16_t uartdiv = 1000;// = SystemCoreClock / baudrate;
	USART2->BRR = (((uartdiv / 16) << USART_BRR_DIV_Mantissa_Pos) |
			((uartdiv % 16) << USART_BRR_DIV_Fraction_Pos));
	USART2->CR1 |= USART_CR1_UE;
	if (enable_tx)
		USART2->CR1 |= USART_CR1_TE;
	if (enable_rx)
		USART2->CR1 |= USART_CR1_RE | USART_CR1_RXNEIE;
	NVIC_EnableIRQ(USART2_IRQn);
}

void uart_enable(uint32_t baudrate) {
	_uart_enable(baudrate, true, true);
}

void uart_enable_tx_only(uint32_t baudrate) {
	_uart_enable(baudrate, true, false);
}

void uart_enable_rx_only(uint32_t baudrate) {
	_uart_enable(baudrate, false, true);
}

void uart_disable() {
	NVIC_DisableIRQ(USART2_IRQn);
	USART2->CR1 &= 0;
	RCC->APB1ENR &= ~RCC_APB1ENR_USART2EN;
	GPIOA->CRL &= GPIO_CRL_MODE2 | GPIO_CRL_CNF2 | GPIO_CRL_MODE3 | GPIO_CRL_CNF3;
}

bool uart_tx_buffer_is_empty() {
	uint8_t next = (tx_head < UART_TX_BUFFER_SIZE ? tx_head + 1 : 0);
	return tx_tail != next;
}

void uart_write(uint8_t * data, uint8_t len) {
	bool empty = (tx_head == tx_tail);
	for (int i = 0; i < len; i++) {
		tx_buffer[tx_head] = data[i];
		tx_head = (tx_head < UART_TX_BUFFER_SIZE ? tx_head + 1 : 0);
	}
	if (empty) {
		//USART2->DR = tx_buffer[tx_tail];
		USART2->CR1 |= USART_CR1_TXEIE;
	}
}

void uart_print(uint8_t * data) {
	//uart_write(data, strlen((char *)data));
}

bool uart_data_is_available() {
	return (rx_head != rx_tail);
}

uint8_t uart_read() {
	if (rx_head == rx_tail)
		return 0;
	uint8_t c = rx_buffer[rx_tail];
	rx_tail = (rx_tail < UART_RX_BUFFER_SIZE ? rx_tail + 1 : 0);
	return c;
}

void USART2_IRQHandler(void) {
	if (USART2->SR & USART_SR_RXNE) {
		uint8_t next = rx_head + 1;
		if (next >= UART_RX_BUFFER_SIZE)
			next = 0;
		uint8_t v = USART2->DR;
		if (next != rx_tail) {
			rx_buffer[rx_head] = v;
			rx_head = next;
		}
	}
	if (USART2->SR & USART_SR_TXE) {
		if (tx_head != tx_tail) {
			USART2->DR = tx_buffer[tx_tail];
			tx_tail = (tx_tail < UART_TX_BUFFER_SIZE ? tx_tail + 1 : 0);
		} else
			USART2->CR1 &= ~USART_CR1_TXEIE;
	}
}


uart.c

#ifndef _uart_h
#define _uart_h
#include <stdint.h>
#include <stdbool.h>
#include "system.h"

#if !defined(UART_TX_BUFFER_SIZE)
#define UART_TX_BUFFER_SIZE 10
#endif
#if !defined(UART_RX_BUFFER_SIZE)
#define UART_RX_BUFFER_SIZE 10
#endif

#ifdef __cplusplus
extern "C" {
#endif
void uart_enable(uint32_t bitrate);
void uart_enable_tx_only(uint32_t bitrate);
void uart_enable_rx_only(uint32_t bitrate);
void uart_disable();

bool uart_tx_buffer_is_empty();
void uart_write(uint8_t * data, uint8_t len);
void uart_print(uint8_t * str);

bool uart_data_is_available();
uint8_t uart_read();
#ifdef __cplusplus
}
#endif
#endif
