therm Changeset - c5a349beceeb · protofusion repositories

Changeset - c5a349beceeb

Parent rev.

Child rev.

[Not reviewed]

default

0 4 1

Ethan Zonca - 10 years ago 2014-08-18 22:35:31
ez@ethanzonca.com

OLED display now works, randomly writes the letter H now.

5 files changed with 719 insertions and 54 deletions:

main.c

smallfonts.c

554

ssd1306.c

130

stm32l1xx_it.c

system_stm32l1xx.c

0 comments (0 inline, 0 general)

main.c

➞

Show inline comments

 #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
-/* Extern variables ----------------------------------------------------------*/
+// 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;
 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();
     Set_USBClock();
     USB_Interrupts_Config();
     USB_Init();
     // Init USB
     //Set_USBClock();
     //USB_Interrupts_Config();
     //USB_Init();
     GPIO_SetBits(LED_POWER);
     USB_Init(); // freezes here... maybe clock issue?
     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);
     GPIO_SetBits(LED_POWER);
     Delay(500);
     GPIO_ResetBits(LED_POWER);
     init_spi();
     ssd1306_Init();
     ssd1306_DrawPoint(0,0,1);
     ssd1306_DrawPoint(0,1,1);
     ssd1306_DrawPoint(0,2,1);
     ssd1306_DrawPoint(0,3,1);
     ssd1306_DrawPoint(0,4,1);
     ssd1306_DrawPoint(0,5,1);
     ssd1306_DrawPoint(0,6,1);
     ssd1306_DrawPoint(1,3,1);
     ssd1306_DrawPoint(2,3,1);
     ssd1306_DrawPoint(3,3,1);
     ssd1306_DrawPoint(5,5,0);
     ssd1306_DrawPoint(4,3,1);
     ssd1306_DrawPoint(5,0,1);
     ssd1306_DrawPoint(5,1,1);
     ssd1306_DrawPoint(5,2,1);
     ssd1306_DrawPoint(5,3,1);
     ssd1306_DrawPoint(5,4,1);
     ssd1306_DrawPoint(5,5,1);
     ssd1306_DrawPoint(5,6,1);
     ssd1306_block_write();
     while(1)
+   {
         ssd1306_block_write();
+        //ssd1306_block_write();
         // Process sensor inputs [TODO: 5hz?]
         process();
         // Run state machine [TODO: 50hz?]
         machine();
         // probably just passed the actual port
         // TODO: Grab buttonpresses with interrupts
         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);
 //        SPI_I2S_SendData(SPI2,0xFA);
 //        SPI_I2S_SendData(SPI1,0xFA);
         if(!GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_3)) {
         if(!sw_btn) {
             GPIO_ToggleBits(LED_STAT);
             ssd1306_block_write();
+        }
         GPIO_SetBits(LED_POWER);
         Delay(50);
         GPIO_ResetBits(LED_POWER);
         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 MAX temp sensor
     GPIO_ResetBits(MAX_CS);
     // Assert CS
     // This may not clock at all... might need to send 16 bits first
     uint8_t retval = 0;//SPI_I2S_ReceiveData(SPI2);
     // Deassert CS
     GPIO_SetBits(MAX_CS);
     if((!retval || (temp & 0x2) != 0))
         return; // Comms error - this is happening right now
     if((temp & 0x4)!= 0)
         return; // Open thermocouple
     temp = (temp & 0x7FF8) >> 5;
     // TODO: Add calibration offset (linear)
     // Perform PID calculations
     // 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()
+{
     switch(state)
+    {
         // Idle state
         case STATE_IDLE:
+        {
             // Write text to OLED
             // [ therm :: idle ]
             // Button handler
             if(GPIO_ReadInputDataBit(SW_BTN)) {
                 state = STATE_SETP;
+            }
             // Event Handler
             // N/A
         } break;
         case STATE_SETP:
+        {
             // Write text to OLED
             // [ therm :: set p ]
             // [ p = 12         ]
             // Button handler
             if(GPIO_ReadInputDataBit(SW_BTN)) {
                 state = STATE_IDLE;
+            }
@@ @@ -249,193 +271,193 @@ void machine() @@
             // [ 30 => 120 C           ]
             // Button handler
             if(GPIO_ReadInputDataBit(SW_BTN)) {
                 state = STATE_IDLE;
+            }
             // Event Handler
             // N/A
         } break;
         case STATE_PREHEAT_STEAM:
+        {
             // Write text to OLED
             // [ therm : preheating steam ]
             // [ 30 => 120 C           ]
             // Button handler
             if(GPIO_ReadInputDataBit(SW_BTN)) {
                 state = STATE_IDLE;
+            }
             // Event Handler
             if(temp >= setpoint) {
                 state = STATE_MAINTAIN_STEAM;
+            }
         } break;
         case STATE_MAINTAIN_STEAM:
+        {
             // Write text to OLED
             // [ therm : ready to steam ]
             // [ 30 => 120 C            ]
             // Button handler
             if(GPIO_ReadInputDataBit(SW_BTN)) {
                 state = STATE_IDLE;
+            }
             // Event Handler
             // N/A
         } break;
         // Something is terribly wrong
         default:
+        {
             state = STATE_IDLE;
         } break;
+    }
+}
 /**
   * @brief  Inserts a delay time.
   * @param  nTime: specifies the delay time length, in 1 ms.
   * @retval None
   */
 void Delay(__IO uint32_t nTime)
+{
   TimingDelay = nTime;
   while(TimingDelay != 0);
+}
 /**
   * @brief  Decrements the TimingDelay variable.
   * @param  None
   * @retval None
   */
 void TimingDelay_Decrement(void)
+{
   if (TimingDelay != 0x00)
+  {
     TimingDelay--;
+  }
+}
 void init_spi(void)
+{
     SPI_InitTypeDef  SPI_InitStructure;
     // OLED IC
     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_64;
+    SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_16;
     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_InitStructure.SPI_Direction = SPI_Direction_1Line_Rx;
     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
     // Can be used for CS... SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
     SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_64;
     //SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
     //SPI_InitStructure.SPI_CRCPolynomial = 7;
     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_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(GPIOB, &GPIO_InitStruct);
   /*Configure GPIO pin : PA */
   GPIO_InitStruct.GPIO_Pin = GPIO_Pin_15;
   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(GPIOA, &GPIO_InitStruct);
   /*Configure GPIO pin : PB */
   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;
   GPIO_Init(GPIOB, &GPIO_InitStruct);
   /** 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_PuPd = GPIO_PuPd_NOPULL;
   GPIO_InitStruct.GPIO_Speed = GPIO_Speed_10MHz;
   GPIO_Init(GPIOA, &GPIO_InitStruct);
   /*Configure GPIO pin alternate function */
   GPIO_PinAFConfig(GPIOA, GPIO_PinSource5, GPIO_AF_SPI1);
   /*Configure GPIO pin alternate function */
   GPIO_PinAFConfig(GPIOA, GPIO_PinSource7, GPIO_AF_SPI1);
   /** SPI2 GPIO Configuration
   PB13   ------> SPI2_SCK
   PB14   ------> SPI2_MISO
   PB15   ------> SPI2_MOSI
   */
   /*Enable or disable the AHB peripheral clock */
   RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB, ENABLE);

smallfonts.c

➞

Show inline comments

@@ new file 100644 @@
 /* Partially based on original code for the KS0108 by Stephane Rey */
 /*
     @file     smallfonts.c
     @author   K. Townsend (microBuilder.eu)
     @date     22 March 2010
     @version  0.10
     @section LICENSE
     Software License Agreement (BSD License)
     Copyright (c) 2010, microBuilder SARL
     All rights reserved.
     Redistribution and use in source and binary forms, with or without
     modification, are permitted provided that the following conditions are met:
 . Redistributions of source code must retain the above copyright
     notice, this list of conditions and the following disclaimer.
 . Redistributions in binary form must reproduce the above copyright
     notice, this list of conditions and the following disclaimer in the
     documentation and/or other materials provided with the distribution.
 . Neither the name of the copyright holders nor the
     names of its contributors may be used to endorse or promote products
     derived from this software without specific prior written permission.
     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ''AS IS'' AND ANY
     EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER 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.
 */
 #include "nil.h"
 #include "smallfonts.h"
 /* Global variables */
 const struct FONT_DEF Font_System3x6    = {3, 6, 32, 96,  au8FontSystem3x6};
 const struct FONT_DEF Font_System5x8    = {5, 8, 32, 128, au8FontSystem5x8};
 const struct FONT_DEF Font_System7x8    = {7, 8, 32, 128, au8FontSystem7x8};
 const struct FONT_DEF Font_8x8          = {8, 8, 32, 128, au8Font8x8};
 const struct FONT_DEF Font_8x8Thin      = {8, 8, 32, 128, au8Font8x8Thin};
 /* System 3x6 - UPPER CASE ONLY */
 const uint8_t au8FontSystem3x6[]= {
 x00,0x00,0x00, /* Space */
 x00,0x5C,0x00, /* ! */
 x0C,0x00,0x0C, /* " */
 x7C,0x28,0x7C, /* # */
 x7C,0x44,0x7C, /* 0x */
 x24,0x10,0x48, /* % */
 x28,0x54,0x08, /* & */
 x00,0x0C,0x00, /* ' */
 x38,0x44,0x00, /* ( */
 x44,0x38,0x00, /* ) */
 x20,0x10,0x08, /* // */
 x10,0x38,0x10, /* + */
 x80,0x40,0x00, /* , */
 x10,0x10,0x10, /* - */
 x00,0x40,0x00, /* . */
 x20,0x10,0x08, /* / */
 x38,0x44,0x38, /* 0 */
 x00,0x7C,0x00, /* 1 */
 x64,0x54,0x48, /* 2 */
 x44,0x54,0x28, /* 3 */
 x1C,0x10,0x7C, /* 4 */
 x4C,0x54,0x24, /* 5 */
 x38,0x54,0x20, /* 6 */
 x04,0x74,0x0C, /* 7 */
 x28,0x54,0x28, /* 8 */
 x08,0x54,0x38, /* 9 */
 x00,0x50,0x00, /* : */
 x80,0x50,0x00, /* ; */
 x10,0x28,0x44, /* < */
 x28,0x28,0x28, /* = */
 x44,0x28,0x10, /* > */
 x04,0x54,0x08, /* ? */
 x38,0x4C,0x5C, /* @ */
 x78,0x14,0x78, /* A */
 x7C,0x54,0x28, /* B */
 x38,0x44,0x44, /* C */
 x7C,0x44,0x38, /* D */
 x7C,0x54,0x44, /* E */
 x7C,0x14,0x04, /* F */
 x38,0x44,0x34, /* G */
 x7C,0x10,0x7C, /* H */
 x00,0x7C,0x00, /* I */
 x20,0x40,0x3C, /* J */
 x7C,0x10,0x6C, /* K */
 x7C,0x40,0x40, /* L */
 x7C,0x08,0x7C, /* M */
 x7C,0x04,0x7C, /* N */
 x7C,0x44,0x7C, /* O */
 x7C,0x14,0x08, /* P */
 x38,0x44,0x78, /* Q */
 x7C,0x14,0x68, /* R */
 x48,0x54,0x24, /* S */
 x04,0x7C,0x04, /* T */
 x7C,0x40,0x7C, /* U */
 x3C,0x40,0x3C, /* V */
 x7C,0x20,0x7C, /* W */
 x6C,0x10,0x6C, /* X */
 x1C,0x60,0x1C, /* Y */
 x64,0x54,0x4C, /* Z */
 x7C,0x44,0x00, /* [ */
 x08,0x10,0x20, /* \ */
 x44,0x7C,0x00, /* ] */
 x08,0x04,0x08, /* ^ */
 x80,0x80,0x80, /* _ */
 x04,0x08,0x00  /* ` */
 };
 /* System 5x8 */
 const uint8_t au8FontSystem5x8[]=
+{
 x00,0x00,0x00,0x00,0x00, /* Space */
 x00,0x00,0x4f,0x00,0x00, /* ! */
 x00,0x07,0x00,0x07,0x00, /* " */
 x14,0x7f,0x14,0x7f,0x14, /* # */
 x24,0x2a,0x7f,0x2a,0x12, /* 0x */
 x23,0x13,0x08,0x64,0x62, /* % */
 x36,0x49,0x55,0x22,0x20, /* & */
 x00,0x05,0x03,0x00,0x00, /* ' */
 x00,0x1c,0x22,0x41,0x00, /* ( */
 x00,0x41,0x22,0x1c,0x00, /* ) */
 x14,0x08,0x3e,0x08,0x14, /* // */
 x08,0x08,0x3e,0x08,0x08, /* + */
 x50,0x30,0x00,0x00,0x00, /* , */
 x08,0x08,0x08,0x08,0x08, /* - */
 x00,0x60,0x60,0x00,0x00, /* . */
 x20,0x10,0x08,0x04,0x02, /* / */
 x3e,0x51,0x49,0x45,0x3e, /* 0 */
 x00,0x42,0x7f,0x40,0x00, /* 1 */
 x42,0x61,0x51,0x49,0x46, /* 2 */
 x21,0x41,0x45,0x4b,0x31, /* 3 */
 x18,0x14,0x12,0x7f,0x10, /* 4 */
 x27,0x45,0x45,0x45,0x39, /* 5 */
 x3c,0x4a,0x49,0x49,0x30, /* 6 */
 x01,0x71,0x09,0x05,0x03, /* 7 */
 x36,0x49,0x49,0x49,0x36, /* 8 */
 x06,0x49,0x49,0x29,0x1e, /* 9 */
 x00,0x36,0x36,0x00,0x00, /* : */
 x00,0x56,0x36,0x00,0x00, /* ; */
 x08,0x14,0x22,0x41,0x00, /* < */
 x14,0x14,0x14,0x14,0x14, /* = */
 x00,0x41,0x22,0x14,0x08, /* > */
 x02,0x01,0x51,0x09,0x06, /* ? */
 x3e,0x41,0x5d,0x55,0x1e, /* @ */
 x7e,0x11,0x11,0x11,0x7e, /* A */
 x7f,0x49,0x49,0x49,0x36, /* B */
 x3e,0x41,0x41,0x41,0x22, /* C */
 x7f,0x41,0x41,0x22,0x1c, /* D */
 x7f,0x49,0x49,0x49,0x41, /* E */
 x7f,0x09,0x09,0x09,0x01, /* F */
 x3e,0x41,0x49,0x49,0x7a, /* G */
 x7f,0x08,0x08,0x08,0x7f, /* H */
 x00,0x41,0x7f,0x41,0x00, /* I */
 x20,0x40,0x41,0x3f,0x01, /* J */
 x7f,0x08,0x14,0x22,0x41, /* K */
 x7f,0x40,0x40,0x40,0x40, /* L */
 x7f,0x02,0x0c,0x02,0x7f, /* M */
 x7f,0x04,0x08,0x10,0x7f, /* N */
 x3e,0x41,0x41,0x41,0x3e, /* O */
 x7f,0x09,0x09,0x09,0x06, /* P */
 x3e,0x41,0x51,0x21,0x5e, /* Q */
 x7f,0x09,0x19,0x29,0x46, /* R */
 x26,0x49,0x49,0x49,0x32, /* S */
 x01,0x01,0x7f,0x01,0x01, /* T */
 x3f,0x40,0x40,0x40,0x3f, /* U */
 x1f,0x20,0x40,0x20,0x1f, /* V */
 x3f,0x40,0x38,0x40,0x3f, /* W */
 x63,0x14,0x08,0x14,0x63, /* X */
 x07,0x08,0x70,0x08,0x07, /* Y */
 x61,0x51,0x49,0x45,0x43, /* Z */
 x00,0x7f,0x41,0x41,0x00, /* [ */
 x02,0x04,0x08,0x10,0x20, /* \ */
 x00,0x41,0x41,0x7f,0x00, /* ] */
 x04,0x02,0x01,0x02,0x04, /* ^ */
 x40,0x40,0x40,0x40,0x40, /* _ */
 x00,0x00,0x03,0x05,0x00, /* ` */
 x20,0x54,0x54,0x54,0x78, /* a */
 x7F,0x44,0x44,0x44,0x38, /* b */
 x38,0x44,0x44,0x44,0x44, /* c */
 x38,0x44,0x44,0x44,0x7f, /* d */
 x38,0x54,0x54,0x54,0x18, /* e */
 x04,0x04,0x7e,0x05,0x05, /* f */
 x08,0x54,0x54,0x54,0x3c, /* g */
 x7f,0x08,0x04,0x04,0x78, /* h */
 x00,0x44,0x7d,0x40,0x00, /* i */
 x20,0x40,0x44,0x3d,0x00, /* j */
 x7f,0x10,0x28,0x44,0x00, /* k */
 x00,0x41,0x7f,0x40,0x00, /* l */
 x7c,0x04,0x7c,0x04,0x78, /* m */
 x7c,0x08,0x04,0x04,0x78, /* n */
 x38,0x44,0x44,0x44,0x38, /* o */
 x7c,0x14,0x14,0x14,0x08, /* p */
 x08,0x14,0x14,0x14,0x7c, /* q */
 x7c,0x08,0x04,0x04,0x00, /* r */
 x48,0x54,0x54,0x54,0x24, /* s */
 x04,0x04,0x3f,0x44,0x44, /* t */
 x3c,0x40,0x40,0x20,0x7c, /* u */
 x1c,0x20,0x40,0x20,0x1c, /* v */
 x3c,0x40,0x30,0x40,0x3c, /* w */
 x44,0x28,0x10,0x28,0x44, /* x */
 x0c,0x50,0x50,0x50,0x3c, /* y */
 x44,0x64,0x54,0x4c,0x44, /* z */
 x08,0x36,0x41,0x41,0x00, /* { */
 x00,0x00,0x77,0x00,0x00, /* | */
 x00,0x41,0x41,0x36,0x08, /* } */
 x08,0x08,0x2a,0x1c,0x08, /* <- */
 x08,0x1c,0x2a,0x08,0x08, /* -> */
 xff,0xff,0xff,0xff,0xff, /* */
 };
 /* System 7x8 */
 const uint8_t au8FontSystem7x8[]=
+{
 ,   0,   0,   0,   0,   0,   0, //' '
 ,   6,  95,  95,   6,   0,   0, //'!'
 ,   7,   7,   0,   7,   7,   0, //'"'
 , 127, 127,  20, 127, 127,  20, //'#'
 ,  46, 107, 107,  58,  18,   0, //'$'
 , 102,  48,  24,  12, 102,  98, //'%'
 , 122,  79,  93,  55, 122,  72, //'&'
 ,   7,   3,   0,   0,   0,   0, //'''
 ,  28,  62,  99,  65,   0,   0, //'('
 ,  65,  99,  62,  28,   0,   0, //')'
 ,  42,  62,  28,  28,  62,  42, //'*'
 ,   8,  62,  62,   8,   8,   0, //'+'
 , 128, 224,  96,   0,   0,   0, //','
 ,   8,   8,   8,   8,   8,   0, //'-'
 ,   0,  96,  96,   0,   0,   0, //'.'
 ,  48,  24,  12,   6,   3,   1, //'/'
 , 127, 113,  89,  77, 127,  62, //'0'
 ,  66, 127, 127,  64,  64,   0, //'1'
 , 115,  89,  73, 111, 102,   0, //'2'
 ,  99,  73,  73, 127,  54,   0, //'3'
 ,  28,  22,  83, 127, 127,  80, //'4'
 , 103,  69,  69, 125,  57,   0, //'5'
 , 126,  75,  73, 121,  48,   0, //'6'
 ,   3, 113, 121,  15,   7,   0, //'7'
 , 127,  73,  73, 127,  54,   0, //'8'
 ,  79,  73, 105,  63,  30,   0, //'9'
 ,   0, 102, 102,   0,   0,   0, //':'
 , 128, 230, 102,   0,   0,   0, //';'
 ,  28,  54,  99,  65,   0,   0, //'<'
 ,  36,  36,  36,  36,  36,   0, //'='
 ,  65,  99,  54,  28,   8,   0, //'>'
 ,   3,  81,  89,  15,   6,   0, //'?'
 , 127,  65,  93,  93,  31,  30, //'@'
 ,126,  19,  19, 126, 124,   0, //'A'
 , 127, 127,  73,  73, 127,  54, //'B'
 ,  62,  99,  65,  65,  99,  34, //'C'
 , 127, 127,  65,  99,  62,  28, //'D'
 , 127, 127,  73,  93,  65,  99, //'E'
 , 127, 127,  73,  29,   1,   3, //'F'
 ,  62,  99,  65,  81, 115, 114, //'G'
 ,127,   8,   8, 127, 127,   0, //'H'
 ,  65, 127, 127,  65,   0,   0, //'I'
 , 112,  64,  65, 127,  63,   1, //'J'
 , 127, 127,   8,  28, 119,  99, //'K'
 , 127, 127,  65,  64,  96, 112, //'L'
 ,127,  14,  28,  14, 127, 127, //'M'
 ,127,   6,  12,  24, 127, 127, //'N'
 ,  62,  99,  65,  99,  62,  28, //'O'
 , 127, 127,  73,   9,  15,   6, //'P'
 ,  63,  33, 113, 127,  94,   0, //'Q'
 , 127, 127,   9,  25, 127, 102, //'R'
 , 111,  77,  89, 115,  50,   0, //'S'
 ,  65, 127, 127,  65,   3,   0, //'T'
 ,127,  64,  64, 127, 127,   0, //'U'
 ,  63,  96,  96,  63,  31,   0, //'V'
 ,127,  48,  24,  48, 127, 127, //'W'
 , 103,  60,  24,  60, 103,  67, //'X'
 ,  79, 120, 120,  79,   7,   0, //'Y'
 ,  99, 113,  89,  77, 103, 115, //'Z'
 , 127, 127,  65,  65,   0,   0, //'['
 ,   3,   6,  12,  24,  48,  96, //'\'
 ,  65,  65, 127, 127,   0,   0, //']'
 ,  12,   6,   3,   6,  12,   8, //'^'
 ,128, 128, 128, 128, 128, 128, //'_'
 ,   0,   3,   7,   4,   0,   0, //'`'
 , 116,  84,  84,  60, 120,  64, //'a'
 , 127,  63,  72,  72, 120,  48, //'b'
 , 124,  68,  68, 108,  40,   0, //'c'
 , 120,  72,  73,  63, 127,  64, //'d'
 , 124,  84,  84,  92,  24,   0, //'e'
 , 126, 127,  73,   3,   2,   0, //'f'
 , 188, 164, 164, 252, 120,   0, //'g'
 , 127, 127,   8,   4, 124, 120, //'h'
 ,  68, 125, 125,  64,   0,   0, //'i'
 , 224, 128, 128, 253, 125,   0, //'j'
 , 127, 127,  16,  56, 108,  68, //'k'
 ,  65, 127, 127,  64,   0,   0, //'l'
 ,124,  28,  56,  28, 124, 120, //'m'
 ,124,   4,   4, 124, 120,   0, //'n'
 , 124,  68,  68, 124,  56,   0, //'o'
 ,  252, 252, 164,  36,  60,  24, //'p'
 ,  60,  36, 164, 248, 252, 132, //'q'
 , 124, 120,  76,   4,  28,  24, //'r'
 ,  92,  84,  84, 116,  36,   0, //'s'
 ,   4,  62, 127,  68,  36,   0, //'t'
 , 124,  64,  64,  60, 124,  64, //'u'
 ,  60,  96,  96,  60,  28,   0, //'v'
 , 124, 112,  56, 112, 124,  60, //'w'
 , 108,  56,  16,  56, 108,  68, //'x'
 , 188, 160, 160, 252, 124,   0, //'y'
 , 100, 116,  92,  76, 100,   0, //'z'
 ,   8,  62, 119,  65,  65,   0, //'{'
 ,   0,   0, 119, 119,   0,   0, //'|'
 ,  65, 119,  62,   8,   8,   0, //'}'
 ,   3,   1,   3,   2,   3,   1, //'~'
 ,129, 129, 129, 129, 129, 255, //'
 , 159, 145, 177, 251,  74,   0 //'Á'
 };
 /* 8x8 Normal */
 const uint8_t au8Font8x8[]= {
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,       // ASCII -  32
 x00,0x00,0x00,0x5F,0x5F,0x00,0x00,0x00,       // ASCII -  33
 x00,0x00,0x03,0x07,0x00,0x07,0x03,0x00,       // ASCII -  34
 x00,0x10,0x74,0x1C,0x77,0x1C,0x17,0x04,       // ASCII -  35
 x00,0x24,0x2E,0x2A,0x7F,0x2A,0x3A,0x10,       // ASCII -  36
 x00,0x4C,0x6A,0x76,0x1A,0x6A,0x56,0x33,       // ASCII -  37
 x00,0x30,0x7A,0x4F,0x5D,0x37,0x7A,0x48,       // ASCII -  38
 x00,0x00,0x04,0x07,0x03,0x00,0x00,0x00,       // ASCII -  39
 x00,0x00,0x00,0x1C,0x3E,0x63,0x41,0x00,       // ASCII -  40
 x00,0x00,0x41,0x63,0x3E,0x1C,0x00,0x00,       // ASCII -  41
 x00,0x08,0x2A,0x3E,0x1C,0x3E,0x2A,0x08,       // ASCII -  42
 x00,0x08,0x08,0x3E,0x3E,0x08,0x08,0x00,       // ASCII -  43
 x00,0x00,0x00,0x60,0x60,0x00,0x00,0x00,       // ASCII -  44
 x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00,       // ASCII -  45
 x00,0x00,0x00,0x60,0x60,0x00,0x00,0x00,       // ASCII -  46
 x00,0x60,0x30,0x18,0x0C,0x06,0x03,0x01,       // ASCII -  47
 x00,0x1C,0x3E,0x61,0x43,0x3E,0x1C,0x00,       // ASCII -  48
 x00,0x00,0x44,0x7F,0x7F,0x40,0x00,0x00,       // ASCII -  49
 x00,0x46,0x67,0x71,0x59,0x4F,0x66,0x00,       // ASCII -  50
 x00,0x22,0x63,0x49,0x4D,0x7F,0x32,0x00,       // ASCII -  51
 x00,0x18,0x1C,0x52,0x7F,0x7F,0x50,0x00,       // ASCII -  52
 x00,0x2F,0x6F,0x45,0x45,0x7D,0x39,0x00,       // ASCII -  53
 x00,0x3C,0x7E,0x4B,0x49,0x79,0x30,0x00,       // ASCII -  54
 x00,0x07,0x43,0x71,0x7D,0x0F,0x03,0x00,       // ASCII -  55
 x00,0x36,0x7F,0x4D,0x59,0x7F,0x36,0x00,       // ASCII -  56
 x00,0x06,0x4F,0x49,0x69,0x3F,0x1E,0x00,       // ASCII -  57
 x00,0x00,0x00,0x66,0x66,0x00,0x00,0x00,       // ASCII -  58
 x00,0x00,0x00,0x66,0x66,0x00,0x00,0x00,       // ASCII -  59
 x00,0x00,0x08,0x1C,0x36,0x63,0x41,0x00,       // ASCII -  60
 x00,0x14,0x14,0x14,0x14,0x14,0x14,0x00,       // ASCII -  61
 x00,0x00,0x41,0x63,0x36,0x1C,0x08,0x00,       // ASCII -  62
 x00,0x02,0x07,0x51,0x59,0x0F,0x06,0x00,       // ASCII -  63
 x00,0x3E,0x41,0x5D,0x55,0x5D,0x51,0x1E,       // ASCII -  64
 x00,0x40,0x70,0x1D,0x17,0x1F,0x78,0x60,       // ASCII -  65
 x00,0x41,0x7F,0x7F,0x49,0x4F,0x7E,0x30,       // ASCII -  66
 x00,0x1C,0x3E,0x63,0x41,0x41,0x42,0x27,       // ASCII -  67
 x00,0x41,0x7F,0x7F,0x41,0x63,0x3E,0x1C,       // ASCII -  68
 x00,0x41,0x7F,0x7F,0x49,0x5D,0x41,0x63,       // ASCII -  69
 x00,0x41,0x7F,0x7F,0x49,0x1D,0x01,0x03,       // ASCII -  70
 x00,0x1C,0x3E,0x63,0x41,0x51,0x72,0x77,       // ASCII -  71
 x00,0x7F,0x7F,0x08,0x08,0x7F,0x7F,0x00,       // ASCII -  72
 x00,0x00,0x41,0x7F,0x7F,0x41,0x00,0x00,       // ASCII -  73
 x00,0x30,0x70,0x41,0x41,0x7F,0x3F,0x01,       // ASCII -  74
 x00,0x7F,0x7F,0x08,0x1C,0x77,0x63,0x41,       // ASCII -  75
 x00,0x41,0x7F,0x7F,0x41,0x40,0x60,0x70,       // ASCII -  76
 x00,0x7F,0x7E,0x0C,0x18,0x0C,0x7E,0x7F,       // ASCII -  77
 x00,0x7F,0x7E,0x0C,0x18,0x30,0x7F,0x7F,       // ASCII -  78
 x00,0x1C,0x3E,0x63,0x41,0x63,0x3E,0x1C,       // ASCII -  79
 x00,0x41,0x7F,0x7F,0x49,0x09,0x0F,0x06,       // ASCII -  80
 x00,0x1C,0x3E,0x63,0x51,0x63,0x3E,0x1C,       // ASCII -  81
 x00,0x7F,0x7F,0x09,0x19,0x7F,0x66,0x40,       // ASCII -  82
 x00,0x66,0x6F,0x4D,0x59,0x7B,0x33,0x00,       // ASCII -  83
 x00,0x03,0x41,0x7F,0x7F,0x41,0x03,0x00,       // ASCII -  84
 x00,0x3F,0x7F,0x40,0x40,0x40,0x7F,0x3F,       // ASCII -  85
 x00,0x03,0x0F,0x3D,0x70,0x1D,0x07,0x01,       // ASCII -  86
 x00,0x0F,0x7F,0x30,0x1C,0x30,0x7F,0x0F,       // ASCII -  87
 x00,0x63,0x77,0x1C,0x1C,0x77,0x63,0x00,       // ASCII -  88
 x01,0x03,0x47,0x7C,0x78,0x47,0x03,0x01,       // ASCII -  89
 x00,0x67,0x73,0x59,0x4D,0x67,0x73,0x00,       // ASCII -  90
 x00,0x00,0x00,0x7F,0x7F,0x41,0x41,0x00,       // ASCII -  91
 x00,0x01,0x03,0x06,0x0C,0x18,0x30,0x60,       // ASCII -  92
 x00,0x00,0x41,0x41,0x7F,0x7F,0x00,0x00,       // ASCII -  93
 x00,0x00,0x04,0x06,0x03,0x06,0x04,0x00,       // ASCII -  94
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,       // ASCII -  95
 x00,0x00,0x01,0x03,0x06,0x04,0x00,0x00,       // ASCII -  96
 x00,0x68,0x6C,0x54,0x54,0x3C,0x78,0x40,       // ASCII -  97
 x00,0x41,0x7F,0x3F,0x6C,0x44,0x7C,0x38,       // ASCII -  98
 x00,0x38,0x7C,0x44,0x44,0x6C,0x2C,0x00,       // ASCII -  99
 x00,0x38,0x7C,0x44,0x49,0x3F,0x7F,0x40,       // ASCII - 100
 x00,0x38,0x7C,0x54,0x54,0x5C,0x58,0x00,       // ASCII - 101
 x00,0x00,0x48,0x7E,0x7F,0x49,0x0B,0x02,       // ASCII - 102
 x00,0x48,0x7C,0x34,0x34,0x2C,0x68,0x44,       // ASCII - 103
 x00,0x41,0x7F,0x7F,0x08,0x04,0x7C,0x78,       // ASCII - 104
 x00,0x00,0x44,0x7D,0x7D,0x40,0x00,0x00,       // ASCII - 105
 x00,0x60,0x60,0x04,0x7D,0x7D,0x00,0x00,       // ASCII - 106
 x00,0x41,0x7F,0x7F,0x10,0x78,0x6C,0x44,       // ASCII - 107
 x00,0x00,0x41,0x7F,0x7F,0x40,0x00,0x00,       // ASCII - 108
 x00,0x7C,0x7C,0x0C,0x78,0x0C,0x7C,0x78,       // ASCII - 109
 x00,0x44,0x7C,0x7C,0x08,0x04,0x7C,0x78,       // ASCII - 110
 x00,0x38,0x7C,0x44,0x44,0x7C,0x38,0x00,       // ASCII - 111
 x00,0x04,0x7C,0x78,0x24,0x24,0x3C,0x18,       // ASCII - 112
 x00,0x18,0x3C,0x24,0x24,0x78,0x7C,0x00,       // ASCII - 113
 x00,0x44,0x7C,0x78,0x4C,0x04,0x1C,0x18,       // ASCII - 114
 x00,0x48,0x5C,0x5C,0x74,0x74,0x24,0x00,       // ASCII - 115
 x00,0x00,0x04,0x3E,0x7F,0x44,0x24,0x00,       // ASCII - 116
 x00,0x3C,0x7C,0x40,0x40,0x3C,0x7C,0x40,       // ASCII - 117
 x00,0x04,0x1C,0x3C,0x60,0x30,0x1C,0x04,       // ASCII - 118
 x00,0x1C,0x7C,0x30,0x1C,0x30,0x7C,0x1C,       // ASCII - 119
 x00,0x44,0x6C,0x3C,0x10,0x78,0x6C,0x44,       // ASCII - 120
 x00,0x44,0x4C,0x1C,0x70,0x64,0x1C,0x0C,       // ASCII - 121
 x00,0x4C,0x64,0x74,0x5C,0x4C,0x64,0x00,       // ASCII - 122
 x00,0x08,0x08,0x3E,0x77,0x41,0x41,0x00,       // ASCII - 123
 x00,0x00,0x00,0x7F,0x7F,0x00,0x00,0x00,       // ASCII - 124
 x00,0x41,0x41,0x77,0x3E,0x08,0x08,0x00,       // ASCII - 125
 x00,0x02,0x01,0x01,0x03,0x02,0x02,0x01,       // ASCII - 126
 x00,0x60,0x78,0x4E,0x47,0x5E,0x78,0x60,       // ASCII - 127
 x00,0x1C,0x3E,0x23,0x41,0x41,0x42,0x27,       // ASCII - 128
 x00,0x3D,0x7D,0x40,0x41,0x3D,0x7C,0x40,       // ASCII - 129
 };
 /* 8x8 Thin */
 const uint8_t au8Font8x8Thin[]= {
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 x00,0x00,0x00,0x5F,0x00,0x00,0x00,0x00,
 x00,0x00,0x07,0x00,0x00,0x07,0x00,0x00,
 x00,0x14,0x7F,0x14,0x14,0x7F,0x14,0x00,
 x00,0x24,0x2A,0x6B,0x6B,0x2A,0x12,0x00,
 x00,0x46,0x26,0x10,0x08,0x64,0x62,0x00,
 x30,0x4A,0x45,0x4D,0x32,0x48,0x48,0x00,
 x00,0x00,0x04,0x03,0x00,0x00,0x00,0x00,
 x00,0x1C,0x22,0x41,0x00,0x00,0x00,0x00,
 x00,0x00,0x41,0x22,0x1C,0x00,0x00,0x00,
 x08,0x2A,0x1C,0x1C,0x1C,0x2A,0x08,0x00,
 x00,0x08,0x08,0x3E,0x08,0x08,0x00,0x00,
 x00,0x00,0x80,0x60,0x00,0x00,0x00,0x00,
 x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00,
 x00,0x00,0x00,0x60,0x00,0x00,0x00,0x00,
 x00,0x40,0x20,0x10,0x08,0x04,0x02,0x00,
 x00,0x3E,0x61,0x51,0x49,0x45,0x3E,0x00,
 x00,0x44,0x42,0x7F,0x40,0x40,0x00,0x00,
 x00,0x62,0x51,0x51,0x49,0x49,0x66,0x00,
 x00,0x22,0x41,0x49,0x49,0x49,0x36,0x00,
 x10,0x18,0x14,0x52,0x7F,0x50,0x10,0x00,
 x00,0x27,0x45,0x45,0x45,0x45,0x39,0x00,
 x00,0x3C,0x4A,0x49,0x49,0x49,0x30,0x00,
 x00,0x03,0x01,0x71,0x09,0x05,0x03,0x00,
 x00,0x36,0x49,0x49,0x49,0x49,0x36,0x00,
 x00,0x06,0x49,0x49,0x49,0x29,0x1E,0x00,
 x00,0x00,0x00,0x66,0x00,0x00,0x00,0x00,
 x00,0x00,0x80,0x66,0x00,0x00,0x00,0x00,
 x00,0x08,0x14,0x22,0x41,0x00,0x00,0x00,
 x00,0x24,0x24,0x24,0x24,0x24,0x24,0x00,
 x00,0x00,0x00,0x41,0x22,0x14,0x08,0x00,
 x00,0x02,0x01,0x01,0x51,0x09,0x06,0x00,
 x00,0x3E,0x41,0x5D,0x55,0x55,0x1E,0x00,
 x00,0x7C,0x12,0x11,0x11,0x12,0x7C,0x00,
 x00,0x41,0x7F,0x49,0x49,0x49,0x36,0x00,
 x00,0x1C,0x22,0x41,0x41,0x41,0x22,0x00,
 x00,0x41,0x7F,0x41,0x41,0x22,0x1C,0x00,
 x00,0x41,0x7F,0x49,0x5D,0x41,0x63,0x00,
 x00,0x41,0x7F,0x49,0x1D,0x01,0x03,0x00,
 x00,0x1C,0x22,0x41,0x51,0x51,0x72,0x00,
 x00,0x7F,0x08,0x08,0x08,0x08,0x7F,0x00,
 x00,0x00,0x41,0x7F,0x41,0x00,0x00,0x00,
 x00,0x30,0x40,0x40,0x41,0x3F,0x01,0x00,
 x00,0x41,0x7F,0x08,0x14,0x22,0x41,0x40,
 x00,0x41,0x7F,0x41,0x40,0x40,0x60,0x00,
 x00,0x7F,0x01,0x02,0x04,0x02,0x01,0x7F,
 x00,0x7F,0x01,0x02,0x04,0x08,0x7F,0x00,
 x00,0x3E,0x41,0x41,0x41,0x41,0x3E,0x00,
 x00,0x41,0x7F,0x49,0x09,0x09,0x06,0x00,
 x00,0x1E,0x21,0x21,0x31,0x21,0x5E,0x40,
 x00,0x41,0x7F,0x49,0x19,0x29,0x46,0x00,
 x00,0x26,0x49,0x49,0x49,0x49,0x32,0x00,
 x00,0x03,0x01,0x41,0x7F,0x41,0x01,0x03,
 x00,0x3F,0x40,0x40,0x40,0x40,0x3F,0x00,
 x00,0x0F,0x10,0x20,0x40,0x20,0x10,0x0F,
 x00,0x3F,0x40,0x40,0x38,0x40,0x40,0x3F,
 x00,0x41,0x22,0x14,0x08,0x14,0x22,0x41,
 x00,0x01,0x02,0x44,0x78,0x44,0x02,0x01,
 x00,0x43,0x61,0x51,0x49,0x45,0x43,0x61,
 x00,0x7F,0x41,0x41,0x41,0x00,0x00,0x00,
 x01,0x02,0x04,0x08,0x10,0x20,0x40,0x00,
 x00,0x41,0x41,0x41,0x7F,0x00,0x00,0x00,
 x08,0x04,0x02,0x01,0x02,0x04,0x08,0x00,
 x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
 x00,0x00,0x00,0x03,0x04,0x00,0x00,0x00,
 x00,0x20,0x54,0x54,0x54,0x54,0x78,0x40,
 x00,0x01,0x7F,0x30,0x48,0x48,0x48,0x30,
 x00,0x38,0x44,0x44,0x44,0x44,0x28,0x00,
 x00,0x30,0x48,0x48,0x48,0x31,0x7F,0x40,
 x00,0x38,0x54,0x54,0x54,0x54,0x18,0x00,
 x00,0x00,0x48,0x7E,0x49,0x01,0x02,0x00,
 x00,0x98,0xA4,0xA4,0xA4,0xA4,0x78,0x04,
 x00,0x41,0x7F,0x08,0x04,0x04,0x78,0x00,
 x00,0x00,0x44,0x7D,0x40,0x00,0x00,0x00,
 x00,0x60,0x80,0x80,0x80,0x84,0x7D,0x00,
 x00,0x01,0x7F,0x10,0x28,0x44,0x40,0x00,
 x00,0x00,0x41,0x7F,0x40,0x00,0x00,0x00,
 x00,0x7C,0x04,0x04,0x78,0x04,0x04,0x78,
 x00,0x7C,0x08,0x04,0x04,0x04,0x78,0x00,
 x00,0x38,0x44,0x44,0x44,0x44,0x38,0x00,
 x00,0x84,0xFC,0x98,0x24,0x24,0x18,0x00,
 x00,0x18,0x24,0x24,0x98,0xFC,0x84,0x00,
 x00,0x44,0x7C,0x48,0x04,0x04,0x18,0x00,
 x00,0x48,0x54,0x54,0x54,0x54,0x24,0x00,
 x00,0x04,0x04,0x3F,0x44,0x44,0x20,0x00,
 x00,0x3C,0x40,0x40,0x40,0x20,0x7C,0x00,
 x00,0x0C,0x10,0x20,0x40,0x20,0x10,0x0C,
 x00,0x3C,0x40,0x40,0x38,0x40,0x40,0x3C,
 x00,0x44,0x28,0x10,0x28,0x44,0x00,0x00,
 x00,0x9C,0xA0,0xA0,0xA0,0xA0,0x7C,0x00,
 x00,0x44,0x64,0x54,0x4C,0x44,0x00,0x00,
 x00,0x08,0x08,0x36,0x41,0x41,0x00,0x00,
 x00,0x00,0x00,0x77,0x00,0x00,0x00,0x00,
 x00,0x00,0x41,0x41,0x36,0x08,0x08,0x00,
 x00,0x02,0x01,0x01,0x02,0x02,0x01,0x00,
 x00,0x70,0x48,0x44,0x42,0x44,0x48,0x70,
 x00,0x0E,0x91,0x91,0xB1,0xB1,0x4A,0x00,
 x00,0x3A,0x40,0x40,0x40,0x7A,0x40,0x00,
 x00,0x38,0x54,0x54,0x55,0x55,0x18,0x00,
 x00,0x22,0x55,0x55,0x55,0x79,0x42,0x00,
 x00,0x21,0x54,0x54,0x54,0x78,0x41,0x00,
 x00,0x20,0x55,0x55,0x54,0x78,0x40,0x00,
 x00,0x20,0x54,0x55,0x54,0x78,0x40,0x00,
 x00,0x18,0x24,0xA4,0xA4,0xE4,0x40,0x00,
 x00,0x3A,0x55,0x55,0x55,0x55,0x1A,0x00,
 x00,0x39,0x54,0x54,0x54,0x54,0x19,0x00,
 x00,0x38,0x55,0x55,0x54,0x54,0x18,0x00,
 x00,0x00,0x01,0x44,0x7C,0x41,0x00,0x00,
 x02,0x01,0x45,0x7D,0x41,0x01,0x02,0x00,
 x00,0x00,0x01,0x45,0x7C,0x40,0x00,0x00,
 x00,0x79,0x14,0x12,0x12,0x14,0x79,0x00,
 x00,0x70,0x28,0x2B,0x2B,0x28,0x70,0x00,
 x00,0x44,0x7C,0x54,0x55,0x45,0x00,0x00,
 x00,0x20,0x54,0x54,0x58,0x38,0x54,0x54,
 x00,0x7C,0x0A,0x09,0x09,0x7F,0x49,0x49,
 x00,0x30,0x4A,0x49,0x49,0x4A,0x30,0x00,
 x00,0x32,0x48,0x48,0x48,0x48,0x32,0x00,
 x00,0x30,0x49,0x4A,0x48,0x48,0x30,0x00,
 x00,0x38,0x42,0x41,0x41,0x42,0x38,0x00,
 x00,0x38,0x41,0x42,0x40,0x40,0x38,0x00,
 x00,0x1A,0xA0,0xA0,0xA0,0xA0,0x7A,0x00,
 x00,0x19,0x24,0x42,0x42,0x24,0x19,0x00,
 x00,0x3D,0x40,0x40,0x40,0x40,0x3D,0x00,
 x00,0x18,0x24,0x24,0xE7,0x24,0x24,0x00,
 x00,0x68,0x5E,0x49,0x41,0x42,0x20,0x00,
 x00,0x15,0x16,0x7C,0x16,0x15,0x00,0x00,
 x81,0xFF,0x85,0x05,0x17,0xFA,0x90,0x50,
 x40,0x88,0x88,0x7F,0x09,0x09,0x02,0x00,
 x00,0x20,0x54,0x54,0x55,0x79,0x40,0x00,
 };

ssd1306.c

➞

Show inline comments

 /*******************************************************************************
 * File Name          : ssd1306.c
 * Author             : lxyppc
 * Version            : V1.0
 * Date               : 10-01-21
 * Description        : ssd1306 operations
 *                      the SSH1101A is compatible with ssd1306
 *******************************************************************************/
 /* Includes ------------------------------------------------------------------*/
 #include "stm32l100c_discovery.h"
 #include "bsp.h"
 #include "ssd1306.h"
 #include "DrawText.h"
 /* Private typedef -----------------------------------------------------------*/
 /* Private define ------------------------------------------------------------*/
 #define   SSD1306_PAGE_NUMBER           8
 #define   SSD1306_COLUMN_NUMBER         128
 #define   SSD1306_COLUMN_MARGIN_START   2
 #define   SSD1306_COLUMN_MARGIN_END     2
 #define   SSD1306_X_PIXEL   128
-#define   SSD1306_Y_PIXEL   64
+#define   SSD1306_Y_PIXEL   32
 /* Private macro -------------------------------------------------------------*/
 #define   ssd1306_Buffer    (_SSD1306_Buffer + SSD1306_COLUMN_MARGIN_START)
 /* Private variables ---------------------------------------------------------*/
 static  uint8_t  _SSD1306_Buffer[SSD1306_COLUMN_NUMBER*SSD1306_PAGE_NUMBER + SSD1306_COLUMN_MARGIN_START + SSD1306_COLUMN_MARGIN_END] = {0};
 static  uint8_t  pageIndex = 0;
 static  uint8_t  iS_SSD_On = 0;
 static  uint8_t  pre_on = 0;
 static  uint8_t  curContrast = 0xCC;
 static  uint8_t  lastContrast = 0xCC;
 /* Private function prototypes -----------------------------------------------*/
 void  WriteCommand(unsigned char command);
 void  WriteData(unsigned char data);
 void  OnPageTransferDone(void);
 unsigned long ssd1306_OFF(void);
 unsigned long ssd1306_ON(void);
 unsigned char* ssd1306_GetBuffer()
+{
   return ssd1306_Buffer;
+}
 /*******************************************************************************
 * Function Name  : WriteCommand
 * Description    : Write command to the ssd1306
 * Input          : None
 * Output         : None
 * Return         : None
 *******************************************************************************/
 void WriteCommand(unsigned char command)
+{
   SSD_A0_Low();
   SPI_SendByte(command);
   SPI_Wait();
+}
 /*******************************************************************************
 * Function Name  : WriteData
 * Description    : Write data to the ssd1306
 * Input          : None
 * Output         : None
 * Return         : None
 *******************************************************************************/
 void WriteData(unsigned char data)
+{
   SSD_A0_High();
   SPI_SendByte(data);
   SPI_Wait();
+}
 /*******************************************************************************
 * Function Name  : ssd1306_Init
 * Description    : Initialize the ssd1306
 * Input          : None
 * Output         : None
 * Return         : None
 *******************************************************************************/
 void ssd1306_Init(void)
+{
   /* Generate a reset */
   SSD_Reset_Low();
   uint32_t i;
   for(i=5000; i>1; i--)
   SSD_Reset_High();
   WriteCommand(0xAE);
   WriteCommand(0xD5);
   WriteCommand(0x80);
   WriteCommand(0xA8);
   WriteCommand(0x1F);
   WriteCommand(0xD3);
   WriteCommand(0x00);
   WriteCommand(0x40 | 0x00); // line #0
   WriteCommand(0x8D);
   WriteCommand(0x14); //10 or 14 if not externalvcc
   WriteCommand(0x20);
   WriteCommand(0x00);
   WriteCommand(0xA0 | 0x1); // segremap
   WriteCommand(0xC8); // comscandep
   WriteCommand(0xDA); // setcompins
   WriteCommand(0x02);
   WriteCommand(0x81); // contrast
   WriteCommand(0x0F); // contrast value. 8f is a good one.
   WriteCommand(0xD9);
   WriteCommand(0xF1); //22 or F1 if not externalvcc
   WriteCommand(0xDB);
   WriteCommand(0x40);
   WriteCommand(0xA4); // dispalyallon_resume
   WriteCommand(0xA6); // normaldisplay
   WriteCommand(0xAF); // display on
   // Clear buffer
 //  for(i=0;i<900;i++)
 //    ssd1306_Buffer[i] = 0;
   /*************************************************
   // ssd1306 Initialization Command
   *************************************************/
  /*
   // Lower Column Address
-  WriteCommand(0x00); /* Set Lower Column Address */
+  WriteCommand(0x00); // Set Lower Column Address
   GPIO_SetBits(GPIOA,GPIO_Pin_15);//turn on status LED
   // High Column Address
-  WriteCommand(0x10); /* Set Higher Column Address*/
+  WriteCommand(0x10); // Set Higher Column Address
   // Display Start Line
-  WriteCommand(0x40); /* Set Display Start Line */
+  WriteCommand(0x40); // Set Display Start Line
 #ifdef    DEBUG_BOARD
   curContrast = lastContrast = 0x30;
 #else
   curContrast = lastContrast = 0xCF;
 #endif
   // Contrast Control Register
   WriteCommand(0x81); /* Set Contrast Control */
   WriteCommand(lastContrast); /* 0 ~ 255 0x1f*/
   WriteCommand(0x81); // Set Contrast Control
   WriteCommand(lastContrast); // 0 ~ 255 0x1f
   // Re-map
   WriteCommand(0xA1); /* [A0]:column address 0 is map
   to SEG0 , [A1]: columnaddress 131 is map to SEG0*/
   WriteCommand(0xA1); // [A0]:column address 0 is map to SEG0 , [A1]: columnaddress 131 is map to SEG0
   // Entire Display ON/OFF
-  WriteCommand(0xA4); /* A4=ON */
+  WriteCommand(0xA4); // A4=ON
   // Normal or Inverse Display
-  WriteCommand(0XA6); /* Normal Display*/
+  WriteCommand(0XA6); // Normal Display
   // Multiplex Ratio
   WriteCommand(0xA8); /* Set Multiplex Ratio */
   WriteCommand(0x3f); /* Set to 36 Mux*/
   WriteCommand(0xA8); // Set Multiplex Ratio
   WriteCommand(0x3f); // Set to 36 Mux
   // Set DC-DC
   WriteCommand(0xAD); /* Set DC-DC */
   WriteCommand(0x8B); /* 8B=ON, 8A=Off */
   WriteCommand(0xAD); // Set DC-DC
   WriteCommand(0x8B); // 8B=ON, 8A=Off
   // Display ON/OFF
-  WriteCommand(0xAE); /* AF=ON , AE=OFF*/
+  WriteCommand(0xAE); // AF=ON , AE=OFF
   // Display Offset
   WriteCommand(0xD3); /* Set Display Offset */
   WriteCommand(0x00); /* No offset */
   WriteCommand(0xD3); // Set Display Offset
   WriteCommand(0x00); // No offset
   // Display Clock Divide
   WriteCommand(0xD5); /* Set Clock Divide */
   WriteCommand(0x20); /* Set to 80Hz */
   WriteCommand(0xD5); // Set Clock Divide
   WriteCommand(0x20); // Set to 80Hz
   // Area Color Mode
   WriteCommand(0xD8); /* Set Area Color On or Off*/
   WriteCommand(0x00); /* Mono Mode */
   WriteCommand(0xD8); // Set Area Color On or Off
   WriteCommand(0x00); // Mono Mode
   // COM Pins Hardware Configuration
-  WriteCommand(0xDA); /* Set Pins HardwareConfiguration */
+  WriteCommand(0xDA); // Set Pins HardwareConfiguration
   WriteCommand(0x12);
   // VCOMH
-  WriteCommand(0xDB); /* Set VCOMH */
+  WriteCommand(0xDB); // Set VCOMH
   WriteCommand(0x00);
   // VP
   WriteCommand(0xD9); /* Set VP */
   WriteCommand(0x22); /* P1=2 , P2=2 */
   WriteCommand(0xD9); // Set VP
   WriteCommand(0x22); // P1=2 , P2=2
   // Set Common output scan direction
-  WriteCommand(0xc8);/* Set COM scan direction */
+  WriteCommand(0xc8);// Set COM scan direction
   // For SSD1306 Set the address mode
   WriteCommand(0x20);/* Set address mode */
   WriteCommand(0x00);/* Set address mode horizontal */
   WriteCommand(0x20);// Set address mode
   WriteCommand(0x00);// Set address mode horizontal
   // Set the page start address
   WriteCommand(0xb0);
   WriteCommand(0x00);
   WriteCommand(0x10);
-  /* Turn on the controller */
+  // Turn on the controller
   pre_on = ssd1306_ON();
 //  // Set Charge pump
 //  WriteCommand(0x8D); /* Set Charge pump */
 //  WriteCommand(0x14); /* 0x14=ON, 0x10=Off */
 //  WriteCommand(0x8D); // Set Charge pump
 //  WriteCommand(0x14); // 0x14=ON, 0x10=Off
 //
 //  // Turn on the display
 //  WriteCommand(0xaf);
 */
+}
 void ssd1306_block_write(void)
+{
   // Set col start addr to 0
   WriteCommand(0x21);
   WriteCommand(0x00);
   // Set col end addr to width - 1
   WriteCommand(127);
   // Set page addr
   WriteCommand(0x22);
   WriteCommand(0x00); // start page addr
   WriteCommand(4); // end page addr (height / 8)
   uint32_t i = 0;
   for(i=0;i<1024;i++)
   for(i=0;i<512;i++)
     WriteData(ssd1306_Buffer[i]);
 //  for(i=0;i<512;i++)
              // * * * *
 //    WriteData(0b00000011);
+}
 /*******************************************************************************
 * Function Name  : ssd1306_TurnOff
 * Description    : Turn off the ssd1306 controller
 * Input          : None
 * Output         : None
 * Return         : None
 *******************************************************************************/
 unsigned long ssd1306_TurnOff(void)
+{
   pre_on = 0;
   return iS_SSD_On;
+}
 /*******************************************************************************
 * Function Name  : ssd1306_TurnOn
 * Description    : Turn off the ssd1306 controller
 * Input          : None
 * Output         : None
 * Return         : None
 *******************************************************************************/
 unsigned long ssd1306_TurnOn(void)
+{
   pre_on = 1;
   return iS_SSD_On;
+}
 /*******************************************************************************
 * Function Name  : ssd1306_SetContrast
 * Description    : Set the ssd1306 contrast
 * Input          : None
 * Output         : None
 * Return         : None
 *******************************************************************************/
 unsigned char ssd1306_SetContrast(unsigned char contrast)
+{
   curContrast = contrast;
   return lastContrast;
+}
 /*******************************************************************************
 * Function Name  : ssd1306_GetContrast
 * Description    : Get the ssd1306 contrast
 * Input          : None
 * Output         : None
 * Return         : None
 *******************************************************************************/
 unsigned char ssd1306_GetContrast()
+{
   return lastContrast;
+}
 /*******************************************************************************
 * Function Name  : ssd1306_OFF
 * Description    : Turn off the ssd1306 controller
 * Input          : None
 * Output         : None
 * Return         : None
 *******************************************************************************/
 unsigned long ssd1306_OFF(void)
+{
   if(iS_SSD_On){
 #ifdef  DEBUG_UI
     uint32_t i = 0;
     for(i=0;i<ssd1306_COLUMN_NUMBER*SSD1306_PAGE_NUMBER;i++){
       ssd1306_Buffer[i] = 0;
+    }
 #else
     // Turn off the display
     WriteCommand(0xae);
     // Set Charge pump
     WriteCommand(0x8D); /* Set Charge pump */
     WriteCommand(0x10); /* 0x14=ON, 0x10=Off */
 #endif
     iS_SSD_On = 0;
+  }
   return iS_SSD_On;
+}
 /*******************************************************************************
 * Function Name  : ssd1306_ON
 * Description    : Turn on the ssd1306 controller
 * Input          : None
 * Output         : None
 * Return         : None
 *******************************************************************************/
 unsigned long ssd1306_ON(void)
+{
   if(!iS_SSD_On){
 #ifdef  DEBUG_UI
 #else
   #ifdef    DEBUG_BOARD
@@ @@ -462,96 +502,154 @@ unsigned long ssd1306_DrawBlock( @@
 //      }
 //      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);
 //        *(pStart + j*ssd1306_COLUMN_NUMBER + i + x) = tmp;
 //      }
 //    }
 //  }else{
 //    for(Pos_t i=0;i<cx;i++){
 //      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);
 //        *(pStart + j*ssd1306_COLUMN_NUMBER + i + x) = tmp;
 //        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
 * Input          : None
 * Output         : None
 * Return         : None
 *******************************************************************************/
 unsigned long ssd1306_DrawPoint(
   Pos_t x,
   Pos_t y,
   Color_t color)
+{
   if(x >= SSD1306_X_PIXEL)return 0;
   if(y >= SSD1306_Y_PIXEL)return 0;
   unsigned char* pStart = ssd1306_Buffer + (y/8)*SSD1306_COLUMN_NUMBER + x;
   unsigned char mask = 1<<(y%8);
   if(color){
     *pStart |= mask;
   }else{
     *pStart &= ~mask;
+  }
   return 0;
+}
 /*******************************************************************************
 * Function Name  : ssd1306_ReadPoint
 * Description    : Read a point from ssd1306
 * Input          : None
 * Output         : None
 * Return         : None
 *******************************************************************************/
 unsigned long ssd1306_ReadPoint(
   Pos_t x,
   Pos_t y)
+{
   unsigned char* pStart = ssd1306_Buffer + (y/8)*SSD1306_COLUMN_NUMBER + x;
   unsigned char mask = 1<<(y%8);
   return *pStart&mask ? 1 : 0;
+}
 /*******************************************************************************
 * Function Name  : ssd1306_ClearScreen
 * Description    : Clear the screen contents
 * Input          : None
 * Output         : None
 * Return         : None
 *******************************************************************************/
 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,
 };
 /*
 void ssd1306_DrawChar(uint8_t x, uint8_t y, uint8_t c, struct FONT_DEF font)
+{
   uint8_t col, column[font.u8Width];
   // Check if the requested character is available
   if ((c >= font.u8FirstChar) && (c <= font.u8LastChar))
+  {
     // Retrieve appropriate columns from font data
     for (col = 0; col < font.u8Width; col++)
+    {
       column[col] = font.au8FontTable[((c - 32) * font.u8Width) + col];    // Get first column of appropriate character
+    }
+  }
   else
+  {
     // Requested character is not available in this font ... send a space instead
     for (col = 0; col < font.u8Width; col++)
+    {
       column[col] = 0xFF;    // Send solid space
+    }
+  }
   // Render each column
   uint16_t xoffset, yoffset;
   for (xoffset = 0; xoffset < font.u8Width; xoffset++)
+  {
     for (yoffset = 0; yoffset < (font.u8Height + 1); yoffset++)
+    {
       uint8_t bit = 0x00;
       bit = (column[xoffset] << (8 - (yoffset + 1)));     // Shift current row bit left
       bit = (bit >> 7);                     // Shift current row but right (results in 0x01 for black, and 0x00 for white)
       if (bit)
+      {
         ssd1306_DrawPixel(x + xoffset, y + yoffset, 1);
+      }
+    }
+  }
+}
 ssd1306_DrawString(uint8_t x, uint8_t y, const char *text, struct FONT_DEF font)
+{
   uint8_t l;
   for (l = 0; l < strlen(text); l++)
+  {
     ssd1306DrawChar(x + (l * (font.u8Width + 1)), y, text[l], font);
+  }
+}
 */

stm32l1xx_it.c

➞

Show inline comments

@@ @@ -67,152 +67,143 @@ void HardFault_Handler(void) @@
+{
   /* Go to infinite loop when Hard Fault exception occurs */
   while (1)
+  {
+  }
+}
 /**
   * @brief  This function handles Memory Manage exception.
   * @param  None
   * @retval None
   */
 void MemManage_Handler(void)
+{
   /* Go to infinite loop when Memory Manage exception occurs */
   while (1)
+  {
+  }
+}
 /**
   * @brief  This function handles Bus Fault exception.
   * @param  None
   * @retval None
   */
 void BusFault_Handler(void)
+{
   /* Go to infinite loop when Bus Fault exception occurs */
   while (1)
+  {
+  }
+}
 /**
   * @brief  This function handles Usage Fault exception.
   * @param  None
   * @retval None
   */
 void UsageFault_Handler(void)
+{
   /* Go to infinite loop when Usage Fault exception occurs */
   while (1)
+  {
+  }
+}
 /**
   * @brief  This function handles SVCall exception.
   * @param  None
   * @retval None
   */
 void SVC_Handler(void)
+{
+}
 /**
   * @brief  This function handles Debug Monitor exception.
   * @param  None
   * @retval None
   */
 void DebugMon_Handler(void)
+{
+}
 /**
   * @brief  This function handles PendSVC exception.
   * @param  None
   * @retval None
   */
 void PendSV_Handler(void)
+{
+}
 /**
   * @brief  This function handles SysTick Handler.
   * @param  None
   * @retval None
   */
 void SysTick_Handler(void)
+{
   TimingDelay_Decrement();
+}
 /*******************************************************************************
 * Function Name  : USB_IRQHandler
 * Description    : This function handles USB Low Priority interrupts
 *                  requests.
 * Input          : None
 * Output         : None
 * Return         : None
 *******************************************************************************/
 #if defined(STM32L1XX_MD) || defined(STM32L1XX_HD)|| defined(STM32L1XX_MD_PLUS)|| defined (STM32F37X)
 void USB_LP_IRQHandler(void)
 #else
 void USB_LP_CAN1_RX0_IRQHandler(void)
 #endif
+{
   USB_Istr();
+}
 /*******************************************************************************
 * Function Name  : USB_FS_WKUP_IRQHandler
 * Description    : This function handles USB WakeUp interrupt request.
 * Input          : None
 * Output         : None
 * Return         : None
 *******************************************************************************/
 #if defined(STM32L1XX_MD) || defined(STM32L1XX_HD)|| defined(STM32L1XX_MD_PLUS)
 void USB_FS_WKUP_IRQHandler(void)
 #else
 void USBWakeUp_IRQHandler(void)
 #endif
+{
   EXTI_ClearITPendingBit(EXTI_Line18);
+}
 /******************************************************************************/
 /*                 STM32L1xx Peripherals Interrupt Handlers                   */
 /*  Add here the Interrupt Handler for the used peripheral(s) (PPP), for the  */
 /*  available peripheral interrupt handler's name please refer to the startup */
 /*  file (startup_stm32l1xx_xx.s).                                            */
 /******************************************************************************/
 /**
   * @brief  This function handles PPP interrupt request.
   * @param  None
   * @retval None
   */
 /*void PPP_IRQHandler(void)
+{
 }*/
 /**
   * @}
   */
 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

system_stm32l1xx.c

➞

Show inline comments

@@ @@ -281,116 +281,116 @@ void SystemCoreClockUpdate (void) @@
       break;
+  }
   /* Compute HCLK clock frequency --------------------------------------------*/
   /* Get HCLK prescaler */
   tmp = AHBPrescTable[((RCC->CFGR & RCC_CFGR_HPRE) >> 4)];
   /* HCLK clock frequency */
   SystemCoreClock >>= tmp;
+}
 /**
   * @brief  Configures the System clock frequency, AHB/APBx prescalers and Flash
   *         settings.
   * @note   This function should be called only once the RCC clock configuration
   *         is reset to the default reset state (done in SystemInit() function).
   * @param  None
   * @retval None
   */
 static void SetSysClock(void)
+{
   __IO uint32_t StartUpCounter = 0, HSEStatus = 0;
   /* SYSCLK, HCLK, PCLK2 and PCLK1 configuration ---------------------------*/
   /* Enable HSE */
   RCC->CR |= ((uint32_t)RCC_CR_HSEON);
   /* Wait till HSE is ready and if Time out is reached exit */
   do
+  {
     HSEStatus = RCC->CR & RCC_CR_HSERDY;
     StartUpCounter++;
   } while((HSEStatus == 0) && (StartUpCounter != HSE_STARTUP_TIMEOUT));
   if ((RCC->CR & RCC_CR_HSERDY) != RESET)
+  {
     HSEStatus = (uint32_t)0x01;
+  }
   else
+  {
     HSEStatus = (uint32_t)0x00;
+  }
   if (HSEStatus == (uint32_t)0x01)
+  {
     /* Enable 64-bit access */
     FLASH->ACR |= FLASH_ACR_ACC64;
     /* Enable Prefetch Buffer */
     FLASH->ACR |= FLASH_ACR_PRFTEN;
     /* Flash 1 wait state */
     FLASH->ACR |= FLASH_ACR_LATENCY;
     /* Power enable */
     RCC->APB1ENR |= RCC_APB1ENR_PWREN;
     /* Select the Voltage Range 1 (1.8 V) */
     PWR->CR = PWR_CR_VOS_0;
     /* Wait Until the Voltage Regulator is ready */
     while((PWR->CSR & PWR_CSR_VOSF) != RESET)
+    {
+    }
     /* HCLK = SYSCLK /1*/
     RCC->CFGR |= (uint32_t)RCC_CFGR_HPRE_DIV1;
     /* PCLK2 = HCLK /1*/
     RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE2_DIV1;
     /* PCLK1 = HCLK /1*/
     RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE1_DIV1;
     /*  PLL configuration */
     RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_PLLSRC | RCC_CFGR_PLLMUL |
                                         RCC_CFGR_PLLDIV));
     RCC->CFGR |= (uint32_t)(RCC_CFGR_PLLSRC_HSE | RCC_CFGR_PLLMUL24 | RCC_CFGR_PLLDIV3);
     /* Enable PLL */
     RCC->CR |= RCC_CR_PLLON;
     /* Wait till PLL is ready */
     while((RCC->CR & RCC_CR_PLLRDY) == 0)
+    {
+    }
     /* Select PLL as system clock source */
     RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_SW));
     RCC->CFGR |= (uint32_t)RCC_CFGR_SW_PLL;
     /* Wait till PLL is used as system clock source */
     while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS) != (uint32_t)RCC_CFGR_SWS_PLL)
+    {
+    }
+  }
   else
+  {
 	while(1);
+//	while(1);
     /* If HSE fails to start-up, the application will have wrong clock
        configuration. User can add here some code to deal with this error */
+  }
+}
 /**
   * @}
   */
 /**
   * @}
   */
 /**
   * @}
   */
 /******************* (C) COPYRIGHT 2013 STMicroelectronics *****END OF FILE****/

0 comments (0 inline, 0 general)