TOOLCHAIN_PATH:=/usr/bin

TOOLCHAIN_PREFIX:=arm-none-eabi

OPTLVL:=3 # Optimization level, can be [0, 1, 2, 3, s].

#PROJECT_NAME:=$(notdir $(lastword $(CURDIR)))

TOP:=$(shell readlink -f "../..")

DISCOVERY:=Utilities/STM32L100C-Discovery

STMLIB:=libraries

OLEDDRV:=oleddrv

STD_PERIPH:=$(STMLIB)/STM32L1xx_StdPeriph_Driver

STARTUP:=$(STMLIB)/CMSIS/Device/ST/STM32L1xx/Source/Templates/gcc_ride7

LINKER_SCRIPT:=$(CURDIR)/stm32-flash.ld

#LINKER_SCRIPT:=$(CURDIR)/../stm32_flash.ld

INCLUDE=-I$(CURDIR)

INCLUDE+=-I$(STMLIB)/CMSIS/Include

INCLUDE+=-I$(STMLIB)/CMSIS/Device/ST/STM32L1xx/Include

INCLUDE+=-I$(STD_PERIPH)/inc

INCLUDE+=-I$(DISCOVERY)

INCLUDE+=-I$(STMLIB)/$(OLEDDRV)

#INCLUDE+=-I$(STMLIB)/STM32_USB_OTG_Driver/inc

#INCLUDE+=-I$(STMLIB)/STM32_USB_Device_Library/Class/hid/inc

#INCLUDE+=-I$(STMLIB)/STM32_USB_Device_Library/Core/inc

# vpath is used so object files are written to the current directory instead

# of the same directory as their source files

vpath %.c $(DISCOVERY) $(STD_PERIPH)/src \

          $(STMLIB)/STM32_USB_OTG_Driver/src \

          $(STMLIB)/STM32_USB_Device_Library/Class/hid/src \

          $(STMLIB)/STM32_USB_Device_Library/Core/src

vpath %.s $(STARTUP)

ASRC=startup_stm32l1xx_mdp.s

# Project Source Files

SRC=main.c

SRC+=stm32l1xx_it.c

SRC+=system_stm32l1xx.c

SRC+=stm32l100c_discovery.c

SRC+=ssd1306.c

# Discovery Source Files

#SRC+=stm32f4_discovery_lis302dl.c

#SRC+=stm32f4_discovery.c

#SRC+=stm32f4_discovery_audio_codec.c

# Standard Peripheral Source Files

SRC+=stm32l1xx_syscfg.c

SRC+=misc.c

SRC+=stm32l1xx_adc.c

SRC+=stm32l1xx_dac.c

SRC+=stm32l1xx_dma.c

SRC+=stm32l1xx_exti.c

SRC+=stm32l1xx_flash.c

SRC+=stm32l1xx_gpio.c

SRC+=stm32l1xx_i2c.c

SRC+=stm32l1xx_rcc.c

SRC+=stm32l1xx_spi.c

SRC+=stm32l1xx_tim.c

# USB Source Files

#SRC+=usb_dcd_int.c

#SRC+=usb_core.c

#SRC+=usb_dcd.c

#SRC+=usbd_hid_core.c

#SRC+=usbd_req.c

#SRC+=usbd_core.c

#SRC+=usbd_ioreq.c

CDEFS=-DUSE_STDPERIPH_DRIVER

CDEFS+=-DSTM32L1XX

CDEFS+=-DMANGUSTA_DISCOVERY

#CDEFS+=-DUSE_USB_OTG_FS

CDEFS+=-DHSE_VALUE=8000000

MCUFLAGS=-mcpu=cortex-m3 -mthumb

#MCUFLAGS=-mcpu=cortex-m4 -mthumb -mlittle-endian -mfpu=fpa -mfloat-abi=hard -mthumb-interwork

#MCUFLAGS=-mcpu=cortex-m4 -mfpu=vfpv4-sp-d16 -mfloat-abi=hard

COMMONFLAGS=-O$(OPTLVL) -g -Wall

CFLAGS=$(COMMONFLAGS) $(MCUFLAGS) $(INCLUDE) $(CDEFS)

LDLIBS=

LDFLAGS=$(COMMONFLAGS) -fno-exceptions -ffunction-sections -fdata-sections \

        -nostartfiles -Wl,--gc-sections,-T$(LINKER_SCRIPT)

#####

#####

OBJ = $(SRC:%.c=%.o) $(ASRC:%.s=%.o)

CC=$(TOOLCHAIN_PATH)/$(TOOLCHAIN_PREFIX)-gcc

LD=$(TOOLCHAIN_PATH)/$(TOOLCHAIN_PREFIX)-gcc

OBJCOPY=$(TOOLCHAIN_PATH)/$(TOOLCHAIN_PREFIX)-objcopy

AS=$(TOOLCHAIN_PATH)/$(TOOLCHAIN_PREFIX)-as

AR=$(TOOLCHAIN_PATH)/$(TOOLCHAIN_PREFIX)-ar

GDB=$(TOOLCHAIN_PATH)/$(TOOLCHAIN_PREFIX)-gdb

all: $(OBJ)

	$(CC) -o $(TARGET).elf $(LDFLAGS) $(OBJ)	$(LDLIBS)

	$(OBJCOPY) -O ihex   $(TARGET).elf $(TARGET).hex

	$(OBJCOPY) -O binary $(TARGET).elf $(TARGET).bin

.PHONY: clean

clean:

	rm -f $(OBJ)

	rm -f $(TARGET).elf

	rm -f $(TARGET).hex

	rm -f $(TARGET).bin

#ifndef BSP_H

#define BSP_H

/**

  IO Connection map

       SSD1303

  Vcc   1  2  Gnd

D1/Data 3  4  D0/Clk

    D3  5  6  D2

    D5  7  8  D4

    D7  9 10  D6

    WR 11 12  RD

   RES 13 14  A0  (1-data,0-command)

   CS  15 16  C86 (1-8080, 0-SPI)

       STM32

  D0/Clk    PB13/SPI2 Clk

  D1/Data   PB15/SPI2 MOSI

  RES       PB12

  A0        PB14

  CS        Gnd

  D2~D7     (Float)

  WR        (Float)

  RD        (Float)

 */

#define   SSD_Clk         GPIOA,GPIO_Pin_5

#define   SSD_Data        GPIOA,GPIO_Pin_7

#define   SSD_Reset       GPIOB,GPIO_Pin_2

#define   SSD_A0          GPIOB,GPIO_Pin_10

#define   SSD_CS          GPIOB,GPIO_Pin_1

#define   SSD_Clk_Low()     GPIOA->BRR = GPIO_Pin_5

#define   SSD_Clk_High()    GPIOA->ODR |= GPIO_Pin_5

#define   SSD_Data_Low()    GPIOA->BRR = GPIO_Pin_7

#define   SSD_Data_High()   GPIOA->ODR |= GPIO_Pin_7

#define   SSD_Reset_Low()   GPIOB->BRR = GPIO_Pin_2

#define   SSD_Reset_High()  GPIOB->ODR |= GPIO_Pin_2

#define   SSD_A0_Low()      GPIOB->BRR = GPIO_Pin_10

#define   SSD_A0_High()     GPIOB->ODR |= GPIO_Pin_10

#define   SSD_CS_Low()      GPIOB->BRR = GPIO_Pin_1

#define   SSD_CS_High()     GPIOB->ODR |= GPIO_Pin_1

#define   SPI_Wait()           while(!(SPI1->SR&SPI_I2S_FLAG_TXE));while(SPI1->SR&SPI_I2S_FLAG_BSY);

#define   SSD1303_FPS                   50

#define   IsLedOn()       (!(GPIOA->ODR & GPIO_Pin_8))

#define   LED_ON()        GPIOA->BRR = GPIO_Pin_8

#define   LED_OFF()       GPIOA->BSRR = GPIO_Pin_8

#define   ToggleLED()     if(GPIOA->ODR & GPIO_Pin_8){GPIOA->BRR = GPIO_Pin_8;}\

                          else{GPIOA->BSRR = GPIO_Pin_8;}

#define   GSel1_High()    GPIOB->BSRR = GPIO_Pin_9

#define   GSel1_Low()     GPIOB->BRR = GPIO_Pin_9

#define   MMA_SLEEP()     GPIOB->BRR = GPIO_Pin_11

#define   MMA_WAKEUP()    GPIOB->BSRR = GPIO_Pin_11

#define   Is_MMA_WAKEUP() (GPIOB->ODR & GPIO_Pin_11)

#define   DMA_SSD_1303    DMA1_Channel5

#define   DMA_Handler_SSD_1303    DMA1_Channel5_IRQHandler

#define   Is_Enc_Key_Down()    (!(GPIOA->IDR & GPIO_Pin_0))

#endif

#include "main.h"

#include "stm32l100c_discovery.h"

#include "ssd1306.h"

static __IO uint32_t TimingDelay;

uint8_t BlinkSpeed = 0;

/* Main */

int main(void)

{

   SystemInit();

   RCC_ClocksTypeDef RCC_Clocks;

  /* Configure LED3 and LED4 on STM32L100C-Discovery */

  STM_EVAL_LEDInit(LED3);

  STM_EVAL_LEDInit(LED4);

  /* Initialize User_Button on STM32L100C-Discovery */

  //STM_EVAL_PBInit(BUTTON_USER, BUTTON_MODE_GPIO);

  /* SysTick end of count event each 1ms */

  RCC_GetClocksFreq(&RCC_Clocks);

  SysTick_Config(RCC_Clocks.HCLK_Frequency / 1000);

 /* Initiate Blink Speed variable */ 

  BlinkSpeed = 1;

 /* Init lcd driver */

//  SSD1303_Init();

//  SSD1303_DrawPoint(3,3,1);

//  SSD1303_DrawPoint(5,5,0);

  STM_EVAL_LEDOn(LED4);

  Delay(1000);

  STM_EVAL_LEDOff(LED4);

  Delay(1000);

  while(1)

  {  

      /* Turn on LD4 Blue LED during 1s each time User button is pressed */

      STM_EVAL_LEDOn(LED4);

      //STM_EVAL_LEDOn(LED3);

      /* wait for 1s */

      Delay(300);

      /* Turn off LD4 Blue LED after 1s each time User button is pressed */

      STM_EVAL_LEDOff(LED4);

      Delay(300);

  }

}

/**

  * @brief  Inserts a delay time.

  * @param  nTime: specifies the delay time length, in 1 ms.

  * @retval None

  */

void Delay(__IO uint32_t nTime)

{

  TimingDelay = nTime;

  while(TimingDelay != 0);

}

/**

  * @brief  Decrements the TimingDelay variable.

  * @param  None

  * @retval None

  */

void TimingDelay_Decrement(void)

{

  if (TimingDelay != 0x00)

  { 

    TimingDelay--;

  }

}

#ifdef  USE_FULL_ASSERT

/**

  * @brief  Reports the name of the source file and the source line number

  *   where the assert_param error has occurred.

  * @param  file: pointer to the source file name

  * @param  line: assert_param error line source number

  * @retval None

  */

void assert_failed(uint8_t* file, uint32_t line)

{ 

  /* User can add his own implementation to report the file name and line number,

     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */

  /* Infinite loop */

  while (1)

  {}

}

#endif

/*

*****************************************************************************

**

**  File        : STM32-FLASH.ld

**

**  Abstract    : Linker script for STM32L100xC Device with

**                256KByte FLASH and 16KByte RAM

**

**                Set heap size, stack size and stack location according

**                to application requirements.

**

**                Set memory bank area and size if external memory is used.

**

**  Target      : STMicroelectronics STM32

**

**  Environment : Atollic TrueSTUDIO(R)

**

**  Distribution: The file is distributed "as is," without any warranty

**                of any kind.

**

**  (c)Copyright Atollic AB.

**  You may use this file as-is or modify it according to the needs of your

**  project. Distribution of this file (unmodified or modified) is not

**  permitted. Atollic AB permit registered Atollic TrueSTUDIO(R) users the

**  rights to distribute the assembled, compiled & linked contents of this

**  file as part of an application binary file, provided that it is built

**  using the Atollic TrueSTUDIO(R) toolchain.

**

*****************************************************************************

*/

/* Entry Point */

ENTRY(Reset_Handler)

/* Highest address of the user mode stack */

/* Generate a link error if heap and stack don't fit into RAM */

_Min_Heap_Size = 0x200;      /* required amount of heap  */

_Min_Stack_Size = 0x400; /* required amount of stack */

/* Specify the memory areas */

MEMORY

{

  MEMORY_B1 (rx)  : ORIGIN = 0x60000000, LENGTH = 0K

}

/* Define output sections */

SECTIONS

{

  /* The startup code goes first into FLASH */

  .isr_vector :

  {

    . = ALIGN(4);

    KEEP(*(.isr_vector)) /* Startup code */

    . = ALIGN(4);

  } >FLASH

  /* The program code and other data goes into FLASH */

  .text :

  {

    . = ALIGN(4);

    *(.text)           /* .text sections (code) */

    *(.text*)          /* .text* sections (code) */

    *(.rodata)         /* .rodata sections (constants, strings, etc.) */

    *(.rodata*)        /* .rodata* sections (constants, strings, etc.) */

    *(.glue_7)         /* glue arm to thumb code */

    *(.glue_7t)        /* glue thumb to arm code */

    KEEP (*(.init))

    KEEP (*(.fini))

    . = ALIGN(4);

    _etext = .;        /* define a global symbols at end of code */

  } >FLASH

   .ARM.extab   : { *(.ARM.extab* .gnu.linkonce.armextab.*) } >FLASH

    .ARM : {

    __exidx_start = .;

      *(.ARM.exidx*)

      __exidx_end = .;

    } >FLASH

/*  .ARM.attributes : { *(.ARM.attributes) } > FLASH */

  .preinit_array     :

  {

    PROVIDE_HIDDEN (__preinit_array_start = .);

    KEEP (*(.preinit_array*))

    PROVIDE_HIDDEN (__preinit_array_end = .);

  } >FLASH

  .init_array :

  {

    PROVIDE_HIDDEN (__init_array_start = .);

    KEEP (*(SORT(.init_array.*)))

    KEEP (*(.init_array*))

    PROVIDE_HIDDEN (__init_array_end = .);

  } >FLASH

  .fini_array :

  {

    PROVIDE_HIDDEN (__fini_array_start = .);

    KEEP (*(.fini_array*))

    KEEP (*(SORT(.fini_array.*)))

    PROVIDE_HIDDEN (__fini_array_end = .);

  } >FLASH

  /* used by the startup to initialize data */

  _sidata = .;

  /* Initialized data sections goes into RAM, load LMA copy after code */

  .data : AT ( _sidata )

  {

    . = ALIGN(4);

    _sdata = .;        /* create a global symbol at data start */

    *(.data)           /* .data sections */

    *(.data*)          /* .data* sections */

    . = ALIGN(4);

    _edata = .;        /* define a global symbol at data end */

  } >RAM

  /* Uninitialized data section */

  . = ALIGN(4);

  .bss :

  {

    /* This is used by the startup in order to initialize the .bss secion */

    _sbss = .;         /* define a global symbol at bss start */

    __bss_start__ = _sbss;

    *(.bss)

    *(.bss*)

    *(COMMON)

    . = ALIGN(4);

    _ebss = .;         /* define a global symbol at bss end */

    __bss_end__ = _ebss;

  } >RAM

  PROVIDE ( end = _ebss );

  PROVIDE ( _end = _ebss );