Changeset - 988bab1cb593
Parent rev.
Child rev.
[Not reviewed]
cortex-f0
2 16 0
Ethan Zonca - 10 years ago 2015-01-03 16:31:08
ez@ethanzonca.com
Got things mostly compiling, disabled SPI and USB for now because of RAM overflow
18 files changed with 185 insertions and 667 deletions:
Makefile
36
37
clock.c
2
config.h
9
9
gpio.c
19
17
gpio.h
1
libraries/CMSIS/Device/ST/STM32F0xx/Include/stm32f0xx.h
1
1
libraries/CMSIS/Device/ST/STM32F0xx/Source/Templates/system_stm32f0xx.c
1
libraries/STM32_USB_Device_Library/Class/CDC/usbd_cdc.c
1
1
main.c
56
51
main.h
3
2
spi.c
17
17
spi.h
3
1
ssd1306.c
4
4
ssd1306.h
20
11
stm32f0xx_hal_conf.h
1
1
stm32f0xx_hal_msp.c
11
25
system_stm32f0xx.c
385
system_stm32f0xx.h
105
0 comments (0 inline, 0 general)
Makefile
➞
Show inline comments
 
TARGET:=therm
 
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 "../..")

			




	
	
	
		
 
LIBDIR:=libraries

			




	
	
	
		
 

			




	
	
	
		
 
HAL_LIB:=$(LIBDIR)/STM32F0xx_HAL_Driver

			




	
	
	
		
 
USB_LIB:=$(LIBDIR)/STM32_USB_Device_Library

			




	
	
	
		
 

			




	
	
	
		
 
STARTUP:=$(STMLIB)/CMSIS/Device/ST/STM32F0xx/Source/Templates/gcc

			




	
	
	
		
 
STARTUP:=$(LIBDIR)/CMSIS/Device/ST/STM32F0xx/Source/Templates/gcc

			




	
	
	
		
 

			




	
	
	
		
 
SYSTEMDIR:=$(LIBDIR)/CMSIS/Device/ST/STM32F0xx/Source/Templates # Houses system_STM32f0xx.c

			




	
	
	
		
 

			




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

			




	
	
	
		
 

			




	
	
	
		
 
# Local libs

			




	
	
	
		
 
INCLUDE=-I$(CURDIR)

			




	
	
	
		
 

			




	
	
	
		
 
# CMSIS

			




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

			




	
	
	
		
 
INCLUDE+=-I$(LIBDIR)/CMSIS/Device/ST/STM32F0xx/Include

			




	
	
	
		
 

			




	
	
	
		
 
# USB

			




	
	
	
		
 
INCLUDE+=-I$(USB_LIB)/Class/CDC

			




	
	
	
		
 
INCLUDE+=-I$(USB_LIB)/Core

			




	
	
	
		
 

			




	
	
	
		
 
# HAL

			




	
	
	
		
 
INCLUDE+=-I$(HAL_LIB)/Inc

			




	
	
	
		
 

			




	
	
	
		
 

			




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

			




	
	
	
		
 
# of the same directory as their source files

			




	
	
	
		
 
vpath %.c $(HAL_LIB)/src \

			




	
	
	
		
 
          $(LIBDIR)/$(USB_LIB) \

			




	
	
	
		
 
          $(LIBDIR)/$(USB_LIB)/Class/CDC \

			




	
	
	
		
 
          $(LIBDIR)/$(USB_LIB)/Core

			




	
	
	
		
 
vpath %.c $(HAL_LIB)/Src \

			




	
	
	
		
 
          $(USB_LIB) \

			




	
	
	
		
 
          $(USB_LIB)/Class/CDC \

			




	
	
	
		
 
          $(USB_LIB)/Core \

			




	
	
	
		
 
	  $(SYSTEMDIR)

			




	
	
	
		
 

			




	
	
	
		
 
vpath %.s $(STARTUP)

			




	
	
	
		
 

			




	
	
	
		
 
ASRC=startup_stm32f042x6.s

			




	
	
	
		
 
ASRC=$(STARTUP)/startup_stm32f042x6.s

			




	
	
	
		
 

			




	
	
	
		
 
# Project Source Files

			




	
	
	
		
 
SRC=main.c

			




	
	
	
		
 
SRC+=stm32f0xx_it.c

			




	
	
	
		
 
SRC+=stm32f0xx_hal_msp.c

			




	
	
	
		
 
SRC+=system_stm32f0xx.c

			




	
	
	
		
 
SRC+=ssd1306.c

			




	
	
	
		
 
SRC+=eeprom_min.c

			




	
	
	
		
 
SRC+=gpio.c

			




	
	
	
		
 
SRC+=spi.c

			




	
	
	
		
 
SRC+=clock.c

			




	
	
	
		
 
SRC+=stringhelpers.c

			




	
	
	
		
 

			




	
	
	
		
 
# Discovery Source Files

			




	
	
	
		
 
#SRC+=stm32f4_discovery_lis302dl.c

			




	
	
	
		
 
#SRC+=stm32f4_discovery.c

			




	
	
	
		
 
#SRC+=stm32f4_discovery_audio_codec.c

			




	
	
	
		
 
SRC+=stm32f0xx_it.c

			




	
	
	
		
 
SRC+=stm32f0xx_hal_msp.c

			




	
	
	
		
 

			




	
	
	
		
 
SRC+=usb_device.c

			




	
	
	
		
 
SRC+=usbd_cdc_if.c

			




	
	
	
		
 
SRC+=usbd_conf.c

			




	
	
	
		
 
SRC+=usbd_desc.c

			




	
	
	
		
 

			




	
	
	
		
 
# Standard Peripheral Source Files

			




	
	
	
		
 
SRC+=stm32f0xx_syscfg.c

			




	
	
	
		
 
SRC+=misc.c

			




	
	
	
		
 
SRC+=stm32f0xx_adc.c

			




	
	
	
		
 
SRC+=stm32f0xx_dac.c

			




	
	
	
		
 
SRC+=stm32f0xx_dma.c

			




	
	
	
		
 
SRC+=stm32f0xx_exti.c

			




	
	
	
		
 
SRC+=stm32f0xx_flash.c

			




	
	
	
		
 
SRC+=stm32f0xx_gpio.c

			




	
	
	
		
 
SRC+=stm32f0xx_i2c.c

			




	
	
	
		
 
SRC+=stm32f0xx_rcc.c

			




	
	
	
		
 
SRC+=stm32f0xx_spi.c

			




	
	
	
		
 
SRC+=stm32f0xx_tim.c

			




	
	
	
		
 
SRC+=system_stm32f0xx.c

			




	
	
	
		
 

			




	
	
	
		
 
SRC+=stm32f0xx_hal.c

			




	
	
	
		
 
SRC+=stm32f0xx_hal_spi.c

			




	
	
	
		
 
SRC+=stm32f0xx_hal_pcd.c

			




	
	
	
		
 
SRC+=stm32f0xx_hal_pcd_ex.c

			




	
	
	
		
 
SRC+=stm32f0xx_hal_cortex.c

			




	
	
	
		
 
SRC+=stm32f0xx_hal_dma.c

			




	
	
	
		
 
SRC+=stm32f0xx_hal_flash.c

			




	
	
	
		
 
SRC+=stm32f0xx_hal_flash_ex.c

			




	
	
	
		
 
SRC+=stm32f0xx_hal_gpio.c

			




	
	
	
		
 
SRC+=stm32f0xx_hal_pwr.c

			




	
	
	
		
 
SRC+=stm32f0xx_hal_pwr_ex.c

			




	
	
	
		
 
SRC+=stm32f0xx_hal_rcc.c

			




	
	
	
		
 
SRC+=stm32f0xx_hal_rcc_ex.c

			




	
	
	
		
 

			




	
	
	
		
 
# USB Source Files

			




	
	
	
		
 
SRC+=usb_core.c

			




	
	
	
		
 
SRC+=usb_init.c

			




	
	
	
		
 
SRC+=usb_int.c

			




	
	
	
		
 
SRC+=usb_mem.c

			




	
	
	
		
 
SRC+=usb_regs.c

			




	
	
	
		
 
SRC+=usb_sil.c

			




	
	
	
		
 
SRC+=hw_config.c

			




	
	
	
		
 
SRC+=usb_desc.c

			




	
	
	
		
 
SRC+=usb_endp.c

			




	
	
	
		
 
SRC+=usb_istr.c

			




	
	
	
		
 
SRC+=usb_prop.c

			




	
	
	
		
 
SRC+=usb_pwr.c

			




	
	
	
		
 
SRC+=usbd_cdc.c

			




	
	
	
		
 
SRC+=usbd_core.c

			




	
	
	
		
 
SRC+=usbd_ctlreq.c

			




	
	
	
		
 
SRC+=usbd_ioreq.c

			




	
	
	
		
 

			




	
	
	
		
 
CDEFS=-DUSE_STDPERIPH_DRIVER

			




	
	
	
		
 
CDEFS+=-DSTM32F0XX

			




	
	
	
		
 
CDEFS+=-DMANGUSTA_DISCOVERY

			




	
	
	
		
 
#CDEFS+=-DUSE_USB_OTG_FS

			




	
	
	
		
 

			




	
	
	
		
 
# EMZ FIXME

			




	
	
	
		
 
CDEFS+=-DHSE_VALUE=8000000

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
#EMZ Optimized: 

			




	
	
	
		
 
MCUFLAGS=-mcpu=cortex-m3 -mthumb -ffunction-sections -fdata-sections -mfloat-abi=soft

			




        

    


    
    

    

        

                

                    clock.c
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 

			




	
	
	
		
 
#include "stm32f0xx_hal_conf.h"

			




	
	
	
		
 

			




	
	
	
		
 
void SystemClock_Config(void)

			




	
	
	
		
 
{

			




	
	
	
		
 

			




	
	
	
		
 
  RCC_OscInitTypeDef RCC_OscInitStruct;

			




	
	
	
		
 
  RCC_ClkInitTypeDef RCC_ClkInitStruct;

			




	
	
	
		
 
  RCC_PeriphCLKInitTypeDef PeriphClkInit;

			




	
	
	
		
 

			




	
	
	
		
 
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI48;

			




	
	
	
		
 
  RCC_OscInitStruct.HSI48State = RCC_HSI48_ON;

			




	
	
	
		
 
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;

			




	
	
	
		
 
  HAL_RCC_OscConfig(&RCC_OscInitStruct);

			




        

    


    
    

    

        

                

                    config.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
#ifndef CONFIG_H

			




	
	
	
		
 
#define CONFIG_H

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
#define SSR_PERIOD 200

			




	
	
	
		
 

			




	
	
	
		
 
#define LED_POWER GPIOB,GPIO_Pin_9

			




	
	
	
		
 
#define LED_STAT  GPIOA,GPIO_Pin_15

			




	
	
	
		
 
#define LED_POWER GPIOB,GPIO_PIN_9

			




	
	
	
		
 
#define LED_STAT  GPIOA,GPIO_PIN_15

			




	
	
	
		
 

			




	
	
	
		
 
#define MAX_CS GPIOB,GPIO_Pin_12

			




	
	
	
		
 
#define MAX_CS GPIOB,GPIO_PIN_12

			




	
	
	
		
 

			




	
	
	
		
 
#define SW_BTN  GPIOB, GPIO_Pin_3

			




	
	
	
		
 
#define SW_UP   GPIOB, GPIO_Pin_6

			




	
	
	
		
 
#define SW_DOWN GPIOB, GPIO_Pin_4

			




	
	
	
		
 
#define SW_LEFT GPIOB, GPIO_Pin_7

			




	
	
	
		
 
#define SW_RIGHT GPIOB, GPIO_Pin_5

			




	
	
	
		
 
#define SW_BTN  GPIOB, GPIO_PIN_3

			




	
	
	
		
 
#define SW_UP   GPIOB, GPIO_PIN_6

			




	
	
	
		
 
#define SW_DOWN GPIOB, GPIO_PIN_4

			




	
	
	
		
 
#define SW_LEFT GPIOB, GPIO_PIN_7

			




	
	
	
		
 
#define SW_RIGHT GPIOB, GPIO_PIN_5

			




	
	
	
		
 

			




	
	
	
		
 
#define SSR_PIN GPIOC, GPIO_Pin_13

			




	
	
	
		
 
#define SSR_PIN GPIOC, GPIO_PIN_13

			




	
	
	
		
 

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
// vim:softtabstop=4 shiftwidth=4 expandtab 

			




        

    


    
    

    

        

                

                    gpio.c
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
#include "gpio.h"

			




	
	
	
		
 
#include "config.h"

			




	
	
	
		
 
#include "stm32f0xx_hal_conf.h"

			




	
	
	
		
 
#include <inttypes.h>

			




	
	
	
		
 

			




	
	
	
		
 
extern volatile uint32_t ticks;

			




	
	
	
		
 

			




	
	
	
		
 
// Increase on each press, and increase at a fast rate after duration elapsed of continuously holding down... somehow...

			




	
	
	
		
 
uint32_t change_time_reset = 0;

			




	
	
	
		
 

			




	
	
	
		
 
void user_input(uint16_t* to_modify)

			




	
	
	
		
 
{

			




	
	
	
		
 
    if(CHANGE_ELAPSED) {

			




	
	
	
		
 
        if(!GPIO_ReadInputDataBit(SW_UP) ) {

			




	
	
	
		
 
        if(!HAL_GPIO_ReadPin(SW_UP) ) {

			




	
	
	
		
 
            CHANGE_RESET;

			




	
	
	
		
 
            (*to_modify)++;

			




	
	
	
		
 
        }

			




	
	
	
		
 
        else if(!GPIO_ReadInputDataBit(SW_DOWN) && (*to_modify) > 0) {

			




	
	
	
		
 
        else if(!HAL_GPIO_ReadPin(SW_DOWN) && (*to_modify) > 0) {

			




	
	
	
		
 
            CHANGE_RESET;

			




	
	
	
		
 
            (*to_modify)--;

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
void init_gpio(void) {

			




	
	
	
		
 

			




	
	
	
		
 
  GPIO_InitTypeDef GPIO_InitStruct;

			




	
	
	
		
 

			




	
	
	
		
 
    /* GPIO Ports Clock Enable */

			




	
	
		
 
@@ -79,51 +81,51 @@ void init_gpio(void) {

			




	
	
	
		
 
  

			




	
	
	
		
 
  // USART1 [PORTA]

			




	
	
	
		
 
  // Configure GPIO pins : PA9 PA10

			




	
	
	
		
 
  GPIO_InitStruct.Pin = GPIO_PIN_9|GPIO_PIN_10;

			




	
	
	
		
 
  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;

			




	
	
	
		
 
  GPIO_InitStruct.Pull = GPIO_NOPULL;

			




	
	
	
		
 
  GPIO_InitStruct.Speed = GPIO_SPEED_LOW;

			




	
	
	
		
 
  GPIO_InitStruct.Alternate = GPIO_AF1_USART1;

			




	
	
	
		
 
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

			




	
	
	
		
 

			




	
	
	
		
 
  // SPI1 [PORTA]

			




	
	
	
		
 
  // Configure GPIO pin : PA, MOSI, SCK 

			




	
	
	
		
 
  GPIO_InitStruct.GPIO_Pin = GPIO_PIN_7|GPIO_PIN_5;

			




	
	
	
		
 
  GPIO_InitStruct.GPIO_Mode = GPIO_MODE_AF_PP;

			




	
	
	
		
 
  GPIO_InitStruct.GPIO_PuPd = GPIO_NOPULL;

			




	
	
	
		
 
  GPIO_InitStruct.GPIO_Speed = GPIO_SPEED_HIGH;

			




	
	
	
		
 
  GPIO_InitStruct.Alternate = GPIO_AF1_SPI1;

			




	
	
	
		
 
  GPIO_InitStruct.Pin = GPIO_PIN_7|GPIO_PIN_5;

			




	
	
	
		
 
  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;

			




	
	
	
		
 
  GPIO_InitStruct.Pull = GPIO_NOPULL;

			




	
	
	
		
 
  GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;

			




	
	
	
		
 
  GPIO_InitStruct.Alternate = GPIO_AF0_SPI1;

			




	
	
	
		
 
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

			




	
	
	
		
 
  

			




	
	
	
		
 
  // Configure GPIO pin: PA, MISO

			




	
	
	
		
 
  GPIO_InitStruct.GPIO_Pin = GPIO_PIN_6;

			




	
	
	
		
 
  GPIO_InitStruct.GPIO_Mode = GPIO_MODE_AF_PP;

			




	
	
	
		
 
  GPIO_InitStruct.GPIO_PuPd = GPIO_NOPULL;

			




	
	
	
		
 
  GPIO_InitStruct.GPIO_Speed = GPIO_SPEED_HIGH;

			




	
	
	
		
 
  GPIO_InitStruct.Alternate = GPIO_AF1_SPI1;

			




	
	
	
		
 
  GPIO_InitStruct.Pin = GPIO_PIN_6;

			




	
	
	
		
 
  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;

			




	
	
	
		
 
  GPIO_InitStruct.Pull = GPIO_NOPULL;

			




	
	
	
		
 
  GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;

			




	
	
	
		
 
  GPIO_InitStruct.Alternate = GPIO_AF0_SPI1;

			




	
	
	
		
 
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

			




	
	
	
		
 

			




	
	
	
		
 
  // USB [PORTA]

			




	
	
	
		
 

			




	
	
	
		
 
  /** USB GPIO Configuration  

			




	
	
	
		
 
  PA11   ------> USB_DM

			




	
	
	
		
 
  PA12   ------> USB_DP

			




	
	
	
		
 
  */  

			




	
	
	
		
 
  // Configure GPIO pin : PA, D+, D-

			




	
	
	
		
 
  GPIO_InitStruct.GPIO_Pin = GPIO_Pin_11|GPIO_Pin_12;

			




	
	
	
		
 
  GPIO_InitStruct.GPIO_Mode = GPIO_MODE_AF_PP;

			




	
	
	
		
 
  GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_NOPULL;

			




	
	
	
		
 
  GPIO_InitStruct.GPIO_Speed = GPIO_Speed_10MHz;

			




	
	
	
		
 
  GPIO_InitStruct.Alternate = GPIO_AF1_USB;

			




	
	
	
		
 
  GPIO_InitStruct.Pin = GPIO_PIN_11|GPIO_PIN_12;

			




	
	
	
		
 
  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;

			




	
	
	
		
 
  GPIO_InitStruct.Pull = GPIO_NOPULL;

			




	
	
	
		
 
  GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;

			




	
	
	
		
 
  GPIO_InitStruct.Alternate = GPIO_AF2_USB; // Can also be AF5

			




	
	
	
		
 
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

			




	
	
	
		
 

			




	
	
	
		
 
  

			




	
	
	
		
 
  //////////////////

			




	
	
	
		
 
  // PORT B       //

			




	
	
	
		
 
  //////////////////

			




	
	
	
		
 
  

			




	
	
	
		
 
  // PORT B UNUSED

			




	
	
	
		
 
  // Configure GPIO pins : PB0 PB1 PB8 

			




	
	
	
		
 
  GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_8;

			




	
	
	
		
 
  GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;

			




	
	
	
		
 
  GPIO_InitStruct.Pull = GPIO_NOPULL;

			




        

    


    
    

    

        

                

                    gpio.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
#ifndef GPIO_H

			




	
	
	
		
 
#define GPIO_H

			




	
	
	
		
 

			




	
	
	
		
 
#include <inttypes.h>

			




	
	
	
		
 

			




	
	
	
		
 
#define CHANGE_PERIOD_MS 100

			




	
	
	
		
 
#define CHANGE_ELAPSED (ticks - change_time_reset) > CHANGE_PERIOD_MS

			




	
	
	
		
 
#define CHANGE_RESET change_time_reset = ticks

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
void user_input(uint16_t* to_modify);

			




	
	
	
		
 
void init_gpio(void);

			




	
	
	
		
 

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
// vim:softtabstop=4 shiftwidth=4 expandtab 

			




        

    


    
    

    

        

                

                    libraries/CMSIS/Device/ST/STM32F0xx/Include/stm32f0xx.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -69,25 +69,25 @@

			




	
	
	
		
 
  */

			




	
	
	
		
 

			




	
	
	
		
 
#if !defined (STM32F030x6) && !defined (STM32F030x8) &&                           \

			




	
	
	
		
 
    !defined (STM32F031x6) && !defined (STM32F038xx) &&                           \

			




	
	
	
		
 
    !defined (STM32F042x6) && !defined (STM32F048xx) &&                           \

			




	
	
	
		
 
    !defined (STM32F051x8) && !defined (STM32F058xx) &&                           \

			




	
	
	
		
 
    !defined (STM32F071xB) && !defined (STM32F072xB) && !defined (STM32F078xx) && \

			




	
	
	
		
 
    !defined (STM32F091xC) && !defined (STM32F098xx)

			




	
	
	
		
 
  /* #define STM32F030x6 */  /*!< STM32F030x4, STM32F030x6 Devices (STM32F030xx microcontrollers where the Flash memory ranges between 16 and 32 Kbytes)              */

			




	
	
	
		
 
  /* #define STM32F030x8 */  /*!< STM32F030x8 Devices (STM32F030xx microcontrollers where the Flash memory is 64 Kbytes)                                              */

			




	
	
	
		
 
  /* #define STM32F031x6 */  /*!< STM32F031x4, STM32F031x6 Devices (STM32F031xx microcontrollers where the Flash memory ranges between 16 and 32 Kbytes)              */

			




	
	
	
		
 
  /* #define STM32F038xx */  /*!< STM32F038xx Devices (STM32F038xx microcontrollers where the Flash memory is 32 Kbytes)                                              */

			




	
	
	
		
 
  /* #define STM32F042x6 */  /*!< STM32F042x4, STM32F042x6 Devices (STM32F042xx microcontrollers where the Flash memory ranges between 16 and 32 Kbytes)              */

			




	
	
	
		
 
  #define STM32F042x6 /*!< STM32F042x4, STM32F042x6 Devices (STM32F042xx microcontrollers where the Flash memory ranges between 16 and 32 Kbytes)              */

			




	
	
	
		
 
  /* #define STM32F048x6 */  /*!< STM32F048xx Devices (STM32F042xx microcontrollers where the Flash memory is 32 Kbytes)                                              */

			




	
	
	
		
 
  /* #define STM32F051x8 */  /*!< STM32F051x4, STM32F051x6, STM32F051x8 Devices (STM32F051xx microcontrollers where the Flash memory ranges between 16 and 64 Kbytes) */

			




	
	
	
		
 
  /* #define STM32F058xx */  /*!< STM32F058xx Devices (STM32F058xx microcontrollers where the Flash memory is 64 Kbytes)                                              */

			




	
	
	
		
 
  /* #define STM32F071xB */  /*!< STM32F071x8, STM32F071xB Devices (STM32F071xx microcontrollers where the Flash memory ranges between 64 and 128 Kbytes)             */

			




	
	
	
		
 
  /* #define STM32F072xB */  /*!< STM32F072x8, STM32F072xB Devices (STM32F072xx microcontrollers where the Flash memory ranges between 64 and 128 Kbytes)             */

			




	
	
	
		
 
  /* #define STM32F078xx */  /*!< STM32F078xx Devices (STM32F078xx microcontrollers where the Flash memory is 128 Kbytes)                                             */

			




	
	
	
		
 
  /* #define STM32F091xC */  /*!< STM32F091xC Devices (STM32F091xx microcontrollers where the Flash memory is 256 Kbytes)                                             */

			




	
	
	
		
 
  /* #define STM32F098xx */  /*!< STM32F098xx Devices (STM32F098xx microcontrollers where the Flash memory is 256 Kbytes)                                             */

			




	
	
	
		
 
#endif

			




	
	
	
		
 
   

			




	
	
	
		
 
/*  Tip: To avoid modifying this file each time you need to switch between these

			




	
	
	
		
 
        devices, you can define the device in your toolchain compiler preprocessor.

			




        

    


    
    

    

        

                

                    libraries/CMSIS/Device/ST/STM32F0xx/Source/Templates/system_stm32f0xx.c
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -73,24 +73,25 @@

			




	
	
	
		
 
  * @{

			




	
	
	
		
 
  */

			




	
	
	
		
 

			




	
	
	
		
 
/** @addtogroup stm32f0xx_system

			




	
	
	
		
 
  * @{

			




	
	
	
		
 
  */

			




	
	
	
		
 

			




	
	
	
		
 
/** @addtogroup STM32F0xx_System_Private_Includes

			




	
	
	
		
 
  * @{

			




	
	
	
		
 
  */

			




	
	
	
		
 

			




	
	
	
		
 
#include "stm32f0xx.h"

			




	
	
	
		
 
#include "stm32f0xx_hal_conf.h" // EMZ

			




	
	
	
		
 

			




	
	
	
		
 
/**

			




	
	
	
		
 
  * @}

			




	
	
	
		
 
  */

			




	
	
	
		
 

			




	
	
	
		
 
/** @addtogroup STM32F0xx_System_Private_TypesDefinitions

			




	
	
	
		
 
  * @{

			




	
	
	
		
 
  */

			




	
	
	
		
 

			




	
	
	
		
 
/**

			




	
	
	
		
 
  * @}

			




	
	
	
		
 
  */

			




        

    


    
    

    

        

                

                    libraries/STM32_USB_Device_Library/Class/CDC/usbd_cdc.c
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -50,25 +50,25 @@

			




	
	
	
		
 
  *        http://www.st.com/software_license_agreement_liberty_v2

			




	
	
	
		
 
  *

			




	
	
	
		
 
  * Unless required by applicable law or agreed to in writing, software 

			




	
	
	
		
 
  * distributed under the License is distributed on an "AS IS" BASIS, 

			




	
	
	
		
 
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

			




	
	
	
		
 
  * See the License for the specific language governing permissions and

			




	
	
	
		
 
  * limitations under the License.

			




	
	
	
		
 
  *

			




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

			




	
	
	
		
 
  */ 

			




	
	
	
		
 

			




	
	
	
		
 
/* Includes ------------------------------------------------------------------*/

			




	
	
	
		
 
#include "USBD_CDC.h"

			




	
	
	
		
 
#include "usbd_cdc.h"

			




	
	
	
		
 
#include "usbd_desc.h"

			




	
	
	
		
 
#include "usbd_ctlreq.h"

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
/** @addtogroup STM32_USB_DEVICE_LIBRARY

			




	
	
	
		
 
  * @{

			




	
	
	
		
 
  */

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
/** @defgroup USBD_CDC 

			




	
	
	
		
 
  * @brief usbd core module

			




	
	
	
		
 
  * @{

			




        

    


    
    

    

        

                

                    main.c
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
#include "main.h"

			




	
	
	
		
 
#include <inttypes.h>

			




	
	
	
		
 
#include "stm32f0xx_hal_conf.h"

			




	
	
	
		
 
#include "usb_device.h"

			




	
	
	
		
 
//#include "usb_device.h"

			




	
	
	
		
 
#include "ssd1306.h"

			




	
	
	
		
 
#include "config.h"

			




	
	
	
		
 
#include "eeprom_min.h"

			




	
	
	
		
 
#include "gpio.h"

			




	
	
	
		
 
#include "clock.h"

			




	
	
	
		
 
#include "spi.h"

			




	
	
	
		
 

			




	
	
	
		
 
// USB includes

			




	
	
	
		
 
//#include "hw_config.h"

			




	
	
	
		
 
//#include "usb_lib.h"

			




	
	
	
		
 
//#include "usb_desc.h"

			




	
	
	
		
 
//#include "usb_pwr.h"

			




	
	
	
		
 
//#include "stringhelpers.h"

			




	
	
	
		
 
//#include "spi.h"

			




	
	
	
		
 

			




	
	
	
		
 
// TODO: Grab buttonpresses with interrupts

			




	
	
	
		
 

			




	
	
	
		
 
// USB Supporting Vars

			




	
	
	
		
 
extern __IO uint8_t Receive_Buffer[64];

			




	
	
	
		
 
extern __IO  uint32_t Receive_length ;

			




	
	
	
		
 
extern __IO  uint32_t length ;

			




	
	
	
		
 
uint8_t Send_Buffer[64];

			




	
	
	
		
 
uint32_t packet_sent=1;

			




	
	
	
		
 
uint32_t packet_receive=1;

			




	
	
	
		
 
//extern __IO uint8_t Receive_Buffer[64];

			




	
	
	
		
 
//extern __IO  uint32_t Receive_length ;

			




	
	
	
		
 
//extern __IO  uint32_t length ;

			




	
	
	
		
 
//uint8_t Send_Buffer[64];

			




	
	
	
		
 
//uint32_t packet_sent=1;

			




	
	
	
		
 
//uint32_t packet_receive=1;

			




	
	
	
		
 

			




	
	
	
		
 
enum tempunits {

			




	
	
	
		
 
    TEMP_UNITS_CELSIUS = 0,

			




	
	
	
		
 
    TEMP_UNITS_FAHRENHEIT,

			




	
	
	
		
 
};

			




	
	
	
		
 

			




	
	
	
		
 
// Globalish setting vars

			




	
	
	
		
 
uint8_t boottobrew = 0;

			




	
	
	
		
 
uint8_t temp_units = TEMP_UNITS_CELSIUS;

			




	
	
	
		
 
uint16_t windup_guard = 1;

			




	
	
	
		
 
uint16_t k_p = 1;

			




	
	
	
		
 
uint16_t k_i = 1;

			




	
	
	
		
 
uint16_t k_d = 1;

			




	
	
	
		
 

			




	
	
	
		
 
uint8_t ignore_tc_error  = 0;

			




	
	
	
		
 

			




	
	
	
		
 
// ISR ticks var

			




	
	
	
		
 
volatile uint32_t ticks = 0;

			




	
	
	
		
 

			




	
	
	
		
 
int16_t setpoint_brew = 0;

			




	
	
	
		
 
int16_t setpoint_steam = 0;

			




	
	
	
		
 

			




	
	
	
		
 
// HAL Variables

			




	
	
	
		
 
SPI_HandleTypeDef hspi1;

			




	
	
	
		
 
//extern SPI_HandleTypeDef spi1;

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
// State definition

			




	
	
	
		
 
enum state {

			




	
	
	
		
 
    STATE_IDLE = 0,

			




	
	
	
		
 

			




	
	
	
		
 
    STATE_SETP,

			




	
	
	
		
 
    STATE_SETI,

			




	
	
	
		
 
    STATE_SETD,

			




	
	
	
		
 
    STATE_SETSTEPS,

			




	
	
	
		
 
    STATE_SETWINDUP,

			




	
	
	
		
 
    STATE_SETBOOTTOBREW,

			




	
	
		
 
@@ -83,38 +77,38 @@ void save_settings();

			




	
	
	
		
 
void save_setpoints();

			




	
	
	
		
 

			




	
	
	
		
 
int main(void)

			




	
	
	
		
 
{

			




	
	
	
		
 
    // Init clocks

			




	
	
	
		
 
    HAL_Init();

			




	
	
	
		
 
    SystemClock_Config();

			




	
	
	
		
 
    

			




	
	
	
		
 
    // Init GPIO

			




	
	
	
		
 
    init_gpio();

			




	
	
	
		
 

			




	
	
	
		
 
    // Turn on power LED

			




	
	
	
		
 
    GPIO_SetBits(LED_POWER);

			




	
	
	
		
 
    HAL_GPIO_WritePin(LED_POWER, 1);

			




	
	
	
		
 

			




	
	
	
		
 
    // TODO: Awesome pwm of power LED (TIM4_CH4 or TIM11_CH1)

			




	
	
	
		
 

			




	
	
	
		
 
    // Configure 1ms SysTick (change if more temporal resolution needed) 

			




	
	
	
		
 
    RCC_ClocksTypeDef RCC_Clocks;

			




	
	
	
		
 
    RCC_GetClocksFreq(&RCC_Clocks);

			




	
	
	
		
 
    SysTick_Config(RCC_Clocks.HCLK_Frequency / 1000);

			




	
	
	
		
 
    //RCC_ClocksTypeDef RCC_Clocks;

			




	
	
	
		
 
    //RCC_GetClocksFreq(&RCC_Clocks);

			




	
	
	
		
 
    //SysTick_Config(RCC_Clocks.HCLK_Frequency / 1000);

			




	
	
	
		
 

			




	
	
	
		
 
    // Init SPI busses

			




	
	
	
		
 
    init_spi();

			




	
	
	
		
 
    //init_spi(&spi1);

			




	
	
	
		
 

			




	
	
	
		
 
    // Init USB 

			




	
	
	
		
 
    init_usb();

			




	
	
	
		
 
    //MX_USB_DEVICE_Init();

			




	
	
	
		
 
    

			




	
	
	
		
 
    // Init OLED over SPI

			




	
	
	
		
 
    ssd1306_Init();

			




	
	
	
		
 
    ssd1306_clearscreen();

			




	
	
	
		
 

			




	
	
	
		
 
    // Check for problems on startup

			




	
	
	
		
 
    uint8_t clock_fail = 0; // FIXME implement in system

			




	
	
	
		
 
    if(clock_fail) {

			




	
	
	
		
 
        //ssd1306_DrawStringBig("ERROR: Check Xtal", 2, 0);

			




	
	
	
		
 
        ssd1306_DrawStringBig("NO XTAL", 2, 0);

			




	
	
	
		
 
        delay(1000);

			




	
	
	
		
 
        ssd1306_clearscreen();

			




	
	
		
 
@@ -130,51 +124,62 @@ int main(void)

			




	
	
	
		
 

			




	
	
	
		
 
    // Startup screen 

			




	
	
	
		
 
    ssd1306_DrawString("therm v0.1", 1, 40);

			




	
	
	
		
 
    ssd1306_DrawString("protofusion.org/therm", 3, 0);

			




	
	
	
		
 

			




	
	
	
		
 
    delay(1500);

			




	
	
	
		
 
    ssd1306_clearscreen();

			




	
	
	
		
 
    

			




	
	
	
		
 
    restore_settings();

			




	
	
	
		
 
    if(boottobrew)

			




	
	
	
		
 
      state = STATE_PREHEAT_BREW; // Go to brew instead of idle if configured thusly

			




	
	
	
		
 

			




	
	
	
		
 
    GPIO_ResetBits(LED_STAT);

			




	
	
	
		
 
    HAL_GPIO_WritePin(LED_STAT, 0);

			




	
	
	
		
 

			




	
	
	
		
 
    // Main loop

			




	
	
	
		
 
    while(1)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        // Process sensor inputs

			




	
	
	
		
 
        process();

			




	
	
	
		
 

			




	
	
	
		
 
        // Run state machine

			




	
	
	
		
 
        machine(); 

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
// Read temperature and update global temp vars

			




	
	
	
		
 
int32_t temp = 0;

			




	
	
	
		
 
uint8_t temp_frac = 0;

			




	
	
	
		
 
uint8_t state_resume = 0;

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
// FIXME: Now this needs to work 8bits at a time, or change the port mode on the fly

			




	
	
	
		
 
void update_temp() {

			




	
	
	
		
 
    // Assert CS

			




	
	
	
		
 
    GPIO_ResetBits(MAX_CS);

			




	
	
	
		
 
    HAL_GPIO_WritePin(MAX_CS, 0);

			




	
	
	
		
 
    delay(1);

			




	
	
	
		
 

			




	
	
	
		
 
    // This may not clock at all... might need to send 16 bits first

			




	
	
	
		
 
    SPI_I2S_SendData(SPI2, 0xAAAA); // send dummy data

			




	
	
	
		
 
    //SPI_I2S_SendData(SPI2, 0xAA); // send dummy data

			




	
	
	
		
 
    uint16_t temp_pre = SPI_I2S_ReceiveData(SPI2);

			




	
	
	
		
 
    // SPI_I2S_SendData(SPI2, 0xAAAA); // send dummy data

			




	
	
	
		
 

			




	
	
	
		
 
    uint8_t data[2] = {0xAA, 0xAA};

			




	
	
	
		
 
    //HAL_SPI_Transmit(&spi1, data, 2, 100);

			




	
	
	
		
 
    

			




	
	
	
		
 
    //OLD: SPI_I2S_SendData(SPI2, 0xAA); // send dummy data

			




	
	
	
		
 
    // OLD:   uint16_t temp_pre = SPI_I2S_ReceiveData(SPI2);

			




	
	
	
		
 
    

			




	
	
	
		
 
    //HAL_SPI_Receive(&spi1, data, 2, 100);

			




	
	
	
		
 

			




	
	
	
		
 
    // Assemble data array into one var

			




	
	
	
		
 
    uint16_t temp_pre = data[0] & (data[1]<<8);

			




	
	
	
		
 

			




	
	
	
		
 
    if(temp_pre & 0b0000000000000010) {

			




	
	
	
		
 
        ssd1306_DrawString("Fatal Error", 3, 35);

			




	
	
	
		
 
        state = STATE_TC_ERROR;

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else if(temp_pre & 0b0000000000000001 && !ignore_tc_error) {

			




	
	
	
		
 
        state_resume = state;

			




	
	
	
		
 
        state = STATE_TC_ERROR;

			




	
	
	
		
 
        temp = 0;

			




	
	
	
		
 
        temp_frac = 0;

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else 

			




	
	
		
 
@@ -205,25 +210,25 @@ void update_temp() {

			




	
	
	
		
 
            temp += 32;

			




	
	
	
		
 

			




	
	
	
		
 
            temp_frac *= 9;

			




	
	
	
		
 
            temp_frac /= 5;

			




	
	
	
		
 
            temp_frac += 32;

			




	
	
	
		
 
            temp += temp_frac/100; // add overflow to above

			




	
	
	
		
 
            temp_frac %= 100;

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    // Deassert CS

			




	
	
	
		
 
    delay(1);

			




	
	
	
		
 
    GPIO_SetBits(MAX_CS);

			




	
	
	
		
 
    HAL_GPIO_WritePin(MAX_CS, 1);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
// PID implementation

			




	
	
	
		
 
// TODO: Make struct that has the last_temp and i_state in it, pass by ref. Make struct that has other input values maybe.

			




	
	
	
		
 
int16_t last_pid_temp = 0;

			




	
	
	
		
 
uint8_t last_pid_temp_frac = 0;

			




	
	
	
		
 
int16_t i_state = 0;

			




	
	
	
		
 

			




	
	
	
		
 
int16_t update_pid(uint16_t k_p, uint16_t k_i, uint16_t k_d, int16_t temp, uint8_t temp_frac, int16_t setpoint) 

			




	
	
	
		
 
{

			




	
	
	
		
 
  // Calculate instantaneous error

			




	
	
		
 
@@ -276,71 +281,71 @@ int32_t setpoint = 0;

			




	
	
	
		
 
int16_t ssr_output = 0; // Duty cycle of ssr, 0 to SSR_PERIOD 

			




	
	
	
		
 
uint8_t pid_enabled = 0;

			




	
	
	
		
 

			




	
	
	
		
 
// Process things

			




	
	
	
		
 
void process()

			




	
	
	
		
 
{

			




	
	
	
		
 
    update_temp(); // Read MAX31855

			




	
	
	
		
 

			




	
	
	
		
 
    // TODO: Add calibration offset (linear)

			




	
	
	
		
 

			




	
	
	
		
 
    if(ticks - last_led > 400) 

			




	
	
	
		
 
    {

			




	
	
	
		
 
        GPIO_ToggleBits(LED_POWER);

			




	
	
	
		
 
        HAL_GPIO_TogglePin(LED_POWER);

			




	
	
	
		
 
        last_led = ticks;

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    // Every 200ms, set the SSR on unless output is 0

			




	
	
	
		
 
    if((ticks - last_ssr_on > SSR_PERIOD))

			




	
	
	
		
 
    {

			




	
	
	
		
 
        if(pid_enabled) 

			




	
	
	
		
 
        {

			




	
	
	
		
 
            // Get ssr output for next time

			




	
	
	
		
 
            int16_t power_percent = update_pid(k_p, k_i, k_d, temp, temp_frac, setpoint);

			




	
	
	
		
 
            //power-percent is 0-1000

			




	
	
	
		
 
            ssr_output = power_percent; //(((uint32_t)SSR_PERIOD * (uint32_t)10 * (uint32_t)100) * power_percent) / (uint32_t)1000000;

			




	
	
	
		
 
        }

			




	
	
	
		
 
        else 

			




	
	
	
		
 
        {

			




	
	
	
		
 
            ssr_output = 0;

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        // Only support heating (ssr_output > 0) right now

			




	
	
	
		
 
        if(ssr_output > 0) {

			




	
	
	
		
 

			




	
	
	
		
 
            char tempstr[6];

			




	
	
	
		
 
            itoa(ssr_output, tempstr);

			




	
	
	
		
 
            itoa(ssr_output, tempstr, 10);

			




	
	
	
		
 
            ssd1306_DrawString(tempstr, 0, 90);

			




	
	
	
		
 

			




	
	
	
		
 
            GPIO_SetBits(LED_STAT);

			




	
	
	
		
 
            GPIO_SetBits(SSR_PIN);

			




	
	
	
		
 
            HAL_GPIO_WritePin(LED_STAT, 1);

			




	
	
	
		
 
            HAL_GPIO_WritePin(SSR_PIN, 1);

			




	
	
	
		
 
            last_ssr_on = ticks;

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 
    

			




	
	
	
		
 
    // Kill SSR after elapsed period less than SSR_PERIOD 

			




	
	
	
		
 
    if(ticks - last_ssr_on > ssr_output || ssr_output == 0)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        GPIO_ResetBits(LED_STAT);

			




	
	
	
		
 
        GPIO_ResetBits(SSR_PIN);

			




	
	
	
		
 
        HAL_GPIO_WritePin(LED_STAT, 0);

			




	
	
	
		
 
        HAL_GPIO_WritePin(SSR_PIN, 0);

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void draw_setpoint() {

			




	
	
	
		
 
    char tempstr[3];

			




	
	
	
		
 
    itoa_fp(temp, temp_frac, tempstr);

			




	
	
	
		
 
    ssd1306_DrawStringBig("      ", 3, 0);

			




	
	
	
		
 
    ssd1306_DrawStringBig(tempstr, 3, 0);

			




	
	
	
		
 
    ssd1306_DrawStringBig(">", 3, 74);

			




	
	
	
		
 
    itoa(setpoint, tempstr);

			




	
	
	
		
 
    itoa(setpoint, tempstr, 10);

			




	
	
	
		
 
    ssd1306_DrawStringBig("    ", 3, 90);

			




	
	
	
		
 
    ssd1306_DrawStringBig(tempstr, 3, 90);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
uint8_t goto_mode = 2;

			




	
	
	
		
 

			




	
	
	
		
 
// State machine

			




	
	
	
		
 
uint8_t sw_btn_last = 0;

			




	
	
	
		
 
uint8_t sw_up_last = 0;

			




	
	
	
		
 
uint8_t sw_down_last = 0;

			




	
	
	
		
 
uint8_t sw_left_last = 0;

			




	
	
	
		
 
uint8_t sw_right_last = 0;

			




	
	
		
 
@@ -422,29 +427,29 @@ uint8_t final_setpoint = 0;

			




	
	
	
		
 

			




	
	
	
		
 
// When executing, complete on time AND(?) temperature. Maybe allow switching to OR via settings

			




	
	
	
		
 

			




	
	
	
		
 
////////////////////////////////////////////////////////////////////////////////////////////////

			




	
	
	
		
 

			




	
	
	
		
 
void machine()

			




	
	
	
		
 
{

			




	
	
	
		
 
    uint8_t last_state = state;

			




	
	
	
		
 
    

			




	
	
	
		
 
    uint8_t temp_changed = temp != last_temp;

			




	
	
	
		
 
    last_temp = temp;

			




	
	
	
		
 

			




	
	
	
		
 
    uint8_t sw_btn = !GPIO_ReadInputDataBit(SW_BTN);

			




	
	
	
		
 
    uint8_t sw_up = !GPIO_ReadInputDataBit(SW_UP);

			




	
	
	
		
 
    uint8_t sw_down = !GPIO_ReadInputDataBit(SW_DOWN);

			




	
	
	
		
 
    uint8_t sw_left = !GPIO_ReadInputDataBit(SW_LEFT);

			




	
	
	
		
 
    uint8_t sw_right = !GPIO_ReadInputDataBit(SW_RIGHT);

			




	
	
	
		
 
    uint8_t sw_btn = !HAL_GPIO_ReadPin(SW_BTN);

			




	
	
	
		
 
    uint8_t sw_up = !HAL_GPIO_ReadPin(SW_UP);

			




	
	
	
		
 
    uint8_t sw_down = !HAL_GPIO_ReadPin(SW_DOWN);

			




	
	
	
		
 
    uint8_t sw_left = !HAL_GPIO_ReadPin(SW_LEFT);

			




	
	
	
		
 
    uint8_t sw_right = !HAL_GPIO_ReadPin(SW_RIGHT);

			




	
	
	
		
 

			




	
	
	
		
 
    switch(state)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        // Idle state

			




	
	
	
		
 
        case STATE_IDLE:

			




	
	
	
		
 
        {

			




	
	
	
		
 
            // Write text to OLED

			




	
	
	
		
 
            // [ therm :: idle ]

			




	
	
	
		
 
            ssd1306_DrawString("therm :: idle ", 0, 40);

			




	
	
	
		
 
            pid_enabled = 0;

			




	
	
	
		
 

			




	
	
	
		
 
            if(temp_changed) {

			




	
	
		
 
@@ -503,25 +508,25 @@ void machine()

			




	
	
	
		
 

			




	
	
	
		
 
        } break;

			




	
	
	
		
 

			




	
	
	
		
 
        case STATE_SETP:

			




	
	
	
		
 
        {

			




	
	
	
		
 
            // Write text to OLED

			




	
	
	
		
 
            // [ therm :: set p ]

			




	
	
	
		
 
            // [ p = 12         ]

			




	
	
	
		
 
            ssd1306_DrawString("Proportional", 0, 40);

			




	
	
	
		
 
            ssd1306_drawlogo();

			




	
	
	
		
 

			




	
	
	
		
 
            char tempstr[6];

			




	
	
	
		
 
            itoa(k_p, tempstr);

			




	
	
	
		
 
            itoa(k_p, tempstr, 10);

			




	
	
	
		
 
            ssd1306_DrawString("P=", 1, 45);

			




	
	
	
		
 
            ssd1306_DrawString("    ", 1, 57);

			




	
	
	
		
 
            ssd1306_DrawString(tempstr, 1, 57);

			




	
	
	
		
 

			




	
	
	
		
 
            ssd1306_DrawString("Press to accept", 3, 40);

			




	
	
	
		
 
            

			




	
	
	
		
 
            // Button handler

			




	
	
	
		
 
            if(SW_BTN_PRESSED) {

			




	
	
	
		
 
                state = STATE_SETI;

			




	
	
	
		
 
            }

			




	
	
	
		
 
            else {

			




	
	
	
		
 
                user_input(&k_p);

			




	
	
		
 
@@ -532,25 +537,25 @@ void machine()

			




	
	
	
		
 
 

			




	
	
	
		
 
        } break;

			




	
	
	
		
 

			




	
	
	
		
 
        case STATE_SETI:

			




	
	
	
		
 
        {

			




	
	
	
		
 
            // Write text to OLED

			




	
	
	
		
 
            // [ therm :: set i ]

			




	
	
	
		
 
            // [ i = 12         ]

			




	
	
	
		
 
            ssd1306_DrawString("Integral", 0, 40);

			




	
	
	
		
 
            ssd1306_drawlogo();

			




	
	
	
		
 

			




	
	
	
		
 
            char tempstr[6];

			




	
	
	
		
 
            itoa(k_i, tempstr);

			




	
	
	
		
 
            itoa(k_i, tempstr, 10);

			




	
	
	
		
 
            ssd1306_DrawString("I=", 1, 45);

			




	
	
	
		
 
            ssd1306_DrawString("    ", 1, 57);

			




	
	
	
		
 
            ssd1306_DrawString(tempstr, 1, 57);

			




	
	
	
		
 

			




	
	
	
		
 
            ssd1306_DrawString("Press to accept", 3, 40);

			




	
	
	
		
 
            

			




	
	
	
		
 
            // Button handler

			




	
	
	
		
 
            if(SW_BTN_PRESSED) {

			




	
	
	
		
 
                state = STATE_SETD;

			




	
	
	
		
 
            }

			




	
	
	
		
 
            else {

			




	
	
	
		
 
                user_input(&k_i);

			




	
	
		
 
@@ -561,25 +566,25 @@ void machine()

			




	
	
	
		
 
 

			




	
	
	
		
 
        } break;

			




	
	
	
		
 

			




	
	
	
		
 
        case STATE_SETD:

			




	
	
	
		
 
        {

			




	
	
	
		
 
            // Write text to OLED

			




	
	
	
		
 
            // [ therm :: set d ]

			




	
	
	
		
 
            // [ d = 12         ]

			




	
	
	
		
 
            ssd1306_DrawString("Derivative", 0, 40);

			




	
	
	
		
 
            ssd1306_drawlogo();

			




	
	
	
		
 

			




	
	
	
		
 
            char tempstr[6];

			




	
	
	
		
 
            itoa(k_d, tempstr);

			




	
	
	
		
 
            itoa(k_d, tempstr, 10);

			




	
	
	
		
 
            ssd1306_DrawString("D=", 1, 45);

			




	
	
	
		
 
            ssd1306_DrawString("    ", 1, 57);

			




	
	
	
		
 
            ssd1306_DrawString(tempstr, 1, 57);

			




	
	
	
		
 

			




	
	
	
		
 
            ssd1306_DrawString("Press to accept", 3, 40);

			




	
	
	
		
 

			




	
	
	
		
 
            // Button handler

			




	
	
	
		
 
            if(SW_BTN_PRESSED) {

			




	
	
	
		
 
                state = STATE_SETWINDUP;

			




	
	
	
		
 
            }

			




	
	
	
		
 
            else {

			




	
	
	
		
 
                user_input(&k_d);

			




	
	
		
 
@@ -588,34 +593,34 @@ void machine()

			




	
	
	
		
 
            // Event Handler

			




	
	
	
		
 
            // N/A

			




	
	
	
		
 
 

			




	
	
	
		
 
        } break;

			




	
	
	
		
 

			




	
	
	
		
 
        case STATE_SETSTEPS:

			




	
	
	
		
 
        {

			




	
	
	
		
 
            // Write text to OLED

			




	
	
	
		
 
            // [ step #1:: Duration: ### ]

			




	
	
	
		
 
            // [           Setpoint: ### ]

			




	
	
	
		
 
            char tempstr[6];

			




	
	
	
		
 

			




	
	
	
		
 
            itoa(final_setpoint, tempstr);

			




	
	
	
		
 
            itoa(final_setpoint, tempstr, 10);

			




	
	
	
		
 
            ssd1306_DrawString("Step #", 0, 0);

			




	
	
	
		
 
            ssd1306_DrawString(tempstr, 0, 40);

			




	
	
	
		
 

			




	
	
	
		
 
            ssd1306_DrawString("Duration: ", 0, 5);

			




	
	
	
		
 
            itoa(step_duration[final_setpoint], tempstr);

			




	
	
	
		
 
            itoa(step_duration[final_setpoint], tempstr, 10);

			




	
	
	
		
 
            ssd1306_DrawString(tempstr, 0, 70);

			




	
	
	
		
 

			




	
	
	
		
 
            ssd1306_DrawString("Setpoint: ", 0, 0);

			




	
	
	
		
 
            itoa(step_setpoint[final_setpoint], tempstr);

			




	
	
	
		
 
            itoa(step_setpoint[final_setpoint], tempstr, 10);

			




	
	
	
		
 
            ssd1306_DrawString(tempstr, 0, 70);

			




	
	
	
		
 

			




	
	
	
		
 
            ssd1306_DrawString("Press to accept", 3, 40);

			




	
	
	
		
 
            

			




	
	
	
		
 
            // Button handler - TODO: increment max_step if pressed

			




	
	
	
		
 
            // return and go to next state otherwise

			




	
	
	
		
 
            if(SW_BTN_PRESSED) {

			




	
	
	
		
 
                state = STATE_SETSTEPS;

			




	
	
	
		
 
                final_setpoint++;

			




	
	
	
		
 
            }

			




	
	
	
		
 
        //    else if(SW_LEFT_PRESSED) {

			




	
	
	
		
 
        //        state++; // go to next state or something

			




	
	
		
 
@@ -629,25 +634,25 @@ void machine()

			




	
	
	
		
 

			




	
	
	
		
 
        } break;

			




	
	
	
		
 

			




	
	
	
		
 
        case STATE_SETWINDUP:

			




	
	
	
		
 
        {

			




	
	
	
		
 
            // Write text to OLED

			




	
	
	
		
 
            // [ therm :: set windup ]

			




	
	
	
		
 
            // [ g = 12         ]

			




	
	
	
		
 
            ssd1306_DrawString("Windup Guard", 0, 40);

			




	
	
	
		
 
            ssd1306_drawlogo();

			




	
	
	
		
 

			




	
	
	
		
 
            char tempstr[6];

			




	
	
	
		
 
            itoa(windup_guard, tempstr);

			




	
	
	
		
 
            itoa(windup_guard, tempstr, 10);

			




	
	
	
		
 
            ssd1306_DrawString("G=", 1, 45);

			




	
	
	
		
 
            ssd1306_DrawString("    ", 1, 57);

			




	
	
	
		
 
            ssd1306_DrawString(tempstr, 1, 57);

			




	
	
	
		
 

			




	
	
	
		
 
            ssd1306_DrawString("Press to accept", 3, 40);

			




	
	
	
		
 

			




	
	
	
		
 
            // Button handler

			




	
	
	
		
 
            if(SW_BTN_PRESSED) {

			




	
	
	
		
 
                state = STATE_SETBOOTTOBREW;

			




	
	
	
		
 
            }

			




	
	
	
		
 
            else {

			




	
	
	
		
 
                user_input(&windup_guard);

			




	
	
		
 
@@ -670,28 +675,28 @@ void machine()

			




	
	
	
		
 
            

			




	
	
	
		
 
            if(boottobrew)

			




	
	
	
		
 
                ssd1306_DrawString("Enabled ", 1, 70);

			




	
	
	
		
 
            else

			




	
	
	
		
 
                ssd1306_DrawString("Disabled", 1, 70);

			




	
	
	
		
 

			




	
	
	
		
 
            ssd1306_DrawString("Press to accept", 3, 40);

			




	
	
	
		
 

			




	
	
	
		
 
            // Button handler

			




	
	
	
		
 
            if(SW_BTN_PRESSED) {

			




	
	
	
		
 
                state = STATE_SETUNITS;

			




	
	
	
		
 
            }

			




	
	
	
		
 
            else if(!GPIO_ReadInputDataBit(SW_UP)) {

			




	
	
	
		
 
            else if(!HAL_GPIO_ReadPin(SW_UP)) {

			




	
	
	
		
 
                boottobrew = 1;

			




	
	
	
		
 
            }

			




	
	
	
		
 
            else if(!GPIO_ReadInputDataBit(SW_DOWN)) {

			




	
	
	
		
 
            else if(!HAL_GPIO_ReadPin(SW_DOWN)) {

			




	
	
	
		
 
                boottobrew = 0;

			




	
	
	
		
 
            }

			




	
	
	
		
 

			




	
	
	
		
 
            // Event Handler

			




	
	
	
		
 
            // N/A

			




	
	
	
		
 
 

			




	
	
	
		
 
        } break;

			




	
	
	
		
 

			




	
	
	
		
 
        case STATE_SETUNITS:

			




	
	
	
		
 
        {

			




	
	
	
		
 
            // Write text to OLED

			




	
	
	
		
 
            // [ therm :: set windup ]

			




	
	
		
 
@@ -702,28 +707,28 @@ void machine()

			




	
	
	
		
 
            if(temp_units == TEMP_UNITS_FAHRENHEIT)

			




	
	
	
		
 
                ssd1306_DrawString("Fahrenheit", 1, 60);

			




	
	
	
		
 
            else

			




	
	
	
		
 
                ssd1306_DrawString("Celsius   ", 1, 60);

			




	
	
	
		
 

			




	
	
	
		
 
            ssd1306_DrawString("Press to accept", 3, 40);

			




	
	
	
		
 

			




	
	
	
		
 
            // Button handler

			




	
	
	
		
 
            if(SW_BTN_PRESSED) {

			




	
	
	
		
 
                save_settings();

			




	
	
	
		
 
                state = STATE_IDLE;

			




	
	
	
		
 
            }

			




	
	
	
		
 
            else if(!GPIO_ReadInputDataBit(SW_UP)) {

			




	
	
	
		
 
            else if(!HAL_GPIO_ReadPin(SW_UP)) {

			




	
	
	
		
 
                temp_units = TEMP_UNITS_FAHRENHEIT;

			




	
	
	
		
 
            }

			




	
	
	
		
 
            else if(!GPIO_ReadInputDataBit(SW_DOWN)) {

			




	
	
	
		
 
            else if(!HAL_GPIO_ReadPin(SW_DOWN)) {

			




	
	
	
		
 
                temp_units = TEMP_UNITS_CELSIUS;

			




	
	
	
		
 
            }

			




	
	
	
		
 

			




	
	
	
		
 
            // Event Handler

			




	
	
	
		
 
            // N/A

			




	
	
	
		
 
 

			




	
	
	
		
 
        } break;

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
        case STATE_PREHEAT_BREW:

			




	
	
	
		
 
        {

			




	
	
	
		
 
            // Write text to OLED

			




        

    


    
    

    

        

                

                    main.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
#ifndef __MAIN_H

			




	
	
	
		
 
#define __MAIN_H

			




	
	
	
		
 

			




	
	
	
		
 
#define STM32F042x6

			




	
	
	
		
 

			




	
	
	
		
 
#include "stm32f0xx_hal_conf.h"

			




	
	
	
		
 

			




	
	
	
		
 
void TimingDelay_Decrement(void);

			




	
	
	
		
 
void delay(__IO uint32_t nTime);

			




	
	
	
		
 

			




	
	
	
		
 
//SPI_HandleTypeDef spi1;

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
#endif /* __MAIN_H */

			




	
	
	
		
 

			




        

    


    
    

    

        

                

                    spi.c
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 

			




	
	
	
		
 
void init_spi(void)

			




	
	
	
		
 
#include "stm32f0xx_hal_conf.h"

			




	
	
	
		
 
/*

			




	
	
	
		
 
void init_spi(SPI_HandleTypeDef* hspi1)

			




	
	
	
		
 
{

			




	
	
	
		
 
  

			




	
	
	
		
 
    SPI_HandleTypeDef hspi1;

			




	
	
	
		
 
    

			




	
	
	
		
 
    hspi1.Instance = SPI1;

			




	
	
	
		
 
    hspi1.Init.Mode = SPI_MODE_MASTER;

			




	
	
	
		
 
    hspi1.Init.Direction = SPI_DIRECTION_2LINES;

			




	
	
	
		
 
    hspi1.Init.DataSize = SPI_DATASIZE_8BIT;

			




	
	
	
		
 
    hspi1.Init.CLKPolarity = SPI_POLARITY_LOW;

			




	
	
	
		
 
    hspi1.Init.CLKPhase = SPI_PHASE_1EDGE;

			




	
	
	
		
 
    hspi1.Init.NSS = SPI_NSS_SOFT;

			




	
	
	
		
 
    hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_8;

			




	
	
	
		
 
    hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;

			




	
	
	
		
 
    hspi1.Init.TIMode = SPI_TIMODE_DISABLED;

			




	
	
	
		
 
    hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLED;

			




	
	
	
		
 
    hspi1.Init.NSSPMode = SPI_NSS_PULSE_ENABLED;

			




	
	
	
		
 
    HAL_SPI_Init(&hspi1);

			




	
	
	
		
 
    

			




	
	
	
		
 
    hspi1->Instance = SPI1;

			




	
	
	
		
 
    hspi1->Init.Mode = SPI_MODE_MASTER;

			




	
	
	
		
 
    hspi1->Init.Direction = SPI_DIRECTION_2LINES;

			




	
	
	
		
 
    hspi1->Init.DataSize = SPI_DATASIZE_8BIT;

			




	
	
	
		
 
    hspi1->Init.CLKPolarity = SPI_POLARITY_LOW;

			




	
	
	
		
 
    hspi1->Init.CLKPhase = SPI_PHASE_1EDGE;

			




	
	
	
		
 
    hspi1->Init.NSS = SPI_NSS_SOFT;

			




	
	
	
		
 
    hspi1->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_8;

			




	
	
	
		
 
    hspi1->Init.FirstBit = SPI_FIRSTBIT_MSB;

			




	
	
	
		
 
    hspi1->Init.TIMode = SPI_TIMODE_DISABLED;

			




	
	
	
		
 
    hspi1->Init.CRCCalculation = SPI_CRCCALCULATION_DISABLED;

			




	
	
	
		
 
    hspi1->Init.NSSPMode = SPI_NSS_PULSE_ENABLED;

			




	
	
	
		
 
    HAL_SPI_Init(hspi1);

			




	
	
	
		
 
}*/    

			




	
	
	
		
 
    

			




	
	
	
		
 
    /* OLD:

			




	
	
	
		
 
        SPI_InitTypeDef  SPI_InitStructure;

			




	
	
	
		
 

			




	
	
	
		
 
    // OLED IC

			




	
	
	
		
 
    SPI_Cmd(SPI1, DISABLE); 

			




	
	
	
		
 
    SPI_InitStructure.SPI_Direction = SPI_Direction_1Line_Tx;

			




	
	
	
		
 
    SPI_InitStructure.SPI_Mode = SPI_Mode_Master;

			




	
	
	
		
 
    SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;

			




	
	
	
		
 
    SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;

			




	
	
	
		
 
    SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;

			




	
	
	
		
 
    SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;

			




	
	
		
 
@@ -42,15 +43,14 @@ void init_spi(void)

			




	
	
	
		
 
    SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;

			




	
	
	
		
 
    SPI_InitStructure.SPI_Mode = SPI_Mode_Master;

			




	
	
	
		
 
    SPI_InitStructure.SPI_DataSize = SPI_DataSize_16b; // Andysworkshop

			




	
	
	
		
 
    SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low; // From andysworkshop

			




	
	
	
		
 
    SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge; // same

			




	
	
	
		
 
    SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;

			




	
	
	
		
 
    SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_8;

			




	
	
	
		
 
    SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;

			




	
	
	
		
 
    SPI_InitStructure.SPI_CRCPolynomial = 7;

			




	
	
	
		
 
    SPI_Init(SPI2, &SPI_InitStructure);

			




	
	
	
		
 
    SPI_Cmd(SPI2, ENABLE);          

			




	
	
	
		
 
    */

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
// vim:softtabstop=4 shiftwidth=4 expandtab 

			




        

    


    
    

    

        

                

                    spi.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
#ifndef SPI_H

			




	
	
	
		
 
#define SPI_H

			




	
	
	
		
 

			




	
	
	
		
 
void init_spi(void);

			




	
	
	
		
 
#include "stm32f0xx_hal_conf.h"

			




	
	
	
		
 

			




	
	
	
		
 
void init_spi(SPI_HandleTypeDef* hspi1);

			




	
	
	
		
 

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
// vim:softtabstop=4 shiftwidth=4 expandtab 

			




        

    


    
    

    

        

                

                    ssd1306.c
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
#include "stm32f0xx_hal_conf.h"

			




	
	
	
		
 
#include "ssd1306.h"

			




	
	
	
		
 

			




	
	
	
		
 
// Write command to OLED

			




	
	
	
		
 
void WriteCommand(unsigned char command)

			




	
	
	
		
 
{

			




	
	
	
		
 
  SSD_A0_Low();

			




	
	
	
		
 
  SPI_SendByte(command);

			




	
	
	
		
 
  SPI_Wait();

			




	
	
	
		
 
  //SPI_SendByte(command);

			




	
	
	
		
 
  //SPI_Wait();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
// Write data to OLED

			




	
	
	
		
 
void WriteData(unsigned char data)

			




	
	
	
		
 
{

			




	
	
	
		
 
  SSD_A0_High();

			




	
	
	
		
 
  SPI_SendByte(data);

			




	
	
	
		
 
  SPI_Wait();

			




	
	
	
		
 
  //SPI_SendByte(data);

			




	
	
	
		
 
  //SPI_Wait();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
// Initialize OLED

			




	
	
	
		
 
void ssd1306_Init(void)

			




	
	
	
		
 
{

			




	
	
	
		
 

			




	
	
	
		
 
  /* Generate a reset */

			




	
	
	
		
 
  SSD_Reset_Low();

			




	
	
	
		
 
  uint32_t i;

			




	
	
	
		
 
  for(i=5000; i>1; i--) 

			




	
	
	
		
 
  SSD_Reset_High();

			




	
	
	
		
 

			




        

    


    
    

    

        

                

                    ssd1306.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
#ifndef   ssd1306_H

			




	
	
	
		
 
#define   ssd1306_H

			




	
	
	
		
 

			




	
	
	
		
 
#define   SSD_RESET       GPIOB,GPIO_Pin_2

			




	
	
	
		
 
#define   SSD_A0          GPIOB,GPIO_Pin_10

			




	
	
	
		
 
#define   SSD_CS          GPIOB,GPIO_Pin_1

			




	
	
	
		
 
#define   SSD_RESET       GPIOB,GPIO_PIN_2

			




	
	
	
		
 
#define   SSD_A0          GPIOB,GPIO_PIN_10

			




	
	
	
		
 
#define   SSD_CS          GPIOB,GPIO_PIN_1

			




	
	
	
		
 

			




	
	
	
		
 
#define   SSD_Reset_Low()   GPIO_ResetBits(SSD_RESET)

			




	
	
	
		
 
#define   SSD_Reset_High()  GPIO_SetBits(SSD_RESET)

			




	
	
	
		
 
#define   SSD_A0_Low()      GPIO_ResetBits(SSD_A0)

			




	
	
	
		
 
#define   SSD_A0_High()     GPIO_SetBits(SSD_A0)

			




	
	
	
		
 
#define   SSD_CS_Low()      GPIO_ResetBits(SSD_CS)

			




	
	
	
		
 
#define   SSD_CS_High()     GPIO_SetBits(SSD_CS)

			




	
	
	
		
 
#define   SSD_Reset_Low()   HAL_GPIO_WritePin(SSD_RESET, 0)

			




	
	
	
		
 
#define   SSD_Reset_High()  HAL_GPIO_WritePin(SSD_RESET, 1)

			




	
	
	
		
 
#define   SSD_A0_Low()      HAL_GPIO_WritePin(SSD_A0, 0)

			




	
	
	
		
 
#define   SSD_A0_High()     HAL_GPIO_WritePin(SSD_A0, 1)

			




	
	
	
		
 
#define   SSD_CS_Low()      HAL_GPIO_WritePin(SSD_CS, 0)

			




	
	
	
		
 
#define   SSD_CS_High()     HAL_GPIO_WritePin(SSD_CS, 1)

			




	
	
	
		
 

			




	
	
	
		
 
// Use stdperiph

			




	
	
	
		
 
#define   SPI_SendByte(data)  SPI_I2S_SendData(SPI1,data) 

			




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

			




	
	
	
		
 

			




	
	
	
		
 
//extern SPI_HandleTypeDef spi1;

			




	
	
	
		
 

			




	
	
	
		
 
// EMZ FIXME this won't really work

			




	
	
	
		
 
//#define   SPI_SendByte(data)  HAL_SPI_Transmit(&spi1, data, 1, 100) 

			




	
	
	
		
 
#define SPI_SendByte(data) 

			




	
	
	
		
 
#define SPI_Wait() 

			




	
	
	
		
 

			




	
	
	
		
 
//#define   SPI_SendByte(data)  SPI_I2S_SendData(SPI1,data) 

			




	
	
	
		
 

			




	
	
	
		
 
//#define   SPI_Wait()       while(!(SPI1->SR&SPI_FLAG_TXE));while(SPI1->SR&SPI_FLAG_BSY); 

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
void ssd1306_Init(void);

			




	
	
	
		
 
void ssd1306_DrawChar(char ascii, unsigned char row, unsigned char xPos);

			




	
	
	
		
 
void ssd1306_DrawCharBig(char ascii, unsigned char row, unsigned char xPos);

			




	
	
	
		
 
void ssd1306_DrawString(const char *dataPtr, unsigned char row, unsigned char xPos);

			




	
	
	
		
 
void ssd1306_DrawStringBig(const char *dataPtr, unsigned char row, unsigned char xPos);

			




	
	
	
		
 
void ssd1306_drawlogo();

			




	
	
	
		
 
void ssd1306_clearscreen();

			




	
	
	
		
 

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




        

    


    
    

    

        

                

                    stm32f0xx_hal_conf.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -54,25 +54,25 @@

			




	
	
	
		
 
//#define HAL_COMP_MODULE_ENABLED   

			




	
	
	
		
 
//#define HAL_CRC_MODULE_ENABLED   

			




	
	
	
		
 
//#define HAL_CRYP_MODULE_ENABLED   

			




	
	
	
		
 
//#define HAL_TSC_MODULE_ENABLED   

			




	
	
	
		
 
//#define HAL_DAC_MODULE_ENABLED   

			




	
	
	
		
 
//#define HAL_I2C_MODULE_ENABLED   

			




	
	
	
		
 
//#define HAL_I2S_MODULE_ENABLED   

			




	
	
	
		
 
//#define HAL_IWDG_MODULE_ENABLED   

			




	
	
	
		
 
//#define HAL_LCD_MODULE_ENABLED   

			




	
	
	
		
 
//#define HAL_LPTIM_MODULE_ENABLED   

			




	
	
	
		
 
//#define HAL_RNG_MODULE_ENABLED   

			




	
	
	
		
 
//#define HAL_RTC_MODULE_ENABLED   

			




	
	
	
		
 
#define HAL_SPI_MODULE_ENABLED

			




	
	
	
		
 
//#define HAL_SPI_MODULE_ENABLED

			




	
	
	
		
 
//#define HAL_TIM_MODULE_ENABLED   

			




	
	
	
		
 
//#define HAL_UART_MODULE_ENABLED   

			




	
	
	
		
 
//#define HAL_USART_MODULE_ENABLED   

			




	
	
	
		
 
//#define HAL_IRDA_MODULE_ENABLED   

			




	
	
	
		
 
//#define HAL_SMARTCARD_MODULE_ENABLED   

			




	
	
	
		
 
//#define HAL_SMBUS_MODULE_ENABLED   

			




	
	
	
		
 
//#define HAL_WWDG_MODULE_ENABLED   

			




	
	
	
		
 
#define HAL_PCD_MODULE_ENABLED

			




	
	
	
		
 
#define HAL_CORTEX_MODULE_ENABLED

			




	
	
	
		
 
#define HAL_DMA_MODULE_ENABLED

			




	
	
	
		
 
#define HAL_FLASH_MODULE_ENABLED

			




	
	
	
		
 
#define HAL_GPIO_MODULE_ENABLED

			




        

    


    
    

    

        

                

                    stm32f0xx_hal_msp.c
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -48,79 +48,65 @@ void HAL_MspInit(void)

			




	
	
	
		
 

			




	
	
	
		
 
  /* USER CODE END MspInit 0 */

			




	
	
	
		
 

			




	
	
	
		
 
  /* System interrupt init*/

			




	
	
	
		
 
/* SysTick_IRQn interrupt configuration */

			




	
	
	
		
 
  HAL_NVIC_SetPriority(SysTick_IRQn, 0, 0);

			




	
	
	
		
 

			




	
	
	
		
 
  /* USER CODE BEGIN MspInit 1 */

			




	
	
	
		
 

			




	
	
	
		
 
  /* USER CODE END MspInit 1 */

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
/*

			




	
	
	
		
 
void HAL_SPI_MspInit(SPI_HandleTypeDef* hspi)

			




	
	
	
		
 
{

			




	
	
	
		
 

			




	
	
	
		
 
  GPIO_InitTypeDef GPIO_InitStruct;

			




	
	
	
		
 
  if(hspi->Instance==SPI1)

			




	
	
	
		
 
  {

			




	
	
	
		
 
  /* USER CODE BEGIN SPI1_MspInit 0 */

			




	
	
	
		
 

			




	
	
	
		
 
  /* USER CODE END SPI1_MspInit 0 */

			




	
	
	
		
 
    /* Peripheral clock enable */

			




	
	
	
		
 
    __SPI1_CLK_ENABLE();

			




	
	
	
		
 
  

			




	
	
	
		
 
    /**SPI1 GPIO Configuration    

			




	
	
	
		
 
    PA5     ------> SPI1_SCK

			




	
	
	
		
 
    PA6     ------> SPI1_MISO

			




	
	
	
		
 
    PA7     ------> SPI1_MOSI 

			




	
	
	
		
 
    */

			




	
	
	
		
 
    // SPI1 GPIO Configuration    

			




	
	
	
		
 
   // PA5     ------> SPI1_SCK

			




	
	
	
		
 
   //  PA6     ------> SPI1_MISO

			




	
	
	
		
 
   // PA7     ------> SPI1_MOSI 

			




	
	
	
		
 
    GPIO_InitStruct.Pin = GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7;

			




	
	
	
		
 
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;

			




	
	
	
		
 
    GPIO_InitStruct.Pull = GPIO_NOPULL;

			




	
	
	
		
 
    GPIO_InitStruct.Speed = GPIO_SPEED_LOW;

			




	
	
	
		
 
    GPIO_InitStruct.Alternate = GPIO_AF0_SPI1;

			




	
	
	
		
 
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

			




	
	
	
		
 

			




	
	
	
		
 
  /* USER CODE BEGIN SPI1_MspInit 1 */

			




	
	
	
		
 

			




	
	
	
		
 
  /* USER CODE END SPI1_MspInit 1 */

			




	
	
	
		
 
  }

			




	
	
	
		
 

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void HAL_SPI_MspDeInit(SPI_HandleTypeDef* hspi)

			




	
	
	
		
 
{

			




	
	
	
		
 

			




	
	
	
		
 
  if(hspi->Instance==SPI1)

			




	
	
	
		
 
  {

			




	
	
	
		
 
  /* USER CODE BEGIN SPI1_MspDeInit 0 */

			




	
	
	
		
 

			




	
	
	
		
 
  /* USER CODE END SPI1_MspDeInit 0 */

			




	
	
	
		
 
    /* Peripheral clock disable */

			




	
	
	
		
 
    // Peripheral clock disable 

			




	
	
	
		
 
    __SPI1_CLK_DISABLE();

			




	
	
	
		
 
  

			




	
	
	
		
 
    /**SPI1 GPIO Configuration    

			




	
	
	
		
 
    PA5     ------> SPI1_SCK

			




	
	
	
		
 
    PA6     ------> SPI1_MISO

			




	
	
	
		
 
    PA7     ------> SPI1_MOSI 

			




	
	
	
		
 
    */

			




	
	
	
		
 
    //SPI1 GPIO Configuration    

			




	
	
	
		
 
   // PA5     ------> SPI1_SCK

			




	
	
	
		
 
   // PA6     ------> SPI1_MISO

			




	
	
	
		
 
   // PA7     ------> SPI1_MOSI 

			




	
	
	
		
 
    HAL_GPIO_DeInit(GPIOA, GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7);

			




	
	
	
		
 

			




	
	
	
		
 
  /* USER CODE BEGIN SPI1_MspDeInit 1 */

			




	
	
	
		
 

			




	
	
	
		
 
  /* USER CODE END SPI1_MspDeInit 1 */

			




	
	
	
		
 
  }

			




	
	
	
		
 

			




	
	
	
		
 
}

			




	
	
	
		
 
*/

			




	
	
	
		
 

			




	
	
	
		
 
/* USER CODE BEGIN 1 */

			




	
	
	
		
 

			




	
	
	
		
 
/* USER CODE END 1 */

			




	
	
	
		
 

			




	
	
	
		
 
/**

			




	
	
	
		
 
  * @}

			




	
	
	
		
 
  */

			




	
	
	
		
 

			




	
	
	
		
 
/**

			




	
	
	
		
 
  * @}

			




	
	
	
		
 
  */

			




        

    


    
    

    

        

                

                    system_stm32f0xx.c
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
deleted file

			




        

    


    
    

    

        

                

                    system_stm32f0xx.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
deleted file

			




        

    



    


    



    



      

      





    
    0 comments (0 inline, 0 general)
    





    


  

  







  


    




    








    
        Server instance: zserverv-1627831
    
    
        This site is powered by
            Kallithea,
        which is
        © 2010–2021 by various authors & licensed under GPLv3.
            – Support