Need a working code for oled ssd1306 display for mikroC compiler

[khatus]

Hello guys i need a working code for oled ssd1306 display for mikroC compiler. I want to print something on the display screen. i am not a programming expert

Here is the working code for CCSC.But i need a code for mirkoc .Can anybody help me

Code: [Select]

#include <18F4550.h>
#device adc=10
#device PASS_STRINGS = IN_RAM
#fuses NOMCLR, NOWDT, NOPROTECT, NOLVP ,NOBROWNOUT
#use delay (clock=20,000000)
#use i2c(Master,Fast=400000,sda=PIN_B0,scl=PIN_B1,force_sw) // maybe force_hw
 
#include <string.h>
#define OLED 0x78
#INCLUDE <stdlib.h>
 
const BYTE TEXT[51][5] =
{
 
   0x00, 0x00, 0x00, 0x00, 0x00, // SPACE
   0x00, 0x00, 0x5F, 0x00, 0x00, // !
   0x00, 0x03, 0x00, 0x03, 0x00, // "
   0x14, 0x3E, 0x14, 0x3E, 0x14, // #
   0x24, 0x2A, 0x7F, 0x2A, 0x12, // $
   0x43, 0x33, 0x08, 0x66, 0x61, // %
   0x36, 0x49, 0x55, 0x22, 0x50, //&
   0x00, 0x05, 0x03, 0x00, 0x00, // '
   0x00, 0x1C, 0x22, 0x41, 0x00, // (
   0x00, 0x41, 0x22, 0x1C, 0x00, //)
   0x14, 0x08, 0x3E, 0x08, 0x14, // *
   0x08, 0x08, 0x3E, 0x08, 0x08, // +
   0x00, 0x50, 0x30, 0x00, 0x00, //,
   0x08, 0x08, 0x08, 0x08, 0x08, // -
   0x00, 0x60, 0x60, 0x00, 0x00, // .
   0x20, 0x10, 0x08, 0x04, 0x02, // /
   0x3E, 0x51, 0x49, 0x45, 0x3E, // 0
   0x04, 0x02, 0x7F, 0x00, 0x00, // 1
   0x42, 0x61, 0x51, 0x49, 0x46, // 2
   0x22, 0x41, 0x49, 0x49, 0x36, // 3
   0x18, 0x14, 0x12, 0x7F, 0x10, // 4
   0x27, 0x45, 0x45, 0x45, 0x39, // 5
   0x3E, 0x49, 0x49, 0x49, 0x32, // 6
   0x01, 0x01, 0x71, 0x09, 0x07, // 7
   0x36, 0x49, 0x49, 0x49, 0x36, // 8
   0x26, 0x49, 0x49, 0x49, 0x3E, // 9
   0x00, 0x36, 0x36, 0x00, 0x00, // :
   0x00, 0x56, 0x36, 0x00, 0x00, //;
 
   0x08, 0x14, 0x22, 0x41, 0x00, // <
   0x14, 0x14, 0x14, 0x14, 0x14, // =
   0x00, 0x41, 0x22, 0x14, 0x08, // >
   0x02, 0x01, 0x51, 0x09, 0x06, // ?
   0x3E, 0x41, 0x59, 0x55, 0x5E, // @
   0x7E, 0x09, 0x09, 0x09, 0x7E, // A
   0x7F, 0x49, 0x49, 0x49, 0x36, // B
   0x3E, 0x41, 0x41, 0x41, 0x22, // C
   0x7F, 0x41, 0x41, 0x41, 0x3E, // D
   0x7F, 0x49, 0x49, 0x49, 0x41, // E
   0x7F, 0x09, 0x09, 0x09, 0x01, // F
   0x3E, 0x41, 0x41, 0x49, 0x3A, // G
   0x7F, 0x08, 0x08, 0x08, 0x7F, // H
   0x00, 0x41, 0x7F, 0x41, 0x00, // I
   0x30, 0x40, 0x40, 0x40, 0x3F, // J
   0x7F, 0x08, 0x14, 0x22, 0x41, // K
   0x7F, 0x40, 0x40, 0x40, 0x40, // L
   0x7F, 0x02, 0x0C, 0x02, 0x7F, // M
   0x7F, 0x02, 0x04, 0x08, 0x7F, // N
   0x3E, 0x41, 0x41, 0x41, 0x3E, // O
   0x7F, 0x09, 0x09, 0x09, 0x06, // P
   0x1E, 0x21, 0x21, 0x21, 0x5E, // Q
   0x7F, 0x09, 0x09, 0x09, 0x76  // R
};
 
const BYTE TEXT2[44][5]=
{
   0x26, 0x49, 0x49, 0x49, 0x32, // S
   0x01, 0x01, 0x7F, 0x01, 0x01, // T
   0x3F, 0x40, 0x40, 0x40, 0x3F, // U
   0x1F, 0x20, 0x40, 0x20, 0x1F, // V
   0x7F, 0x20, 0x10, 0x20, 0x7F, // W
   0x41, 0x22, 0x1C, 0x22, 0x41, // X
   0x07, 0x08, 0x70, 0x08, 0x07, // Y
   0x61, 0x51, 0x49, 0x45, 0x43, // Z
   0x00, 0x7F, 0x41, 0x00, 0x00, // [
   0x02, 0x04, 0x08, 0x10, 0x20, // \
   0x00, 0x00, 0x41, 0x7F, 0x00, // ]
   0x04, 0x02, 0x01, 0x02, 0x04, // ^
   0x40, 0x40, 0x40, 0x40, 0x40, // _
   0x00, 0x01, 0x02, 0x04, 0x00, // `
   0x20, 0x54, 0x54, 0x54, 0x78, // a
   0x7F, 0x44, 0x44, 0x44, 0x38, // b
   0x38, 0x44, 0x44, 0x44, 0x44, // c
   0x38, 0x44, 0x44, 0x44, 0x7F, // d
   0x38, 0x54, 0x54, 0x54, 0x18, // e
   0x04, 0x04, 0x7E, 0x05, 0x05, // f
   0x08, 0x54, 0x54, 0x54, 0x3C, // g
   0x7F, 0x08, 0x04, 0x04, 0x78, // h
   0x00, 0x44, 0x7D, 0x40, 0x00, // i
   0x20, 0x40, 0x44, 0x3D, 0x00, // j
   0x7F, 0x10, 0x28, 0x44, 0x00, // k
   0x00, 0x41, 0x7F, 0x40, 0x00, // l
   0x7C, 0x04, 0x78, 0x04, 0x78, // m
   0x7C, 0x08, 0x04, 0x04, 0x78, // n
   0x38, 0x44, 0x44, 0x44, 0x38, // o
   0x7C, 0x14, 0x14, 0x14, 0x08, // p
   0x08, 0x14, 0x14, 0x14, 0x7C, // q
   0x00, 0x7C, 0x08, 0x04, 0x04, // r
   0x48, 0x54, 0x54, 0x54, 0x20, // s
   0x04, 0x04, 0x3F, 0x44, 0x44, // t
   0x3C, 0x40, 0x40, 0x20, 0x7C, // u
   0x1C, 0x20, 0x40, 0x20, 0x1C, // v
   0x3C, 0x40, 0x30, 0x40, 0x3C, // w
   0x44, 0x28, 0x10, 0x28, 0x44, // x
   0x0C, 0x50, 0x50, 0x50, 0x3C, // y
   0x44, 0x64, 0x54, 0x4C, 0x44, // z
   0x00, 0x08, 0x36, 0x41, 0x41, //{
   0x00, 0x00, 0x7F, 0x00, 0x00, //|
   0x41, 0x41, 0x36, 0x08, 0x00, //}
   0x02, 0x01, 0x02, 0x04, 0x02 // ~
 
};
 
int DISPLAY [1024];
 
void OLED_command(int ind, int com)
{
   i2c_start ();
   i2c_write (ind);
   i2c_write (0x00);
   i2c_write (com);
   i2c_stop ();
}
 
void OLED_write(INT ind)
{
   LONG i;
   OLED_command (ind, 0x21) ;
   OLED_command (ind, 0x00);
   OLED_command (ind, 127);
   OLED_command (ind, 0x22) ;
   OLED_command (ind, 0x00);
   OLED_command (ind, 7);
   i2c_start ();
   i2c_write (ind) ;
   i2c_write (0x40) ;
   FOR (i = 0; i < 1024; i++)
   {
   
      i2c_write (DISPLAY[I]) ;
   }
 
   i2c_stop ();
}
 
void  OLED_init(INT add)
{
   OLED_command (add, 0xae) ;
   OLED_command (add, 0xa8);
   OLED_command (add, 0x3f);
   OLED_command (add, 0xd3);
   OLED_command (add, 0x00);
   OLED_command (add, 0x40);
 
   OLED_command (add, 0xa0);
   OLED_command (add, 0xa1);
   OLED_command (add, 0xc0);
 
   OLED_command (add, 0xc8);
   OLED_command (add, 0xda);
   OLED_command (add, 0x12);
   OLED_command (add, 0x81);
   OLED_command (add, 0xfF);
   OLED_command (add, 0xa4);
   OLED_command (add, 0xa6) ;
   OLED_command (add, 0xd5);
   OLED_command (add, 0x80);
   OLED_command (add, 0x8d);
   OLED_command (add, 0x14) ;
   OLED_command (add, 0xAF) ;
   OLED_command (add, 0x20) ;
   OLED_command (add, 0x00) ;
}
 
void OLED_pixel(LONG x,long y)
{
   LONG nt;
   LONG pagina;
   LONG bit;
   pagina = y /8;
   bit= y-(pagina*8);
   nt= DISPLAY[pagina*128+x];
   nt |= 1 << bit;
   DISPLAY[pagina*128+x] = nt;
}
 
 
   Void OLED_text(int x, int y, char *textptr, int size)
   {
      int i, j, k, l, m;     // Loop counters
      BYTE pixelData[5];     // Stores character data
      for (i = 0; textptr[I] != '\0'; ++i, ++x) // Loop through the passed string
      {
         if (textptr[I] < 'S') // Checks if the letter is in the first text array
            memcpy (pixelData, TEXT[textptr[I] - ' '], 5) ;
 
         else if (textptr[I] <= '~') // Check if the letter is in the second array
            memcpy (pixelData, TEXT2[textptr[I] - 'S'], 5) ;
 
         else
         memcpy (pixelData, TEXT[0], 5); // DEFAULT to space
         if (x + 5 * size >= 128)  // Performs character wrapping
         {
            x = 0;       // Set x at far left position
            y += 7*size + 1;    // Set y at next position down
         }
 
         for (j = 0; j<5; ++j, x += size)  // Loop through character byte data
         {
            for (k = 0; k<7 * size; ++k)  // Loop through the vertical pixels
            {
               if (bit_test (pixelData[j], k)) // Check if the pixel should be set
               {
                  for (l = 0; l<size; ++l) // The next two loops change the
                  {
                     // character's size
                     for (m = 0; m<size; ++m)
                     {
                        OLED_pixel (x + m, y+k * size + l); // Draws the pixel
                     }
                  }
               }
            }
         }
      }
   }
 
 
 
   VOID OLED_clear()
   {
      LONG x;
      FOR (x = 0; x < 1024; x++)
      {
         DISPLAY[x] = 0x00;
      }
   }
 
   void main()
   {
      char txt[100];
      OLED_init(OLED);
      int16 value;
      setup_adc_ports(AN0);
      setup_adc(ADC_CLOCK_DIV_64);
      set_adc_channel(0);
      char str[20];
      WHILE (1)
      {
         OLED_clear();
         delay_us(12);
         value = read_adc();
         sprintf(str, "%lu", value);
         sprintf(txt,str);
         OLED_text(0,16,"Voltage",2);
         OLED_text(82,16,txt,2);
         OLED_text(0,33,"Current",2);
         OLED_text(82,33,txt,2);
         OLED_text(0,50,"Power",2);
         OLED_text(82,50,txt,2);
         OLED_write(OLED);
         delay_ms(300);
      }
   }

[Buriedcode]

MikroC compiler will accept standard C code.  As long as the code doesn't rely on any built-in libraries from other vendors I'm sure it will work just fine. 

It is also not necessarily a binary "use existing code" or "write completely from scratch".  You can adapt existing code for your own purposes. This way you don't have to trawl through the LCD controllers datasheet to find the initialization sequence, as most libraries already have that.

With that code, I believe the only changes required are to the lower level routines - the I2C based ones "void OLED_command" and "void OLED_write" as these can call mikroC's built-in I2C routines (the current code uses CSS I2C routines). Also, the first few lines are not required in MikroC as you configure the device and fuses/config in the project setup.
There may be other differences such as the size of variables like int, but for the most part, the bulk of the code should work just fine.

[hugo]

Just do a search for "ssd1306" @ https://libstock.mikroe.com

[Doctorandus_P]

Almost 20 years ago I stopped writing code for microcontrollers which used propietary compilers.
GCC is an excellent open source compilers and it works from small AVR's to lots of ARM processors from different vendors and also for big PC compilers.

It supports multiple (old and newer) variants of C and C++ upto the latest C++19 standards.
Why would you want to be messing around with and obscure and outdated proprietary compiler from some small company?

Take a step back and look at the big picture before you proceed.