#include "main.h"
#include "stm32l100c_discovery.h"
#include "ssd1306.h"
#include "config.h"
#include "eeprom_min.h"
#include "gpio.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"
// 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;
// Globalish setting vars
uint8_t boottobrew = 0;
uint16_t windup_guard = 1;
uint16_t k_p = 1;
uint16_t k_i = 1;
uint16_t k_d = 1;
// ISR ticks var
volatile uint32_t ticks = 0;
int16_t setpoint_brew = 0;
int16_t setpoint_steam = 0;
// State definition
enum state {
STATE_IDLE = 0,
STATE_SETP,
STATE_SETI,
STATE_SETD,
STATE_SETWINDUP,
STATE_SETBOOTTOBREW,
STATE_PREHEAT_BREW,
STATE_MAINTAIN_BREW,
STATE_PREHEAT_STEAM,
STATE_MAINTAIN_STEAM,
};
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
SystemInit();
// Init GPIO
init_gpio();
// Turn on power LED
GPIO_SetBits(LED_POWER);
// 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);
// Init SPI busses
init_spi();
// Init OLED over SPI
ssd1306_Init();
ssd1306_clearscreen();
// Check for problems on startup
if(clock_fail) {
ssd1306_DrawString("ERROR: Check Xtal", 3, 0);
delay(2000);
//ssd1306_DrawStringBig("ERROR: Check Xtal", 2, 0);
ssd1306_DrawStringBig("XTAL ERR", 2, 0);
delay(5000);
}
// Init USB
//Set_System(); // hw_config.h
Set_USBClock();
USB_Interrupts_Config();
USB_Init();
//SYSCFG_USBPuCmd(ENABLE);
//PowerOn();
// Startup screen
ssd1306_DrawString("therm v0.1", 1, 40);
ssd1306_DrawString("protofusion.org/therm", 3, 0);
delay(1500);
restore_settings();
if(boottobrew)
state = STATE_PREHEAT_BREW; // Go to brew instead of idle if configured thusly
GPIO_ResetBits(LED_STAT);
// Main loop
while(1)
// Process sensor inputs
process();
// Run state machine
machine();
// Read temperature and update global temp vars
int16_t temp = 0;
uint8_t temp_frac = 0;
void update_temp() {
// Assert CS
GPIO_ResetBits(MAX_CS);
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);
if(temp_pre & 0b0000000000000010) {
ssd1306_DrawString("Fatal Error", 2, 35);
else if(temp_pre & 0b0000000000000001) {
ssd1306_DrawString("Error: No TC", 2, 40);
temp = 0;
temp_frac = 0;
else
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;
// Deassert CS
GPIO_SetBits(MAX_CS);
// 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)
// not necessary, but this makes windup guard values
// relative to the current iGain
int16_t windup_guard_res = windup_guard / k_i;
// Calculate integral term with windup guard
if (i_state > windup_guard_res)
i_state = windup_guard_res;
else if (i_state < -windup_guard_res)
i_state = -windup_guard_res;
int16_t i_term = k_i * i_state;
// Calculate differential term (slope since last iteration)
int16_t d_term = (k_d * (temp - last_pid_temp));
// Save temperature for next iteration
last_pid_temp = temp;
last_pid_temp_frac = temp_frac;
int16_t result = p_term + i_term - d_term;
// Put out tenths of percent, 0-1000.
if(result > 1000)
result = 1000;
else if(result < -1000)
result = -1000;
// Return feedback
return result;
uint32_t last_ssr_on = 0;
uint32_t last_led = 0;
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);
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;
ssr_output = 0;
// Only support heating (ssr_output > 0) right now
if(ssr_output > 0) {
char tempstr[6];
itoa(ssr_output, tempstr);
ssd1306_DrawString("#=", 2, 45);
ssd1306_DrawString(" ", 2, 57);
ssd1306_DrawString(tempstr, 2, 57);
GPIO_SetBits(LED_STAT);
GPIO_SetBits(SSR_PIN);
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(SSR_PIN);
void draw_setpoint() {
char tempstr[3];
itoa_fp(temp, temp_frac, tempstr);
//ssd1306_DrawString(" ", 3, 40);
ssd1306_DrawString(tempstr, 3, 40);
ssd1306_DrawString("-> ", 3, 80);
itoa(setpoint, tempstr);
ssd1306_DrawString(" ", 3, 95);
ssd1306_DrawString(tempstr, 3, 95);
uint8_t goto_mode = 1;
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;
#define SW_BTN_PRESSED (sw_btn_last == 0 && sw_btn == 1) // rising edge on buttonpress
#define SW_UP_PRESSED (sw_up_last == 0 && sw_up == 1)
#define SW_DOWN_PRESSED (sw_down_last == 0 && sw_down == 1)
#define SW_LEFT_PRESSED (sw_left_last == 0 && sw_left == 1)
#define SW_RIGHT_PRESSED (sw_right_last == 0 && sw_right == 1)
void save_settings()
Minimal_EEPROM_Unlock();
// Try programming a word at an address divisible by 4
Minimal_EEPROM_ProgramWord(EEPROM_BASE_ADDR + EEPROM_ADDR_BOOTTOBREW, boottobrew);
Minimal_EEPROM_ProgramWord(EEPROM_BASE_ADDR + EEPROM_ADDR_WINDUP_GUARD, windup_guard);
Minimal_EEPROM_ProgramWord(EEPROM_BASE_ADDR + EEPROM_ADDR_K_P, k_p);
Minimal_EEPROM_ProgramWord(EEPROM_BASE_ADDR + EEPROM_ADDR_K_I, k_i);
Minimal_EEPROM_ProgramWord(EEPROM_BASE_ADDR + EEPROM_ADDR_K_D, k_d);
Minimal_EEPROM_Lock();
void save_setpoints()
Minimal_EEPROM_ProgramWord(EEPROM_BASE_ADDR + EEPROM_ADDR_BREWTEMP, setpoint_brew);
Minimal_EEPROM_ProgramWord(EEPROM_BASE_ADDR + EEPROM_ADDR_STEAMTEMP, setpoint_steam);
// TODO: Make a struct that has all settings in it. Pass by ref to this func in a library.
void restore_settings()
while(Minimal_FLASH_GetStatus()==FLASH_BUSY);
boottobrew = (*(__IO uint32_t*)(EEPROM_BASE_ADDR + EEPROM_ADDR_BOOTTOBREW));
windup_guard = (*(__IO uint32_t*)(EEPROM_BASE_ADDR + EEPROM_ADDR_WINDUP_GUARD));
k_p = (*(__IO uint32_t*)(EEPROM_BASE_ADDR + EEPROM_ADDR_K_P));
k_i = (*(__IO uint32_t*)(EEPROM_BASE_ADDR + EEPROM_ADDR_K_I));
k_d = (*(__IO uint32_t*)(EEPROM_BASE_ADDR + EEPROM_ADDR_K_D));
setpoint_brew = (*(__IO uint32_t*)(EEPROM_BASE_ADDR + EEPROM_ADDR_BREWTEMP));
setpoint_steam = (*(__IO uint32_t*)(EEPROM_BASE_ADDR + EEPROM_ADDR_STEAMTEMP));
int16_t last_temp = 21245;
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);
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) {
ssd1306_DrawString("Temp: ", 3, 40);
ssd1306_DrawString(" ", 3, 72);
ssd1306_DrawString(tempstr, 3, 72);
ssd1306_drawlogo();
switch(goto_mode) {
case 2:
ssd1306_DrawString("-> brew ", 1, 40);
} break;
case 1:
ssd1306_DrawString("-> setup ", 1, 40);
case 0:
ssd1306_DrawString("-> reset ", 1, 40);
// Button handler
if(SW_BTN_PRESSED) {
state = STATE_PREHEAT_BREW;
break;
state = STATE_SETP;
state = STATE_IDLE;
default:
else if(SW_UP_PRESSED && goto_mode < 2) {
goto_mode++;
else if(SW_DOWN_PRESSED && goto_mode > 0) {
goto_mode--;
// Event Handler
// N/A
case STATE_SETP:
// [ therm :: set p ]
// [ p = 12 ]
ssd1306_DrawString("Proportional", 0, 40);
itoa(k_p, tempstr);
ssd1306_DrawString("P=", 1, 45);
ssd1306_DrawString(" ", 1, 57);
ssd1306_DrawString(tempstr, 1, 57);
ssd1306_DrawString("Press to accept", 3, 40);
state = STATE_SETI;
user_input(&k_p);
case STATE_SETI:
// [ therm :: set i ]
// [ i = 12 ]
ssd1306_DrawString("Integral", 0, 40);
itoa(k_i, tempstr);
ssd1306_DrawString("I=", 1, 45);
@@ -70,225 +70,306 @@ const char fontData[240][5] =
{0x24,0x2A,0x7F,0x2A,0x12}, // ( 4) $ - 0x0024 Dollar Sign
{0x23,0x13,0x08,0x64,0x62}, // ( 5) % - 0x0025 Percent Sign
{0x36,0x49,0x55,0x22,0x50}, // ( 6) & - 0x0026 Ampersand
{0x00,0x05,0x03,0x00,0x00}, // ( 7) ' - 0x0027 Apostrophe
{0x00,0x1C,0x22,0x41,0x00}, // ( 8) ( - 0x0028 Left Parenthesis
{0x00,0x41,0x22,0x1C,0x00}, // ( 9) ) - 0x0029 Right Parenthesis
{0x14,0x08,0x3E,0x08,0x14}, // ( 10) * - 0x002A Asterisk
{0x08,0x08,0x3E,0x08,0x08}, // ( 11) + - 0x002B Plus Sign
{0x00,0x50,0x30,0x00,0x00}, // ( 12) , - 0x002C Comma
{0x08,0x08,0x08,0x08,0x08}, // ( 13) - - 0x002D Hyphen-Minus
{0x00,0x60,0x60,0x00,0x00}, // ( 14) . - 0x002E Full Stop
{0x20,0x10,0x08,0x04,0x02}, // ( 15) / - 0x002F Solidus
{0x3E,0x51,0x49,0x45,0x3E}, // ( 16) 0 - 0x0030 Digit Zero
{0x00,0x42,0x7F,0x40,0x00}, // ( 17) 1 - 0x0031 Digit One
{0x42,0x61,0x51,0x49,0x46}, // ( 18) 2 - 0x0032 Digit Two
{0x21,0x41,0x45,0x4B,0x31}, // ( 19) 3 - 0x0033 Digit Three
{0x18,0x14,0x12,0x7F,0x10}, // ( 20) 4 - 0x0034 Digit Four
{0x27,0x45,0x45,0x45,0x39}, // ( 21) 5 - 0x0035 Digit Five
{0x3C,0x4A,0x49,0x49,0x30}, // ( 22) 6 - 0x0036 Digit Six
{0x01,0x71,0x09,0x05,0x03}, // ( 23) 7 - 0x0037 Digit Seven
{0x36,0x49,0x49,0x49,0x36}, // ( 24) 8 - 0x0038 Digit Eight
{0x06,0x49,0x49,0x29,0x1E}, // ( 25) 9 - 0x0039 Dight Nine
{0x00,0x36,0x36,0x00,0x00}, // ( 26) : - 0x003A Colon
{0x00,0x56,0x36,0x00,0x00}, // ( 27) ; - 0x003B Semicolon
{0x08,0x14,0x22,0x41,0x00}, // ( 28) < - 0x003C Less-Than Sign
{0x14,0x14,0x14,0x14,0x14}, // ( 29) = - 0x003D Equals Sign
{0x00,0x41,0x22,0x14,0x08}, // ( 30) > - 0x003E Greater-Than Sign
{0x02,0x01,0x51,0x09,0x06}, // ( 31) ? - 0x003F Question Mark
{0x32,0x49,0x79,0x41,0x3E}, // ( 32) @ - 0x0040 Commercial At
{0x7E,0x11,0x11,0x11,0x7E}, // ( 33) A - 0x0041 Latin Capital Letter A
{0x7F,0x49,0x49,0x49,0x36}, // ( 34) B - 0x0042 Latin Capital Letter B
{0x3E,0x41,0x41,0x41,0x22}, // ( 35) C - 0x0043 Latin Capital Letter C
{0x7F,0x41,0x41,0x22,0x1C}, // ( 36) D - 0x0044 Latin Capital Letter D
{0x7F,0x49,0x49,0x49,0x41}, // ( 37) E - 0x0045 Latin Capital Letter E
{0x7F,0x09,0x09,0x09,0x01}, // ( 38) F - 0x0046 Latin Capital Letter F
{0x3E,0x41,0x49,0x49,0x7A}, // ( 39) G - 0x0047 Latin Capital Letter G
{0x7F,0x08,0x08,0x08,0x7F}, // ( 40) H - 0x0048 Latin Capital Letter H
{0x00,0x41,0x7F,0x41,0x00}, // ( 41) I - 0x0049 Latin Capital Letter I
{0x20,0x40,0x41,0x3F,0x01}, // ( 42) J - 0x004A Latin Capital Letter J
{0x7F,0x08,0x14,0x22,0x41}, // ( 43) K - 0x004B Latin Capital Letter K
{0x7F,0x40,0x40,0x40,0x40}, // ( 44) L - 0x004C Latin Capital Letter L
{0x7F,0x02,0x0C,0x02,0x7F}, // ( 45) M - 0x004D Latin Capital Letter M
{0x7F,0x04,0x08,0x10,0x7F}, // ( 46) N - 0x004E Latin Capital Letter N
{0x3E,0x41,0x41,0x41,0x3E}, // ( 47) O - 0x004F Latin Capital Letter O
{0x7F,0x09,0x09,0x09,0x06}, // ( 48) P - 0x0050 Latin Capital Letter P
{0x3E,0x41,0x51,0x21,0x5E}, // ( 49) Q - 0x0051 Latin Capital Letter Q
{0x7F,0x09,0x19,0x29,0x46}, // ( 50) R - 0x0052 Latin Capital Letter R
{0x46,0x49,0x49,0x49,0x31}, // ( 51) S - 0x0053 Latin Capital Letter S
{0x01,0x01,0x7F,0x01,0x01}, // ( 52) T - 0x0054 Latin Capital Letter T
{0x3F,0x40,0x40,0x40,0x3F}, // ( 53) U - 0x0055 Latin Capital Letter U
{0x1F,0x20,0x40,0x20,0x1F}, // ( 54) V - 0x0056 Latin Capital Letter V
{0x3F,0x40,0x38,0x40,0x3F}, // ( 55) W - 0x0057 Latin Capital Letter W
{0x63,0x14,0x08,0x14,0x63}, // ( 56) X - 0x0058 Latin Capital Letter X
{0x07,0x08,0x70,0x08,0x07}, // ( 57) Y - 0x0059 Latin Capital Letter Y
{0x61,0x51,0x49,0x45,0x43}, // ( 58) Z - 0x005A Latin Capital Letter Z
{0x00,0x7F,0x41,0x41,0x00}, // ( 59) [ - 0x005B Left Square Bracket
{0x02,0x04,0x08,0x10,0x20}, // ( 60) \ - 0x005C Reverse Solidus
{0x00,0x41,0x41,0x7F,0x00}, // ( 61) ] - 0x005D Right Square Bracket
{0x04,0x02,0x01,0x02,0x04}, // ( 62) ^ - 0x005E Circumflex Accent
{0x40,0x40,0x40,0x40,0x40}, // ( 63) _ - 0x005F Low Line
{0x01,0x02,0x04,0x00,0x00}, // ( 64) ` - 0x0060 Grave Accent
{0x20,0x54,0x54,0x54,0x78}, // ( 65) a - 0x0061 Latin Small Letter A
{0x7F,0x48,0x44,0x44,0x38}, // ( 66) b - 0x0062 Latin Small Letter B
{0x38,0x44,0x44,0x44,0x20}, // ( 67) c - 0x0063 Latin Small Letter C
{0x38,0x44,0x44,0x48,0x7F}, // ( 68) d - 0x0064 Latin Small Letter D
{0x38,0x54,0x54,0x54,0x18}, // ( 69) e - 0x0065 Latin Small Letter E
{0x08,0x7E,0x09,0x01,0x02}, // ( 70) f - 0x0066 Latin Small Letter F
{0x06,0x49,0x49,0x49,0x3F}, // ( 71) g - 0x0067 Latin Small Letter G
{0x7F,0x08,0x04,0x04,0x78}, // ( 72) h - 0x0068 Latin Small Letter H
{0x00,0x44,0x7D,0x40,0x00}, // ( 73) i - 0x0069 Latin Small Letter I
{0x20,0x40,0x44,0x3D,0x00}, // ( 74) j - 0x006A Latin Small Letter J
{0x7F,0x10,0x28,0x44,0x00}, // ( 75) k - 0x006B Latin Small Letter K
{0x00,0x41,0x7F,0x40,0x00}, // ( 76) l - 0x006C Latin Small Letter L
{0x7C,0x04,0x18,0x04,0x7C}, // ( 77) m - 0x006D Latin Small Letter M
{0x7C,0x08,0x04,0x04,0x78}, // ( 78) n - 0x006E Latin Small Letter N
{0x38,0x44,0x44,0x44,0x38}, // ( 79) o - 0x006F Latin Small Letter O
{0x7C,0x14,0x14,0x14,0x08}, // ( 80) p - 0x0070 Latin Small Letter P
{0x08,0x14,0x14,0x18,0x7C}, // ( 81) q - 0x0071 Latin Small Letter Q
{0x7C,0x08,0x04,0x04,0x08}, // ( 82) r - 0x0072 Latin Small Letter R
{0x48,0x54,0x54,0x54,0x20}, // ( 83) s - 0x0073 Latin Small Letter S
{0x04,0x3F,0x44,0x40,0x20}, // ( 84) t - 0x0074 Latin Small Letter T
{0x3C,0x40,0x40,0x20,0x7C}, // ( 85) u - 0x0075 Latin Small Letter U
{0x1C,0x20,0x40,0x20,0x1C}, // ( 86) v - 0x0076 Latin Small Letter V
{0x3C,0x40,0x30,0x40,0x3C}, // ( 87) w - 0x0077 Latin Small Letter W
{0x44,0x28,0x10,0x28,0x44}, // ( 88) x - 0x0078 Latin Small Letter X
{0x0C,0x50,0x50,0x50,0x3C}, // ( 89) y - 0x0079 Latin Small Letter Y
{0x44,0x64,0x54,0x4C,0x44}, // ( 90) z - 0x007A Latin Small Letter Z
{0x00,0x08,0x36,0x41,0x00}, // ( 91) { - 0x007B Left Curly Bracket
{0x00,0x00,0x7F,0x00,0x00}, // ( 92) | - 0x007C Vertical Line
{0x00,0x41,0x36,0x08,0x00}, // ( 93) } - 0x007D Right Curly Bracket
{0x02,0x01,0x02,0x04,0x02}, // ( 94) ~ - 0x007E Tilde
{0x08,0x14,0x2A,0x14,0x22}, // ( 95) << - 0x00AB Left-Pointing Double Angle Quotation Mark
{0x00,0x02,0x05,0x02,0x00}, // ( 96) - 0x00B0 Degree Sign
{0x44,0x44,0x5F,0x44,0x44}, // ( 97) +- - 0x00B1 Plus-Minus Sign
{0x7E,0x20,0x20,0x10,0x3E}, // ( 98) u - 0x00B5 Micro Sign
{0x22,0x14,0x2A,0x14,0x08}, // ( 99) >> - 0x00BB Right-Pointing Double Angle Quotation Mark
{0x30,0x48,0x45,0x40,0x20}, // (100) ? - 0x00BF Inverted Question Mark
{0x22,0x14,0x08,0x14,0x22}, // (101) x - 0x00D7 Multiplcation Sign
{0x08,0x08,0x2A,0x08,0x08}, // (102) + - 0x00F7 Division Sign
{0x18,0x14,0x08,0x14,0x0C}, // (103) - 0x221E Infinity
{0x44,0x4A,0x4A,0x51,0x51}, // (104) < - 0x2264 Less-Than or Equal to
{0x51,0x51,0x4A,0x4A,0x44}, // (105) > - 0x2265 Greater-Than or Equal to
{0x54,0x14,0x64,0x08,0x70}, // (106) .: - RF Symbol
{0x70,0x7C,0x72,0x7C,0x70}, // (107) ^ - Lock symbol
{0x70,0x5C,0x52,0x54,0x70}, // (108) / - Unlock symbol
{0x0C,0x1E,0x3C,0x1E,0x0C}, // (109) <3 - Heart Symbol
{0x18,0x22,0xFF,0x12,0x0C}, // (110) U - USB Symbol
void setStartPage(unsigned char d)
WriteCommand(0xB0|d); // Set Page Start Address for Page Addressing Mode
// Default => 0xB0 (0x00)
/* Below are functions used to configure the OLED */
void setStartColumn(unsigned char d)
WriteCommand(0x00+d%16); // Set Lower Column Start Address for Page Addressing Mode
WriteCommand(0x10+d/16); // Set Higher Column Start Address for Page Addressing Mode
// Default => 0x10
const uint8_t row[4][32] = {
{0x00,0x00,0x01,0x03,0x07,0x0F,0x1E,0x3C,0x3C,0x7C,0x7C,0x7C,0xFC,0xFF,0xFF,0xFC,0xFC,0xFC,0xFC,0xFF,0x7F,0x7F,0x7F,0x3C,0x3C,0x1C,0x0C,0x06,0x03,0x01,0x00,0x00},
{0x0F,0x7F,0xFF,0xFF,0xFF,0xFF,0x00,0x00,0x00,0x00,0x3F,0x3F,0x7F,0xFF,0xFF,0x00,0x00,0x00,0x00,0xFF,0xFF,0xFF,0xFF,0x00,0x00,0x00,0x00,0x00,0xFF,0xFF,0x7F,0x0F},
{0xF0,0xFE,0xFF,0xFF,0xFF,0xC7,0x00,0x00,0x00,0x00,0x87,0xC7,0xC7,0xFF,0xFF,0x00,0x00,0x00,0x00,0x87,0x87,0xC7,0xC3,0x03,0x07,0x07,0x0F,0x7F,0xFF,0xFF,0xFE,0xF0},
{0x00,0x00,0x80,0xC0,0xE0,0xF0,0xF8,0xFC,0xFC,0xFE,0xFE,0xFE,0xFF,0xFF,0xFF,0x1F,0x1F,0x1F,0x1F,0xFF,0xFE,0xFE,0xFE,0xFC,0xFC,0xF8,0xF0,0xE0,0xC0,0x80,0x00,0x00},
void ssd1306_clearscreen()
uint8_t i = 0;
uint8_t page = 0;
for(page = 0; page<4; page++)
setStartPage(page);
setStartColumn(0);
for(i = 0; i<128; i++)
WriteData(0x00);
void ssd1306_drawlogo()
setStartPage(3);
for(i = 0; i<32; i++)
WriteData(row[0][i]);
setStartPage(2);
WriteData(row[1][i]);
setStartPage(1);
WriteData(row[2][i]);
setStartPage(0);
WriteData(row[3][i]);
/* Print a single character from font.cpp */
void ssd1306_DrawChar(char ascii, unsigned char row, unsigned char xPos)
char *srcPointer = 0;
char *srcPointer = -1;
unsigned char i;
srcPointer = &fontData[(ascii-32)][0];
setStartPage(row);
setStartColumn(xPos);
for(i=0;i<5;i++)
WriteData(*srcPointer);
srcPointer++;
void ssd1306_DrawCharBig(char ascii, unsigned char row, unsigned char xPos)
setStartPage(row-1);
// Write first row
uint8_t data = 0;
data |= ((*srcPointer) & 0b1000) << 4; // get top 4 bits
data |= ((*srcPointer) & 0b1000) << 3; // get top 4 bits
data |= ((*srcPointer) & 0b0100) << 3; // get top 4 bits
data |= ((*srcPointer) & 0b0100) << 2; // get top 4 bits
data |= ((*srcPointer) & 0b0010) << 2; // get top 4 bits
data |= ((*srcPointer) & 0b0010) << 1; // get top 4 bits
data |= ((*srcPointer) & 0b0001) << 1; // get top 4 bits
data |= ((*srcPointer) & 0b0001); // get top 4 bits
WriteData(data);
srcPointer -= 5;
// Write second row
data |= (*srcPointer) & 0b10000000; // get top 4 bits
data |= ((*srcPointer) & 0b10000000) >> 1; // get top 4 bits
data |= ((*srcPointer) & 0b01000000) >> 1; // get top 4 bits
data |= ((*srcPointer) & 0b01000000) >> 2; // get top 4 bits
data |= ((*srcPointer) & 0b00100000) >> 2; // get top 4 bits
data |= ((*srcPointer) & 0b00100000) >> 3; // get top 4 bits
data |= ((*srcPointer) & 0b00010000) >> 3; // get top 4 bits
data |= ((*srcPointer) & 0b00010000) >> 4; // get top 4 bits
void ssd1306_DrawString(const char *dataPtr, unsigned char row, unsigned char xPos)
char *srcPointer;
srcPointer = (char*)dataPtr;
ssd1306_DrawChar(' ',row,xPos); // NBSP must be written first before the string start
ssd1306_DrawChar(*srcPointer,row,xPos);
xPos+=6;
if(*srcPointer == 0) break;
void ssd1306_DrawStringBig(const char *dataPtr, unsigned char row, unsigned char xPos)
ssd1306_DrawCharBig(' ',row,xPos); // NBSP must be written first before the string start
ssd1306_DrawCharBig(*srcPointer,row,xPos);
xPos+=12;
// vim:softtabstop=4 shiftwidth=4 expandtab
#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_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)
// 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);
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
Status change: