#include "main.h"
#include "stm32l100c_discovery.h"
#include "ssd1306.h"
// USB includes
#include "hw_config.h"
#include "usb_lib.h"
#include "usb_desc.h"
#include "usb_pwr.h"
#define LED_POWER GPIOB,GPIO_Pin_9
#define LED_STAT GPIOA,GPIO_Pin_15
#define MAX_CS GPIOB,GPIO_Pin_12
// TODO: Grab buttonpresses with interrupts
#define SW_BTN GPIOB, GPIO_Pin_3
#define SW_UP GPIOB, GPIO_Pin_7
#define SW_DOWN GPIOB, GPIO_Pin_6
#define SW_LEFT GPIOB, GPIO_Pin_5
#define SW_RIGHT GPIOB, GPIO_Pin_4
// 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;
char* itoa(int16_t i, char b[]){
char const digit[] = "0123456789";
char* p = b;
if(i<0){
*p++ = '-';
i *= -1;
}
uint16_t shifter = i;
do{ //Move to where representation ends
++p;
shifter = shifter/10;
}while(shifter);
*p = '\0';
do{ //Move back, inserting digits as you go
*--p = digit[i%10];
i = i/10;
}while(i);
return b;
char* itoa_fp(int16_t i, uint8_t frac, char b[]){
// set p to beginning of char array
// If negative, set current char to '-' and inc, unnegate number
// Init shifter to numeric value
uint16_t frac_shifter = frac;
// Iterate through 10s places, incrementing text pointer as we go
do{
++p; // increment for decimal point
frac_shifter = frac_shifter/10;
}while(frac_shifter);
// Null-terminate the string
// Go backwards and write out fractional digits
*--p = digit[frac%10];
frac = frac/10;
}while(frac);
*--p = '.'; // insert decimal point
// Go backwards and write out remaining digits
static __IO uint32_t TimingDelay;
// Move to header file
void init_gpio();
void init_spi();
void process();
void machine();
int main(void)
{
// Init clocks
SystemInit();
init_gpio();
// Init USB
//Set_USBClock();
//USB_Interrupts_Config();
//USB_Init();
GPIO_SetBits(LED_POWER);
RCC_ClocksTypeDef RCC_Clocks;
// SysTick end of count event each 1ms
RCC_GetClocksFreq(&RCC_Clocks);
SysTick_Config(RCC_Clocks.HCLK_Frequency / 1000);
GPIO_ResetBits(LED_STAT);
Delay(100);
Delay(500);
GPIO_ResetBits(LED_POWER);
init_spi();
ssd1306_Init();
ssd1306_block_write();
ssd1306_DrawString("therm 0.1", 0, 40);
ssd1306_DrawString("Status: Idle", 2, 40);
// ssd1306_block_write();
ssd1306_test();
uint8_t toggle = 0;
int16_t temp = -231;
while(1)
//ssd1306_block_write();
// Process sensor inputs [TODO: 5hz?]
process();
// Run state machine [TODO: 50hz?]
machine();
// probably just passed the actual port
uint8_t sw_btn = GPIO_ReadInputDataBit(SW_BTN);
//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);
if(!sw_btn) {
GPIO_ToggleBits(LED_STAT);
if(!toggle) {
GPIO_SetBits(GPIOB, GPIO_Pin_13);
toggle = ! toggle;
else {
GPIO_ResetBits(GPIOB, GPIO_Pin_13);
Delay(50);
int32_t temp = 0;
int32_t setpoint = 0;
int32_t p = 1;
int32_t i = 1;
int32_t d = 1;
// Process things
void process()
// 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", 3, 35);
else if(temp_pre & 0b0000000000000001) {
ssd1306_DrawString("TC Fault", 3, 35);
ssd1306_DrawString("TempSense OK", 3, 35);
uint8_t sign = temp >> 15;// top bit is sign
temp_pre = temp_pre >> 2; // Drop 2 lowest bits
uint8_t frac = temp_pre & 0b11; // get fractional part
frac *= 25; // each bit is .25 a degree, up to fixed point
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;
temp = temp_pre;
// Deassert CS
GPIO_SetBits(MAX_CS);
if(temp > 0) {
GPIO_SetBits(LED_STAT);
char tempstr[9];
itoa(temp_pre, tempstr);
ssd1306_DrawString("Temp: ", 1, 40);
ssd1306_DrawString(" ", 1, 70);
ssd1306_DrawString(tempstr, 1, 70);
itoa(frac, tempstr);
ssd1306_DrawString(" ", 1, 90);
ssd1306_DrawString(tempstr, 1, 90);
update_temp(); // Read MAX31855
// TODO: Add calibration offset (linear)
// Perform PID calculations
//if(
// Write output to SSR
enum state {
STATE_IDLE = 0,
STATE_SETP,
STATE_SETI,
STATE_SETD,
STATE_PREHEAT_BREW,
STATE_MAINTAIN_BREW,
STATE_PREHEAT_STEAM,
STATE_MAINTAIN_STEAM,
};
uint8_t state = STATE_IDLE;
// State machine
void machine()
uint8_t last_state = state;
switch(state)
// Idle state
case STATE_IDLE:
// Write text to OLED
// [ therm :: idle ]
ssd1306_DrawString("therm :: idle ", 0, 40);
ssd1306_drawlogo();
itoa_fp(temp, temp_frac, tempstr);
ssd1306_DrawString("Temp: ", 2, 40);
ssd1306_DrawString(" ", 2, 70);
ssd1306_DrawString(tempstr, 2, 72);
// Button handler
if(!GPIO_ReadInputDataBit(SW_BTN)) {
state = STATE_SETP;
// Event Handler
// N/A
} break;
case STATE_SETP:
// [ therm :: set p ]
// [ p = 12 ]
ssd1306_DrawString("therm :: set p", 0, 40);
state = STATE_SETI;
case STATE_SETI:
// [ therm :: set i ]
// [ i = 12 ]
ssd1306_DrawString("therm :: set i", 0, 40);
state = STATE_SETD;
case STATE_SETD:
// [ therm :: set d ]
// [ d = 12 ]
ssd1306_DrawString("therm :: set d", 0, 40);
state = STATE_IDLE;
case STATE_PREHEAT_BREW:
// [ therm : preheating brew ]
// [ 30 => 120 C ]
ssd1306_DrawString("therm :: Bpreheat", 0, 40);
if(temp >= setpoint) {
state = STATE_MAINTAIN_BREW;
case STATE_MAINTAIN_BREW:
// [ therm : ready to brew ]
ssd1306_DrawString("therm :: Bready", 0, 40);
case STATE_PREHEAT_STEAM:
// [ therm : preheating steam ]
ssd1306_DrawString("therm :: Spreheat", 0, 40);
state = STATE_MAINTAIN_STEAM;
case STATE_MAINTAIN_STEAM:
// [ therm : ready to steam ]
ssd1306_DrawString("therm :: Sready", 0, 40);
// Something is terribly wrong
default:
ssd1306_DrawString("therm :: BAD BAD", 0, 40);
if(last_state != state) {
// Clear screen on state change
/**
* @brief Inserts a delay time.
* @param nTime: specifies the delay time length, in 1 ms.
* @retval None
*/
void Delay(__IO uint32_t nTime)
TimingDelay = nTime;
while(TimingDelay != 0);
* @brief Decrements the TimingDelay variable.
* @param None
void TimingDelay_Decrement(void)
if (TimingDelay != 0x00)
TimingDelay--;
void init_spi(void)
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;
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_4;
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
SPI_InitStructure.SPI_CRCPolynomial = 7;
SPI_Init(SPI1, &SPI_InitStructure);
SPI_Cmd(SPI1, ENABLE); /* Enable the SPI */
// MAX IC
SPI_Cmd(SPI2, DISABLE);
SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
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_BaudRatePrescaler = SPI_BaudRatePrescaler_8;
SPI_Init(SPI2, &SPI_InitStructure);
SPI_Cmd(SPI2, ENABLE); /* Enable the SPI */
void init_gpio(void) {
GPIO_InitTypeDef GPIO_InitStruct;
// Enable SPI clocks
RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE);
// Enable GPIO clocks
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOC|RCC_AHBPeriph_GPIOB|RCC_AHBPeriph_GPIOA, ENABLE);
// Enable DMA clocks (Is AHB even the right thing???)
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE); // EMZ TODO get the right ones
/*Configure GPIO pin : PC */
GPIO_InitStruct.GPIO_Pin = GPIO_Pin_13;
GPIO_InitStruct.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;
GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_InitStruct.GPIO_Speed = GPIO_Speed_400KHz;
GPIO_Init(GPIOC, &GPIO_InitStruct);
/*Configure GPIO pin : PB */
GPIO_InitStruct.GPIO_Pin = GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_10|GPIO_Pin_12
|GPIO_Pin_9;
GPIO_Init(GPIOB, &GPIO_InitStruct);
/*Configure GPIO pin : PA */
GPIO_InitStruct.GPIO_Pin = GPIO_Pin_15;
GPIO_Init(GPIOA, &GPIO_InitStruct);
GPIO_InitStruct.GPIO_Pin = GPIO_Pin_3|GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6
|GPIO_Pin_7;
GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN;
GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_UP;
/** SPI1 GPIO Configuration
PA5 ------> SPI1_SCK
PA7 ------> SPI1_MOSI
/*Enable or disable the AHB peripheral clock */
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA, ENABLE);
/*Configure GPIO pin : PA: MOSI,SCK */
GPIO_InitStruct.GPIO_Pin = GPIO_Pin_5|GPIO_Pin_7;
GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStruct.GPIO_Speed = GPIO_Speed_10MHz;
/*Configure GPIO pin alternate function */
GPIO_PinAFConfig(GPIOA, GPIO_PinSource5, GPIO_AF_SPI1);
GPIO_PinAFConfig(GPIOA, GPIO_PinSource7, GPIO_AF_SPI1);
/** SPI2 GPIO Configuration
PB13 ------> SPI2_SCK
PB14 ------> SPI2_MISO
PB15 ------> SPI2_MOSI
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB, ENABLE);
// SPI PINSSS
/*Configure GPIO pin : PB, MOSI, SCK */
GPIO_InitStruct.GPIO_Pin = GPIO_Pin_13|GPIO_Pin_15;
GPIO_InitTypeDef GPIO_InitStruct2;
// MISO
GPIO_InitStruct2.GPIO_Pin = GPIO_Pin_14;
GPIO_InitStruct2.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStruct2.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_InitStruct2.GPIO_Speed = GPIO_Speed_10MHz;
GPIO_Init(GPIOB, &GPIO_InitStruct2);
//Configure GPIO pin alternate function
GPIO_PinAFConfig(GPIOB, GPIO_PinSource13, GPIO_AF_SPI2);
GPIO_PinAFConfig(GPIOB, GPIO_PinSource14, GPIO_AF_SPI2);
GPIO_PinAFConfig(GPIOB, GPIO_PinSource15, GPIO_AF_SPI2);
/** USB GPIO Configuration
PA11 ------> USB_DM
PA12 ------> USB_DP
GPIO_InitStruct.GPIO_Pin = GPIO_Pin_11|GPIO_Pin_12;
// vim:softtabstop=4 shiftwidth=4 expandtab
@@ -271,455 +271,455 @@ void OnPageTransferDone(void)
if(pageIndex == 0){
WriteCommand(0x00);
WriteCommand(0x10);
SSD_A0_High();
DMA1_Channel5->CCR &= ((uint32_t)0xFFFFFFFE);
DMA1_Channel5->CNDTR = ssd1306_COLUMN_NUMBER+SSD1306_COLUMN_MARGIN_START + SSD1306_COLUMN_MARGIN_END;
DMA1_Channel5->CMAR = (uint32_t)(ssd1306_Buffer+SSD1306_COLUMN_NUMBER*pageIndex - SSD1306_COLUMN_MARGIN_START);
DMA_SSD_1306->CCR |= ((uint32_t)0x00000001);
pageIndex++;
#else
DMA_SSD_1306->CCR &= ((uint32_t)0xFFFFFFFE);
DMA_SSD_1306->CNDTR = SSD1306_COLUMN_NUMBER*SSD1306_PAGE_NUMBER;//+SSD1306_COLUMN_MARGIN_START + SSD1306_COLUMN_MARGIN_END;
DMA_SSD_1306->CMAR = (uint32_t)(ssd1306_Buffer);//+SSD1306_COLUMN_NUMBER*pageIndex);
//DMA_Cmd(DMA_SSD_1306, ENABLE);
// pageIndex++;
pageIndex = SSD1306_PAGE_NUMBER;
#endif
/*******************************************************************************
* Function Name : DMA1_Channel5_IRQHandler
* Description : This function handles DMA1 Channel 5 interrupt request.
* Input : None
* Output : None
* Return : None
*******************************************************************************/
void DMA_Handler_SSD_1306(void) //DMA1_Channel5_IRQHandler(void)
if(DMA_GetITStatus(DMA1_IT_TC5)){
DMA_ClearITPendingBit(DMA1_IT_GL5);
OnPageTransferDone();
* Function Name : StartPageTransfer
* Description : Start a new page transfer
void StartPageTransfer(void)
pageIndex = 0;
if(pre_on){
if(iS_SSD_On == 0){
pre_on = ssd1306_ON();
}else{
if(iS_SSD_On){
pre_on = ssd1306_OFF();
if( curContrast != lastContrast ){
lastContrast = curContrast;
WriteCommand(0x81); /* Set Contrast Control */
WriteCommand(lastContrast); /* 0 ~ 255 0x1f*/
Display related functions
******************************************************************************/
* Function Name : ssd1306_DrawBlock
* Description : Draw a block with specify data to ssd1306
unsigned long ssd1306_DrawBlock(
Pos_t x,
Pos_t y,
Pos_t cx,
Pos_t cy,
const unsigned char* data)
if(x >= SSD1306_X_PIXEL)return 0;
if(y >= SSD1306_Y_PIXEL)return 0;
if(x+cx > SSD1306_X_PIXEL ) cx = SSD1306_X_PIXEL - x ;
if(y+cy > SSD1306_Y_PIXEL ) cy = SSD1306_Y_PIXEL - y ;
unsigned char* pStart = ssd1306_Buffer + (y/8)*SSD1306_COLUMN_NUMBER + x;
unsigned char offset1 = y%8;
unsigned char offset2 = (cy+y)%8;
if(data){
unsigned char mask1 = (1<<offset1)-1;
unsigned char mask2 = ~((1<<offset2)-1);
cy = (cy+offset1)/8;
Pos_t i = 0;
for(i=0;i<cx;i++){
Pos_t j = 0;
unsigned short tmp = *pStart & mask1;
for(;j<cy;j++){
tmp |= (((unsigned short)data[j*cx])<<offset1);
*(pStart + j*SSD1306_COLUMN_NUMBER) = tmp;
tmp>>=8;
if(offset2){
tmp |= ((((unsigned short)data[j*cx])<<offset1) & (~mask2))
| *(pStart + j*SSD1306_COLUMN_NUMBER) & mask2;
data++;
pStart++;
unsigned char mask1 = ~((1<<offset1)-1);
unsigned char mask2 = ((1<<offset2)-1);
Pos_t j = 1;
*pStart ^= mask1;
*(pStart + j*SSD1306_COLUMN_NUMBER) ^= 0xFF;
*(pStart + j*SSD1306_COLUMN_NUMBER) ^= mask2;
// if(!offset){
// for(Pos_t i=0;i<cx;i++){
// unsigned char tmp;
// Pos_t j = 0;
// for(;j<cy/8;j++){
// tmp = data[i+j*cx];
// *(pStart + j*ssd1306_COLUMN_NUMBER + i + x) = tmp;
// }
// if(cy&0x7){
// unsigned char mask1 = (1<<(cy&7)) - 1;
// unsigned char mask2 = 0xFF - mask1;
// tmp = (data[i+j*cx] & mask1)
// | (*(pStart + j*ssd1306_COLUMN_NUMBER + i + x) & mask2);
// }else{
// unsigned short tmp;
// for(Pos_t j=0;j<cy/8;j++){
// if(j == 0){
// // First line
// tmp = *(pStart + j*ssd1306_COLUMN_NUMBER + i + x) & mask;
// tmp |= (((unsigned short)data[i+j*cx])<<offset);
// tmp>>=8;
// if(j == (cy/8)-1){
// // Last line
// *(pStart + (j+1)*ssd1306_COLUMN_NUMBER + i + x) &= ~mask;
// *(pStart + (j+1)*ssd1306_COLUMN_NUMBER + i + x) |= tmp;
return 0;
* Function Name : ssd1306_DrawPoint
* Description : Draw a point with specify data to ssd1306
unsigned long ssd1306_DrawPoint(
Color_t color)
unsigned char mask = 1<<(y%8);
if(color){
*pStart |= mask;
*pStart &= ~mask;
* Function Name : ssd1306_ReadPoint
* Description : Read a point from ssd1306
unsigned long ssd1306_ReadPoint(
Pos_t y)
return *pStart&mask ? 1 : 0;
* Function Name : ssd1306_ClearScreen
* Description : Clear the screen contents
void ssd1306_FillScreen(Color_t color)
unsigned char mask = color ? 0xFF : 0;
unsigned long i = 0;
for(i=0;i<SSD1306_COLUMN_NUMBER*SSD1306_PAGE_NUMBER;i++){
ssd1306_Buffer[i] = mask;
const DeviceProp ssd1306_Prop =
.pfnDrawBlok = ssd1306_DrawBlock,
.pfnDrawPoint = ssd1306_DrawPoint,
.xPixel = 128,
.yPixel = 64,
// Times New Roman font
const char fontData[240][5] =
{ // Refer to "Times New Roman" Font Database
// Basic Characters
{0x00,0x00,0x00,0x00,0x00}, // ( 0) - 0x0020 No-Break Space
{0x00,0x00,0x4F,0x00,0x00}, // ( 1) ! - 0x0021 Exclamation Mark
{0x00,0x07,0x00,0x07,0x00}, // ( 2) " - 0x0022 Quotation Mark
{0x14,0x7F,0x14,0x7F,0x14}, // ( 3) # - 0x0023 Number Sign
{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_test()
void ssd1306_drawlogo()
uint8_t i = 0;
setStartPage(3);
setStartColumn(0);
for(i = 0; i<32; i++)
WriteData(row[0][i]);
WriteData(0x00);
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;
unsigned char i;
srcPointer = &fontData[(ascii-32)][0];
setStartPage(row);
setStartColumn(xPos);
for(i=0;i<5;i++)
WriteData(*srcPointer);
srcPointer++;
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;
#ifndef ssd1306_H
#define ssd1306_H
typedef unsigned long Pos_t;
typedef unsigned long Size_t;
typedef unsigned long Color_t;
typedef unsigned long (*pfnDrawBlock_t)(
const unsigned char* data);
typedef unsigned long (*pfnDrawPoint_t)(Pos_t x, Pos_t y, Color_t color);
typedef unsigned long(*pfnFontDrawChar)(pfnDrawBlock_t DrawBlock,Pos_t x, Pos_t y, unsigned int ch);
typedef struct _DeviceProp
pfnDrawBlock_t pfnDrawBlok;
pfnDrawPoint_t pfnDrawPoint;
Size_t xPixel;
Size_t yPixel;
}DeviceProp;
typedef struct _Device
const DeviceProp* pDevProp;
pfnFontDrawChar pfnFont;
Pos_t curX;
Pos_t curY;
}Device;
void ssd1306_Init(void);
void StartPageTransfer(void);
extern const DeviceProp ssd1306_Prop;
unsigned long ssd1306_DrawBlock(Pos_t x, Pos_t y, Pos_t cx, Pos_t cy, const unsigned char* data);
unsigned long ssd1306_IsOn(void);
unsigned long ssd1306_TurnOff(void);
unsigned long ssd1306_TurnOn(void);
unsigned char ssd1306_SetContrast(unsigned char contrast);
unsigned char ssd1306_GetContrast();
unsigned char* ssd1306_GetBuffer();
unsigned long ssd1306_DrawPoint(Pos_t x, Pos_t y, Color_t color);
void ssd1306_block_write(void);
void ssd1306_DrawChar(char ascii, unsigned char row, unsigned char xPos);
void ssd1306_DrawString(const char *dataPtr, unsigned char row, unsigned char xPos);
void ssd1306_test();
void ssd1306_drawlogo();
Status change: