Help needed to convert a code from one compiler to another for PIC mcu

Thread Starter

khatus

Joined Jul 2, 2018
89
C:
#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);
      }
   }
This was the code that i found in CCSC forum for OLED 128x64 SSD1306 I2C display. But now i want to convert it to mikroC for pic.But i am a programming expert.Can anyone in this group help me to convert it from CCSC to mikroc for pic??
 
Last edited by a moderator:

bertus

Joined Apr 5, 2008
20,881
Hello,

In the code these are given:
#include <18F4550.h>
#include <string.h>
#INCLUDE <stdlib.h>

These should be available, so the compiler can make use of them.

Bertus
 

Thread Starter

khatus

Joined Jul 2, 2018
89
C:
#include <stdint.h>
#include <string.h>
#define OLED 0x78
#include <stdlib.h>

const char 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 char 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)
{
   I2C1_Start();
   I2C1_Wr(ind);
   I2C1_Wr(0x00);
   I2C1_Wr(com);
   I2C1_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);
   I2C1_Start();
   I2C1_Wr(ind) ;
   I2C1_Wr(0x40) ;
   for (i = 0; i < 1024; i++)
   {

      I2C1_Wr(DISPLAY[I]) ;
   }

   I2C1_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 bi_t;
   pagina = y /8;
   bi_t= y-(pagina*8);
   nt= DISPLAY[pagina*128+x];
   nt |= 1 << bi_t;
   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);

      char str[20];
      while (1)
      {
         OLED_clear();
         delay_us(12);
         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);
      }
   }





Moderators note : Please use code tags for pieces of code.
 

Ian Rogers

Joined Dec 12, 2012
810
For those of you unfamiliar with MikroC…. It is NOT ansi standard... The headers are included by means of a large check box form.

You just delete the #include<xx.x> entries and check the relevant tick in the "Library Manager"..

C code is not really portable into MikroC, or out of it come to think of it.. MikroC doesn't care about case sensitivity so you cannot have a variable defined like this :-
int INT; most compilers will allow this, MikroC will not!
MikroC has its own memcpy() routine, so you'll have to figure that out..
I also think constants need a ROM qualifier, but I can't remember this either..

Once you delete the include statements and tick C_string and C_lib possible C_type in the library manager, you'll get a whole host of new errors...

See you in a bit!
 

JohnInTX

Joined Jun 26, 2012
4,344
I detailed and compiled the code in #8 in MikroC Ver. 6.00

A couple of things:
Turn on case-sensitivity in the project. Running C case-insensitive runs against the very essence of C and should not be done.

Note that MikroC includes library files by default so you don't have to do that.

Be sure to document what the PIC configuration fuzes are and put that in the source code as a comment as well as in the project config.

Case-sensitivity and library includes are defined in the project configuration windows.

One issue with MikroC is that many of the routines that require pointers like the LCD string routines AND memcpy don't support const (ROM) storage classes. You will get an invalid pointer conversion message. Other compilers handle it but I've not been able to do it with MikroC. I redefined the big font arrays to live in RAM. In the past, I've copied sections of ROM constants to a RAM buffer and gone from there. If someone knows a better way, I'd be interested too. I don't really do much with MikroC so haven't beat that one down.

This code compiles with the only error being that 'bit_test' is not present. You'll have to track that down or write one yourself.
C:
// NOTE: missing bit_test routine

// NOTE: MikroC includes these by default.
//#include <stdint.h>
//#include <string.h>
#define OLED 0x78
//#include <stdlib.h>

// NOTE: MikroC does not like pointer operations to ROM. You might be able
// to copy a character's worth of data to a RAM variable and operate on it
// there.
//const char TEXT[51][5] =
char 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
};

char 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)
{
  I2C1_Start();
  I2C1_Wr(ind);
  I2C1_Wr(0x00);
  I2C1_Wr(com);
  I2C1_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);
  I2C1_Start();
  I2C1_Wr(ind) ;
  I2C1_Wr(0x40) ;
  for (i = 0; i < 1024; i++)
  {

  I2C1_Wr(DISPLAY[i]) ;
  }

  I2C1_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 bi_t;
  pagina = y /8;
  bi_t= y-(pagina*8);
  nt= DISPLAY[pagina*128+x];
  nt |= 1 << bi_t;
  DISPLAY[pagina*128+x] = nt;
}


void OLED_text(int x, int y, char *textptr, int size)
  {
  int i, j, k, l, m;  // Loop counters
  unsigned char pixelData[5];  // Stores character data

//NOTE: fixed [I] for case sensitivity.  Turn case sensitivity ON in your project configuration
  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
// NOTE: memcpy wants variables in RAM, not ROM so you can't you const to declare the array
// NOTE: '&' to extract address of character data[i]
  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
  {
//NOTE: Need a bit_test routine
  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];
  //  char str[20];

  OLED_init(OLED);
  while (1)
  {
  OLED_clear();
  Delay_us(12);
  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);
  }
  }
Good luck!
 
Last edited:

Ian Rogers

Joined Dec 12, 2012
810
Evening John…. I see you have had the same experience I have had with MikroC..

Definitely a compiler that is once learnt never move to a new one... This definitely reminds me of Arduino programming...
 

JohnInTX

Joined Jun 26, 2012
4,344
Evening John…. I see you have had the same experience I have had with MikroC..
Definitely a compiler that is once learnt never move to a new one... This definitely reminds me of Arduino programming...
Good evening, Ian. Yeah, I found that out working with another member here passing strings to the MikroC LCD routines. Of course, he ran out of RAM for all of them and when we went to ROM, we got pointer errors. Based on examining the compiled code, we did what I described i.e. make a RAM buffer big enough for one operation then manually copy ROM->RAMbuffer then use the library routines.

Other compilers generate run-time code to figure out the instruction sequence to read either RAM or ROM - as you know, they are different, and it's transparent to the programmer. MikroC V6.00 just punts on that problem (and some others, too). I use it for quickie things where the extensive libraries come in handy but I use XC8 for PIC C. But mainly, I use assembler when it's time to get serious.

Have a good one.
 

Ian Rogers

Joined Dec 12, 2012
810
I use MikroC for pic32 and that has Flash so there are "special" routines to shift data... It is done in large amounts..

I didn't bother and just stuck on my usual FRAM via I2C all's good..
 

Thread Starter

khatus

Joined Jul 2, 2018
89
https://forum.mikroe.com/viewtopic.php?t=20874. I think there is a replacement for bit_test command in mikroc .But i don't know how to use them
Good evening, Ian. Yeah, I found that out working with another member here passing strings to the MikroC LCD routines. Of course, he ran out of RAM for all of them and when we went to ROM, we got pointer errors. Based on examining the compiled code, we did what I described i.e. make a RAM buffer big enough for one operation then manually copy ROM->RAMbuffer then use the library routines.

Other compilers generate run-time code to figure out the instruction sequence to read either RAM or ROM - as you know, they are different, and it's transparent to the programmer. MikroC V6.00 just punts on that problem (and some others, too). I use it for quickie things where the extensive libraries come in handy but I use XC8 for PIC C. But mainly, I use assembler when it's time to get serious.

Have a good one.
 

JohnInTX

Joined Jun 26, 2012
4,344
Here's the description from the CCS C manual describing how bit_test works. The bold code is what it does in C. I incorporated it into the bit_test function and added it to the code posted in #11.
bit_test( )
Syntax:
value = bit_test (var, bit)
Parameters:
var may be a 8,16 or 32 bit variable (any lvalue)
bit is a number 0- 31 representing a bit number, 0 is the least
significant bit.
Returns:
0 or 1
Function:
Tests the specified bit (0-7,0-15 or 0-31) in the given variable. The
least significant bit is 0. This function is much more efficient than, but
otherwise similar to:
((var & (1<<bit)) != 0)
Availability:
All devices
Requires: Nothing
Unfortunately, the code from #11 runs you out of RAM. That is a result of the big arrays needing to be in RAM unless you change how you fetch that data. The good news is that it looks like the DISPLAY array does not have to be 16-bit integers so I changed that to 8-bit unsigned chars. It compiles with no errors. I have no idea if it will work on the hardware.

RAM used: 1654 bytes (82%) Free RAM: 373 bytes (18%)
ROM used: 2799 (9%) Free ROM: 29969 (91%)
Compiled in FREE mode

Good luck!


C:
// NOTE: replaced missing bit_test routine
// NOTE: shrunk DISPLAY array 

// NOTE: MikroC includes these by default.
//#include <stdint.h>
//#include <string.h>
#define OLED 0x78
//#include <stdlib.h>

// NOTE: MikroC does not like pointer operations to ROM. You might be able
// to copy a character's worth of data to a RAM variable and operate on it
// there.
//const char TEXT[51][5] =
char 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
};

char 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 // ~

};
// NOTE: using int for DISPLAY runs you out of RAM.  It does not look like
// it needs a full 16bit integer (the I2C1_Wr routine uses single byte arguments)
// Give it a try.
//int DISPLAY [1024];
unsigned short DISPLAY [1024];

// NOTE: added this routine from the CCS C compiler manual.  It should work
// for byte data.
unsigned char bit_test(char v, unsigned char bitNum)
{
  return ((v & (1<<bitNum))!=0);
}

void OLED_command(int ind, int com)
{
  I2C1_Start();
  I2C1_Wr(ind);
  I2C1_Wr(0x00);
  I2C1_Wr(com);
  I2C1_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);
  I2C1_Start();
  I2C1_Wr(ind) ;
  I2C1_Wr(0x40) ;
  for (i = 0; i < 1024; i++)
  {

  I2C1_Wr(DISPLAY[i]) ;
  }

  I2C1_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 bi_t;
  pagina = y /8;
  bi_t= y-(pagina*8);
  nt= DISPLAY[pagina*128+x];
  nt |= 1 << bi_t;
  DISPLAY[pagina*128+x] = nt;
}


void OLED_text(int x, int y, char *textptr, int size)
  {
  int i, j, k, l, m;  // Loop counters
  unsigned char pixelData[5];  // Stores character data

//NOTE: fixed [I] for case sensitivity.  Turn case sensitivity ON in your project configuration
  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
// NOTE: memcpy wants variables in RAM, not ROM so you can't you const to declare the array
// NOTE: '&' to extract address of character data[i]
  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
  {
//NOTE: Need a bit_test routine
  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];
  //  char str[20];

  OLED_init(OLED);
  while (1)
  {
  OLED_clear();
  Delay_us(12);
  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);
  }
  }
 
Last edited:
Top