CCS C Software and Maintenance Offers
FAQFAQ   FAQForum Help   FAQOfficial CCS Support   SearchSearch  RegisterRegister 

ProfileProfile   Log in to check your private messagesLog in to check your private messages   Log inLog in 

CCS does not monitor this forum on a regular basis.

Please do not post bug reports on this forum. Send them to CCS Technical Support
SSD1306 4 Wire SPI OLED Library

 
Post new topic   Reply to topic    CCS Forum Index -> Code Library
View previous topic :: View next topic  
Author Message
sshahryiar



Joined: 05 May 2010
Posts: 94
Location: Dhaka, Bangladesh

View user's profile Send private message Send e-mail Visit poster's website

SSD1306 4 Wire SPI OLED Library
PostPosted: Tue Apr 28, 2015 9:53 am     Reply with quote
SSD1306.h

Code:
#define D0 pin_B0
#define D1    pin_B1 
#define RST pin_B2   
#define DC  pin_B3               
#define SCL D0
#define SDA D1
                                                 
#define DAT TRUE
#define CMD FALSE
                                                                       
#define Set_Lower_Column_Start_Address_CMD 0x00
#define Set_Higher_Column_Start_Address_CMD 0x10
#define Set_Memory_Addressing_Mode_CMD 0x20
#define Set_Column_Address_CMD 0x21
#define Set_Page_Address_CMD 0x22
#define Set_Display_Start_Line_CMD 0x40 
#define Set_Contrast_Control_CMD 0x81
#define Set_Charge_Pump_CMD 0x8D
#define Set_Segment_Remap_CMD 0xA0   
#define Set_Entire_Display_ON_CMD 0xA4   
#define Set_Normal_or_Inverse_Display_CMD 0xA6
#define Set_Multiplex_Ratio_CMD 0xA8
#define Set_Display_ON_or_OFF_CMD 0xAE
#define Set_Page_Start_Address_CMD 0xB0 
#define Set_COM_Output_Scan_Direction_CMD 0xC0
#define Set_Display_Offset_CMD 0xD3 
#define Set_Display_Clock_CMD 0xD5 
#define Set_Pre_charge_Period_CMD 0xD9
#define Set_Common_HW_Config_CMD 0xDA
#define Set_VCOMH_Level_CMD 0xDB 
#define Set_NOP_CMD 0xE3       

#define Horizontal_Addressing_Mode 0x00
#define Vertical_Addressing_Mode 0x01     
#define Page_Addressing_Mode 0x02

#define Disable_Charge_Pump 0x00
#define Enable_Charge_Pump 0x04
                                                                             
#define Column_Address_0_Mapped_to_SEG0 0x00
#define Column_Address_0_Mapped_to_SEG127 0x01

#define Normal_Display 0x00
#define Entire_Display_ON 0x01
                                                   
#define Non_Inverted_Display 0x00
#define Inverted_Display 0x01   
                                               
#define Display_OFF 0x00 
#define Display_ON 0x01

#define Scan_from_COM0_to_63 0x00   
#define Scan_from_COM63_to_0 0x08
                                                 
                 
#use FAST_IO(B)


void OLED_init();
void OLED_write(unsigned char value, short type);               
void OLED_gotoxy(unsigned char x_pos, unsigned char y_pos);
void OLED_fill(unsigned char bmp_data);
void OLED_clear_screen();
void OLED_set_start_column(unsigned char n);
void OLED_set_addressing_mode(unsigned char n);                 
void OLED_set_column_address(unsigned char r, unsigned char t);
void OLED_set_page_address(unsigned char r, unsigned char t); 
void OLED_set_start_line(unsigned char n);
void OLED_set_contrast(unsigned char n); 
void OLED_set_charge_pump(unsigned char n);
void OLED_set_segment_remap(unsigned char n);
void OLED_set_entire_display_on(unsigned char n);
void OLED_set_normal_or_inverse_display(unsigned char n);
void OLED_set_multiplex_ratio(unsigned char n);
void OLED_set_display_on_off(unsigned char n);
void OLED_set_start_page(unsigned char n);
void OLED_set_common_output_scan_direction(unsigned char n);
void OLED_set_display_offset(unsigned char n);   
void OLED_set_display_clock(unsigned char n);
void OLED_set_precharge_period(unsigned char n);
void OLED_set_common_config(unsigned char n);
void OLED_set_VCOMH(unsigned char n);                                 
void OLED_set_NOP();
void OLED_cursor(unsigned char x_pos, unsigned char y_pos);
void OLED_print_char(unsigned char x_pos, unsigned char y_pos, unsigned char ch);
void OLED_print_string(unsigned char x_pos, unsigned char y_pos, unsigned char *ch);
void OLED_draw_bitmap(unsigned char xb, unsigned char yb, unsigned char xe, unsigned char ye, unsigned char *bmp);
void OLED_print_chr(unsigned char x_pos, unsigned char y_pos, signed char value);
void OLED_print_int(unsigned char x_pos, unsigned char y_pos, signed long value);
void OLED_print_decimal(unsigned char x_pos, unsigned char y_pos, unsigned long value, unsigned char points);
void OLED_print_float(unsigned char x_pos, unsigned char y_pos, float value, unsigned char points); 


SSD1306.c

Code:
#include "SSD1306.h"   
#include "fonts.c"


void OLED_init()
{
   set_TRIS_B(0xF0);         
   port_B_pullups(FALSE);
   output_high(D0);
   output_low(RST);
   delay_ms(60);
   output_high(RST); 
           
   OLED_set_display_on_off(0x00);   
   OLED_set_display_clock(0x80);       
   OLED_set_multiplex_ratio(0x3F);                        
   OLED_set_display_offset(0x00);      
   OLED_set_start_line(0x00);         
   OLED_set_charge_pump(Enable_Charge_Pump);       
   OLED_set_addressing_mode(Page_Addressing_Mode);    
   OLED_set_segment_remap(Column_Address_0_Mapped_to_SEG127);       
       OLED_set_common_output_scan_direction(Scan_from_COM63_to_0);   
   OLED_set_common_config(0x10);    
   OLED_set_contrast(0xCF);                                         
   OLED_set_precharge_period(0xF1);   
   OLED_set_VCOMH(0x40);          
   OLED_set_entire_display_on(Normal_Display);                       
   OLED_set_normal_or_inverse_display(Non_Inverted_Display);                                  
   OLED_set_display_on_off(Display_ON);           
   OLED_fill(0x00);                       
   OLED_gotoxy(0,0);                                                    
}     


void OLED_write(unsigned char value, short type)
{
   unsigned char s = 8;
   
    switch(type)
    {
        case 1:
        {   
            output_high(DC);   
            break;
        } 
        default:
        {
            output_low(DC);   
            break;
        }
    }   

    output_low(D0);     
         
   while(s > 0)
   {                                                                                 
      if((value & 0x80) != 0)                 
      {
         output_high(D1); ;
      }
      else
      {
         output_low(D1);                                                         
      }
               
        output_high(D0); 
        output_low(D0);
                                                             
      value <<= 1; 
      s -= 1;
   }                                                             
} 


void OLED_gotoxy(unsigned char x_pos, unsigned char y_pos)
{                                   
   OLED_write((Set_Page_Start_Address_CMD + y_pos), CMD);
   OLED_write(((x_pos & 0x0F) | Set_Lower_Column_Start_Address_CMD), CMD);
   OLED_write((((x_pos & 0xF0) >> 0x04) | Set_Higher_Column_Start_Address_CMD), CMD); 
}


void OLED_fill(unsigned char bmp_data)
{                                                     
   unsigned char x_pos = 0;                          
   unsigned char page = 0;                                                             
   
   for(page = 0; page <= 7; page++)
   {   
      OLED_write((Set_Page_Start_Address_CMD + page), CMD); 
      OLED_write(Set_Lower_Column_Start_Address_CMD, CMD);   
      OLED_write(Set_Higher_Column_Start_Address_CMD, CMD);
      
      for(x_pos = 0; x_pos <= 127; x_pos++)   
      {                                   
         OLED_write(bmp_data, DAT);
      }                   
   }   
}


void OLED_clear_screen()
{
   OLED_fill(0x00);
}


void OLED_set_start_column(unsigned char n)
{       
   OLED_write(Set_Lower_Column_Start_Address_CMD + (n % 16), CMD);   
   OLED_write(Set_Higher_Column_Start_Address_CMD + (n / 16), CMD);   
}

   
void OLED_set_addressing_mode(unsigned char n) 
{
   OLED_write(Set_Memory_Addressing_Mode_CMD, CMD);      
   OLED_write(n, CMD);         
}


void OLED_set_column_address(unsigned char r, unsigned char t)
{             
   OLED_write(Set_Column_Address_CMD, CMD);      
   OLED_write(r, CMD);         
   OLED_write(t, CMD);         
}   


void OLED_set_page_address(unsigned char r, unsigned char t)
{
   OLED_write(Set_Page_Address_CMD, CMD);      
   OLED_write(r, CMD);         
   OLED_write(t, CMD);    
} 

                                                               
void OLED_set_start_line(unsigned char n)
{                                     
   OLED_write((Set_Display_Start_Line_CMD | n), CMD);      
} 


void OLED_set_contrast(unsigned char n)
{             
   OLED_write(Set_Contrast_Control_CMD, CMD);      
   OLED_write(n, CMD);         
}


void OLED_set_charge_pump(unsigned char n)
{
   OLED_write(Set_Charge_Pump_CMD, CMD);            
   OLED_write((Set_Higher_Column_Start_Address_CMD | n), CMD);      
}   

       
void OLED_set_segment_remap(unsigned char n)
{                 
   OLED_write((Set_Segment_Remap_CMD | n), CMD);
}               


void OLED_set_entire_display_on(unsigned char n)
{
   OLED_write((Set_Entire_Display_ON_CMD | n), CMD);
}   
                                       
             
void OLED_set_normal_or_inverse_display(unsigned char n)
{
   OLED_write((Set_Normal_or_Inverse_Display_CMD | n), CMD);      
   
}       


void OLED_set_multiplex_ratio(unsigned char n)
{   
   OLED_write(Set_Multiplex_Ratio_CMD, CMD);      
   OLED_write(n, CMD);       
}         

                                                               
void OLED_set_display_on_off(unsigned char n)
{                   
   OLED_write((Set_Display_ON_or_OFF_CMD + n) , CMD);      
}             

               
void OLED_set_start_page(unsigned char n)
{
   OLED_write((Set_Page_Start_Address_CMD | n), CMD);      
}     


void OLED_set_common_output_scan_direction(unsigned char n)
{
   OLED_write((Set_COM_Output_Scan_Direction_CMD | n), CMD); 
}     

                                                                   
void OLED_set_display_offset(unsigned char n)
{   
   OLED_write(Set_Display_Offset_CMD, CMD);            
   OLED_write(n, CMD);         
}                           

   
void OLED_set_display_clock(unsigned char n)
{
   OLED_write(Set_Display_Clock_CMD, CMD);            
   OLED_write(n, CMD);      
}       


void OLED_set_precharge_period(unsigned char n)
{
   OLED_write(Set_Pre_charge_Period_CMD, CMD);            
   OLED_write(n, CMD);    
}                                                                       
     
     
void OLED_set_common_config(unsigned char n)
{
   OLED_write(Set_Common_HW_Config_CMD, CMD);         
   OLED_write((0x02 | n), CMD);                           
}

                                                                                                                                                           
void OLED_set_VCOMH(unsigned char n)
{                                         
   OLED_write(Set_VCOMH_Level_CMD, CMD);            
   OLED_write(n, CMD);                          
}
 
                                                                         
void OLED_set_NOP() 
{
   OLED_write(Set_NOP_CMD, CMD);     
}   


void OLED_cursor(unsigned char x_pos, unsigned char y_pos)
{   
   unsigned char i = 0;
   
   if(y_pos != 0)
   {
      if(x_pos == 1)
      {
         OLED_gotoxy(0x00, (y_pos + 0x02));
      }
      else 
      {
         OLED_gotoxy((0x50 + ((x_pos - 0x02) * 0x06)), (y_pos + 0x02));
      } 
      
       for(i = 0; i < 6; i++) 
       {
           OLED_write(0xFF, DAT);
       }            
   }
 } 
       
                   
void OLED_print_char(unsigned char x_pos, unsigned char y_pos, unsigned char ch)
{
    unsigned char chr = 0;
    unsigned char i = 0;
      
   chr = (ch - 32); 
   
   if(x_pos > 122)
   {
      x_pos = 0; 
      y_pos++;
   }     
   OLED_gotoxy(x_pos, y_pos); 
   
   for(i = 0; i < 6; i++)             
   {                   
      OLED_write(font_regular[chr][i], DAT);     
   }                                                           
}
 

void OLED_print_string(unsigned char x_pos, unsigned char y_pos, unsigned char *ch)
{
   unsigned char chr = 0;
   unsigned char i = 0;
    unsigned char j = 0; 
                              
   while(ch[j] != '\0')
   {     
      chr = (ch[j] - 32);
      
      if(x_pos > 126)
      {                   
         x_pos = 0;
         y_pos++;
      }
      OLED_gotoxy(x_pos, y_pos); 
   
      for(i = 0; i < 6; i++)     
      {                   
         OLED_write(font_regular[chr][i], DAT); 
      }
      
      j++;
      x_pos += 6;
   }
}   
                                                     
   
void OLED_draw_bitmap(unsigned char xb, unsigned char yb, unsigned char xe, unsigned char ye, unsigned char *bmp)   
{   
   unsigned long i = 0;
   unsigned char x_pos = 0;
   unsigned char y_pos = 0;
                      
   for(y_pos = yb; y_pos <= ye; y_pos++)
   {                                           
      OLED_gotoxy(xb, y_pos);            
      for(x_pos = xb; x_pos < xe; x_pos++)
      {                               
         OLED_write((bmp[i]), DAT);
         i++;
      }
   }
}
                                             
                     
void OLED_print_chr(unsigned char x_pos, unsigned char y_pos, signed char value)
{                                             
   unsigned char ch = 0;                     
      
   if(value < 0)   
   {
      OLED_print_char(x_pos, y_pos, '-');
      value = -value;                  
   }
   else
   {
      OLED_print_char(x_pos, y_pos,' ');
   }                     
                        
   ch = (value / 100);
   OLED_print_char((x_pos + 6), y_pos , (48 + ch));     
   
   ch = ((value % 100) / 10);                             
   OLED_print_char((x_pos + 12), y_pos , (48 + ch));
   
   ch = (value % 10);             
   OLED_print_char((x_pos + 18), y_pos , (48 + ch));     
}


void OLED_print_int(unsigned char x_pos, unsigned char y_pos, signed long value)
{
   unsigned char ch = 0;                     
      
   if(value < 0)   
   {
      OLED_print_char(x_pos, y_pos, '-');
      value = -value;                  
   }
   else
   {                                             
      OLED_print_char(x_pos, y_pos,' ');
   } 
   
   if(value > 9999)
   {               
      ch = (value / 10000);
      OLED_print_char((x_pos + 6), y_pos , (48 + ch));
      
      ch = ((value % 10000)/ 1000);
      OLED_print_char((x_pos + 12), y_pos , (48 + ch));
      
      ch = ((value % 1000) / 100);                           
      OLED_print_char((x_pos + 18), y_pos , (48 + ch));       
                               
      ch = ((value % 100) / 10);         
      OLED_print_char((x_pos + 24), y_pos , (48 + ch));
                               
      ch = (value % 10); 
      OLED_print_char((x_pos + 30), y_pos , (48 + ch));   
   }   
   
   else if((value > 999) && (value <= 9999))
   {     
      ch = ((value % 10000)/ 1000);
      OLED_print_char((x_pos + 6), y_pos , (48 + ch));
      
      ch = ((value % 1000) / 100);                           
      OLED_print_char((x_pos + 12), y_pos , (48 + ch));       
                               
      ch = ((value % 100) / 10);         
      OLED_print_char((x_pos + 18), y_pos , (48 + ch));
                               
      ch = (value % 10); 
      OLED_print_char((x_pos + 24), y_pos , (48 + ch));   
   }                 
   else if((value > 99) && (value <= 999))
   {     
      ch = ((value % 1000) / 100);                                             
      OLED_print_char((x_pos + 6), y_pos , (48 + ch));       
                               
      ch = ((value % 100) / 10);         
      OLED_print_char((x_pos + 12), y_pos , (48 + ch));
                               
      ch = (value % 10);                                                               
      OLED_print_char((x_pos + 18), y_pos , (48 + ch));   
   }     
   else if((value > 9) && (value <= 99))
   {                                   
      ch = ((value % 100) / 10);         
      OLED_print_char((x_pos + 12), y_pos , (48 + ch));
                               
      ch = (value % 10); 
      OLED_print_char((x_pos + 18), y_pos , (48 + ch));   
   }
   else
   {                                                           
      ch = (value % 10); 
      OLED_print_char((x_pos + 18), y_pos , (48 + ch));   
   }
}                                                     


void OLED_print_decimal(unsigned char x_pos, unsigned char y_pos, unsigned long value, unsigned char points)
{
   unsigned char ch = 0;                                                                 
              
   OLED_print_char(x_pos, y_pos, '.'); 
   
   ch = (value / 1000);
   OLED_print_char((x_pos + 6), y_pos , (48 + ch));
   
   if(points > 1)
   { 
      ch = ((value % 1000) / 100);
      OLED_print_char((x_pos + 12), y_pos , (48 + ch));   
      
           
      if(points > 2)
      {   
         ch = ((value % 100) / 10);
         OLED_print_char((x_pos + 18), y_pos , (48 + ch));     
         
         if(points > 3)
         {   
            ch = (value % 10);
            OLED_print_char((x_pos + 24), y_pos , (48 + ch));
         }                                                                                                             
      }
   }
}
 
                             
void OLED_print_float(unsigned char x_pos, unsigned char y_pos, float value, unsigned char points)
{                                                   
   signed long tmp = 0;                                                                             
                                                                                                          
   OLED_print_int(x_pos, y_pos, value);     
   tmp = value;
   tmp = abs((value - tmp) * 10000);
                                             
   if((abs(value) >= 9999) && (abs(value) < 99999))                       
   {                                                                                 
      OLED_print_decimal((x_pos + 36), y_pos, tmp, points);                                     
   }                                                                                           
   else if((abs(value) >= 999) && (abs(value) < 9999))                                             
   {                                       
      OLED_print_decimal((x_pos + 30), y_pos, tmp, points);                             
   }                                                                       
   else if((abs(value) >= 99) && (abs(value) < 999))
   {                   
      OLED_print_decimal((x_pos + 24), y_pos, tmp, points);                     
   }           
   else if((abs(value) >= 9) && (abs(value) < 99)) 
   {                                               
      OLED_print_decimal((x_pos + 18), y_pos, tmp, points);                                                               
   }       
   else if((abs(value) >= 0.00009) && (abs(value) < 9))   
   {                                                               
      OLED_print_decimal((x_pos + 12), y_pos, tmp, points);
   }
}                                                               



fonts.c

Code:

const unsigned char font_regular[92][6] =
{                       
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   // sp
     0x00, 0x00, 0x00, 0x2f, 0x00, 0x00,   // !
     0x00, 0x00, 0x07, 0x00, 0x07, 0x00,   // "
     0x00, 0x14, 0x7f, 0x14, 0x7f, 0x14,   // #
     0x00, 0x24, 0x2a, 0x7f, 0x2a, 0x12,   // $
     0x00, 0x62, 0x64, 0x08, 0x13, 0x23,   // %             
     0x00, 0x36, 0x49, 0x55, 0x22, 0x50,   // &
     0x00, 0x00, 0x05, 0x03, 0x00, 0x00,   // '
     0x00, 0x00, 0x1c, 0x22, 0x41, 0x00,   // (
     0x00, 0x00, 0x41, 0x22, 0x1c, 0x00,   // )
     0x00, 0x14, 0x08, 0x3E, 0x08, 0x14,   // *
     0x00, 0x08, 0x08, 0x3E, 0x08, 0x08,   // +
     0x00, 0x00, 0x00, 0xA0, 0x60, 0x00,   // ,
     0x00, 0x08, 0x08, 0x08, 0x08, 0x08,   // -
     0x00, 0x00, 0x60, 0x60, 0x00, 0x00,   // .
     0x00, 0x20, 0x10, 0x08, 0x04, 0x02,   // /
     0x00, 0x3E, 0x51, 0x49, 0x45, 0x3E,   // 0
     0x00, 0x00, 0x42, 0x7F, 0x40, 0x00,   // 1
     0x00, 0x42, 0x61, 0x51, 0x49, 0x46,   // 2
     0x00, 0x21, 0x41, 0x45, 0x4B, 0x31,   // 3
     0x00, 0x18, 0x14, 0x12, 0x7F, 0x10,   // 4
     0x00, 0x27, 0x45, 0x45, 0x45, 0x39,   // 5
     0x00, 0x3C, 0x4A, 0x49, 0x49, 0x30,   // 6
     0x00, 0x01, 0x71, 0x09, 0x05, 0x03,   // 7
     0x00, 0x36, 0x49, 0x49, 0x49, 0x36,   // 8
     0x00, 0x06, 0x49, 0x49, 0x29, 0x1E,   // 9
     0x00, 0x00, 0x36, 0x36, 0x00, 0x00,   // :
     0x00, 0x00, 0x56, 0x36, 0x00, 0x00,   // ;
     0x00, 0x08, 0x14, 0x22, 0x41, 0x00,   // <
     0x00, 0x14, 0x14, 0x14, 0x14, 0x14,   // =
     0x00, 0x00, 0x41, 0x22, 0x14, 0x08,   // >
     0x00, 0x02, 0x01, 0x51, 0x09, 0x06,   // ?
     0x00, 0x32, 0x49, 0x59, 0x51, 0x3E,   // @
     0x00, 0x7C, 0x12, 0x11, 0x12, 0x7C,   // A
     0x00, 0x7F, 0x49, 0x49, 0x49, 0x36,   // B
     0x00, 0x3E, 0x41, 0x41, 0x41, 0x22,   // C
     0x00, 0x7F, 0x41, 0x41, 0x22, 0x1C,   // D
     0x00, 0x7F, 0x49, 0x49, 0x49, 0x41,   // E
     0x00, 0x7F, 0x09, 0x09, 0x09, 0x01,   // F
     0x00, 0x3E, 0x41, 0x49, 0x49, 0x7A,   // G
     0x00, 0x7F, 0x08, 0x08, 0x08, 0x7F,   // H
     0x00, 0x00, 0x41, 0x7F, 0x41, 0x00,   // I
     0x00, 0x20, 0x40, 0x41, 0x3F, 0x01,   // J
     0x00, 0x7F, 0x08, 0x14, 0x22, 0x41,   // K
     0x00, 0x7F, 0x40, 0x40, 0x40, 0x40,   // L
     0x00, 0x7F, 0x02, 0x0C, 0x02, 0x7F,   // M
     0x00, 0x7F, 0x04, 0x08, 0x10, 0x7F,   // N
     0x00, 0x3E, 0x41, 0x41, 0x41, 0x3E,   // O
     0x00, 0x7F, 0x09, 0x09, 0x09, 0x06,   // P
     0x00, 0x3E, 0x41, 0x51, 0x21, 0x5E,   // Q
     0x00, 0x7F, 0x09, 0x19, 0x29, 0x46,   // R
     0x00, 0x46, 0x49, 0x49, 0x49, 0x31,   // S
     0x00, 0x01, 0x01, 0x7F, 0x01, 0x01,   // T
     0x00, 0x3F, 0x40, 0x40, 0x40, 0x3F,   // U
     0x00, 0x1F, 0x20, 0x40, 0x20, 0x1F,   // V
     0x00, 0x3F, 0x40, 0x38, 0x40, 0x3F,   // W
     0x00, 0x63, 0x14, 0x08, 0x14, 0x63,   // X
     0x00, 0x07, 0x08, 0x70, 0x08, 0x07,   // Y
     0x00, 0x61, 0x51, 0x49, 0x45, 0x43,   // Z
     0x00, 0x00, 0x7F, 0x41, 0x41, 0x00,   // [ 91
     0x00, 0x02, 0x04 , 0x08, 0x10, 0x20,    // \92
     0x00, 0x00, 0x41, 0x41, 0x7F, 0x00,   // ]
     0x00, 0x04, 0x02, 0x01, 0x02, 0x04,   // ^
     0x00, 0x40, 0x40, 0x40, 0x40, 0x40,   // _
     0x00, 0x00, 0x01, 0x02, 0x04, 0x00,   // '
     0x00, 0x20, 0x54, 0x54, 0x54, 0x78,   // a
     0x00, 0x7F, 0x48, 0x44, 0x44, 0x38,   // b
     0x00, 0x38, 0x44, 0x44, 0x44, 0x20,   // c
     0x00, 0x38, 0x44, 0x44, 0x48, 0x7F,   // d
     0x00, 0x38, 0x54, 0x54, 0x54, 0x18,   // e
     0x00, 0x08, 0x7E, 0x09, 0x01, 0x02,   // f
     0x00, 0x18, 0xA4, 0xA4, 0xA4, 0x7C,   // g
     0x00, 0x7F, 0x08, 0x04, 0x04, 0x78,   // h
     0x00, 0x00, 0x44, 0x7D, 0x40, 0x00,   // i
     0x00, 0x40, 0x80, 0x84, 0x7D, 0x00,   // j
     0x00, 0x7F, 0x10, 0x28, 0x44, 0x00,   // k
     0x00, 0x00, 0x41, 0x7F, 0x40, 0x00,   // l
     0x00, 0x7C, 0x04, 0x18, 0x04, 0x78,   // m
     0x00, 0x7C, 0x08, 0x04, 0x04, 0x78,   // n
     0x00, 0x38, 0x44, 0x44, 0x44, 0x38,   // o
     0x00, 0xFC, 0x24, 0x24, 0x24, 0x18,   // p
     0x00, 0x18, 0x24, 0x24, 0x18, 0xFC,   // q
     0x00, 0x7C, 0x08, 0x04, 0x04, 0x08,   // r
     0x00, 0x48, 0x54, 0x54, 0x54, 0x20,   // s
     0x00, 0x04, 0x3F, 0x44, 0x40, 0x20,   // t
     0x00, 0x3C, 0x40, 0x40, 0x20, 0x7C,   // u
     0x00, 0x1C, 0x20, 0x40, 0x20, 0x1C,   // v
     0x00, 0x3C, 0x40, 0x30, 0x40, 0x3C,   // w                           
     0x00, 0x44, 0x28, 0x10, 0x28, 0x44,   // x
     0x00, 0x1C, 0xA0, 0xA0, 0xA0, 0x7C,   // y
     0x00, 0x44, 0x64, 0x54, 0x4C, 0x44,   // z
     0x14, 0x14, 0x14, 0x14, 0x14, 0x14    // horizontal lines
};       



Example:

Code:
#include <16F876A.h>


#device *= 16

             
#fuses NOWDT, HS, PROTECT, CPD, PUT, BROWNOUT
               
                                       
#use delay (clock = 10MHz)


#include "SSD1306.c"
         


void setup();


void main()
{
   signed long i = -9;
   float f = 0;
              
   setup();
   
   while(TRUE)   
   { 
      f += 1.1;
      i++;
      if(i > 1000)
      {
         i = -9;
         f = 0;                                                                                                                             
      }
      
      OLED_print_float(1, 4, f, 1);                                                   
      OLED_print_int(1, 5, i);
      delay_ms(600);                                                       
   };                                                 
}                       
                               
                                                                                           
void setup()
{
    char text[] = {"MicroArena"};
   
    disable_interrupts(global);   
    setup_comparator(NC_NC_NC_NC);
    setup_ADC(ADC_off);
    setup_ADC_ports(no_analogs);
    setup_CCP1(CCP_off);   
    setup_CCP2(CCP_off);
    setup_SPI(SPI_disabled | SPI_SS_disabled);         
    setup_timer_0(T0_internal);
    setup_timer_1(T1_disabled); 
    setup_timer_2(T2_disabled, 255, 1);
    set_timer0(0);
    set_timer1(0);                                     
    set_timer2(0);                                         
    OLED_init();   
    OLED_print_string(34, 2, text); 
}


https://www.youtube.com/watch?v=w4L1xaYNdDw
_________________
https://www.facebook.com/MicroArena

SShahryiar

Last edited by sshahryiar on Sun Jul 05, 2015 10:35 pm; edited 1 time in total
asmboy



Joined: 20 Nov 2007
Posts: 2128
Location: albany ny

View user's profile Send private message AIM Address

PostPosted: Fri May 01, 2015 8:49 am     Reply with quote
Quote:

output_highuy��0);

nonsense line DOES NOT compile .........

also the use of defined CMD and DAT might be more
readable as just '1' and '0'
amanver



Joined: 06 May 2015
Posts: 4
Location: bonab

View user's profile Send private message

bitmap
PostPosted: Sun Jul 05, 2015 5:46 am     Reply with quote
what is the parameter of draw_bitmap func?
gkrusi



Joined: 07 Aug 2015
Posts: 1

View user's profile Send private message Visit poster's website

PostPosted: Fri Aug 07, 2015 5:51 am     Reply with quote
Thank you for this code!

I only removed #use FAST_IO(B) and port B definitions from the code and added chip select managment in OLED_write function.

Very Happy
Display posts from previous:   
Post new topic   Reply to topic    CCS Forum Index -> Code Library All times are GMT - 6 Hours
Page 1 of 1

 
Jump to:  
You cannot post new topics in this forum
You cannot reply to topics in this forum
You cannot edit your posts in this forum
You cannot delete your posts in this forum
You cannot vote in polls in this forum


Powered by phpBB © 2001, 2005 phpBB Group