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

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 %.s $(STARTUP)

# Project Source Files

SRC=main.c

SRC+=ssd1306.c

SRC+=eeprom_min.c

SRC+=gpio.c

SRC+=spi.c

SRC+=clock.c

SRC+=stringhelpers.c

# Standard Peripheral Source Files

# USB Source Files

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

# Default:  MCUFLAGS=-mcpu=cortex-m3 -mthumb -ffunction-sections -fdata-sections

#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)

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);

  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_SYSCLK;

  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSI48;

  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;

  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;

  HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_1);

  PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USB;

  PeriphClkInit.UsbClockSelection = RCC_USBCLKSOURCE_HSI48;

  HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit);

  __SYSCFG_CLK_ENABLE();

#ifndef CONFIG_H

#define CONFIG_H

#define SSR_PERIOD 200

#endif

// vim:softtabstop=4 shiftwidth=4 expandtab 

#include "gpio.h"

#include "config.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) {

            CHANGE_RESET;

            (*to_modify)++;

        }

            CHANGE_RESET;

            (*to_modify)--;

        }

    }

}

void init_gpio(void) {

  GPIO_InitTypeDef GPIO_InitStruct;

    /* GPIO Ports Clock Enable */

  __GPIOF_CLK_ENABLE();

  __GPIOA_CLK_ENABLE();

  __GPIOB_CLK_ENABLE();

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

  // PORT F       //

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

  // PORTF OUTPUT

  // Configure GPIO pin : PF0

  GPIO_InitStruct.Pin = GPIO_PIN_0;

  // Configure GPIO pin : PA15 

  GPIO_InitStruct.Pin = GPIO_PIN_15;

  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;

  GPIO_InitStruct.Pull = GPIO_PULLUP;

  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  // PORTA UNUSED

  // Configure GPIO pins : PA0 PA8

  GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_8;

  GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;

  GPIO_InitStruct.Pull = GPIO_NOPULL;

  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  // 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 

  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  // Configure GPIO pin: PA, MISO

  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  // USB [PORTA]

  /** USB GPIO Configuration  

  PA11   ------> USB_DM

  PA12   ------> USB_DP

  */  

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

  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;

  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

  // PORT B INPUT

  // Configure GPIO pins : PB3 PB4 PB5 PB6 PB7

  GPIO_InitStruct.Pin = GPIO_PIN_3|GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6 

                          |GPIO_PIN_7;

  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;

  GPIO_InitStruct.Pull = GPIO_PULLUP;

  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);  

  // Enable DMA clocks (Is AHB even the right thing???)

#ifndef GPIO_H

#define GPIO_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 

#define __STM32F0xx_H

#ifdef __cplusplus

 extern "C" {

#endif /* __cplusplus */

/** @addtogroup Library_configuration_section

  * @{

  */

/* Uncomment the line below according to the target STM32 device used in your

   application 

  */

#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 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.

  */

#if !defined  (USE_HAL_DRIVER)

/**

 * @brief Comment the line below if you will not use the peripherals drivers.

   In this case, these drivers will not be included and the application code will 

   be based on direct access to peripherals registers 

   */

  /*#define USE_HAL_DRIVER */

#endif /* USE_HAL_DRIVER */

/**

  * @brief CMSIS Device version number V2.1.0

  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE

  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

  *

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

  */

/** @addtogroup CMSIS

  * @{

  */

/** @addtogroup stm32f0xx_system

  * @{

  */

/** @addtogroup STM32F0xx_System_Private_Includes

  * @{

  */

#include "stm32f0xx.h"

/**

  * @}

  */

/** @addtogroup STM32F0xx_System_Private_TypesDefinitions

  * @{

  */

/**

  * @}

  */

/** @addtogroup STM32F0xx_System_Private_Defines

  * @{

  */

#if !defined  (HSE_VALUE) 

  #define HSE_VALUE    ((uint32_t)8000000) /*!< Default value of the External oscillator in Hz.

                                                This value can be provided and adapted by the user application. */

#endif /* HSE_VALUE */

#if !defined  (HSI_VALUE)

  #define HSI_VALUE    ((uint32_t)8000000) /*!< Default value of the Internal oscillator in Hz.

                                                This value can be provided and adapted by the user application. */

  *      

  *  @endverbatim

  *                                  

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

  * @attention

  *

  * <h2><center>&copy; COPYRIGHT 2014 STMicroelectronics</center></h2>

  *

  * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License");

  * You may not use this file except in compliance with the License.

  * You may obtain a copy of the License at:

  *

  *        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_desc.h"

#include "usbd_ctlreq.h"

/** @addtogroup STM32_USB_DEVICE_LIBRARY

  * @{

  */

/** @defgroup USBD_CDC 

  * @brief usbd core module

  * @{

  */ 

/** @defgroup USBD_CDC_Private_TypesDefinitions

  * @{

  */ 

/**

  * @}

  */ 

/** @defgroup USBD_CDC_Private_Defines

  * @{

#include "main.h"

#include "stm32f0xx_hal_conf.h"

#include "ssd1306.h"

#include "config.h"

#include "eeprom_min.h"

#include "gpio.h"

#include "clock.h"

// TODO: Grab buttonpresses with interrupts

// USB Supporting Vars

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

// State definition

enum state {

    STATE_IDLE = 0,

    STATE_SETP,

    STATE_SETI,

    STATE_SETD,

    STATE_SETSTEPS,

    STATE_SETWINDUP,

    STATE_SETBOOTTOBREW,

    STATE_SETUNITS,

    STATE_PREHEAT_BREW,

    STATE_MAINTAIN_BREW,

    STATE_PREHEAT_STEAM,

    STATE_MAINTAIN_STEAM,

    STATE_TC_ERROR

};

uint8_t state = STATE_IDLE;

static __IO uint32_t TimingDelay;

// Move to header file

void process();

void machine();

void restore_settings();

void save_settings();

void save_setpoints();

int main(void)

{

    // Init clocks

    HAL_Init();

    SystemClock_Config();

    // Init GPIO

    init_gpio();

    // Turn on power LED

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

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

    // Init SPI busses

    // Init USB 

    // 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();

    }

    // Init USB

    //Set_System(); // hw_config.h

    //Set_USBClock();

    //SB_Interrupts_Config();

    //SB_Init();

    //SYSCFG_USBPuCmd(ENABLE);

    //PowerOn();

    // 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

    // 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;

void update_temp() {

    // Assert CS

    delay(1);

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

    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 

    {

        if(state == STATE_TC_ERROR)

        {

            state = state_resume;

            ssd1306_clearscreen();

        }

        uint8_t sign = temp >> 15;// top bit is sign

        temp_pre = temp_pre >> 2; // Drop 2 lowest bits

        temp_frac = temp_pre & 0b11; // get fractional part

        temp_frac *= 25; // each bit is .25 a degree, up to fixed point

        temp_pre = temp_pre >> 2; // Drop 2 fractional bits 

        if(sign) {

            temp = -temp_pre;

        }

        else {

            temp = temp_pre;

        }

        if(temp_units == TEMP_UNITS_FAHRENHEIT) {

            temp *= 9; // fixed point mul by 1.8

            temp /= 5;

            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);

}

// 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

  int16_t error = (int16_t)setpoint - (int16_t)temp; // TODO: Use fixed point fraction

  // Proportional component

  int16_t p_term = k_p * error;

  // Error accumulator (integrator)

  i_state += error;

  // to prevent the iTerm getting huge despite lots of 

  //  error, we use a "windup guard" 

  // (this happens when the machine is first turned on and

  // it cant help be cold despite its best efforts)

    result = 1000;

  else if(result < -1000)

    result = -1000;

  // Return feedback

  return result;