« previous next »
Pages: [1]   Go Down

Author Topic: Help needed to convert a code from one compiler to another for PIC mcu  (Read 975 times)

0 Members and 1 Guest are viewing this topic.

Offline khatusTopic starter

  • Regular Contributor
  • *
  • Posts: 147
  • Country: gl
Help needed to convert a code from one compiler to another for PIC mcu
« on: March 27, 2019, 03:05:22 pm »
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);
      }
   }

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 CCS to mikroc for pic??
Logged
 

Offline MarkF

  • Super Contributor
  • ***
  • Posts: 2647
  • Country: us
Re: Help needed to convert a code from one compiler to another for PIC mcu
« Reply #1 on: March 27, 2019, 03:22:28 pm »
Do you want to keep it as I2C or use SPI?

I wrote a library for a SSD1351 OLED (128x96) that uses SPI that would probably work with minor changes.
It writes directly to the display memory so you don't need MCU RAM.
« Last Edit: October 23, 2020, 04:07:02 am by MarkF »
Logged
 

Offline khatusTopic starter

  • Regular Contributor
  • *
  • Posts: 147
  • Country: gl
Re: Help needed to convert a code from one compiler to another for PIC mcu
« Reply #2 on: March 27, 2019, 03:31:13 pm »
I want to keep it as I2C. But how can i use it in my code??
Logged
 

Offline Nerull

  • Frequent Contributor
  • **
  • Posts: 694
Re: Help needed to convert a code from one compiler to another for PIC mcu
« Reply #3 on: March 27, 2019, 03:55:45 pm »
You need to replace the i2c and and adc functions from CCS and use the equiavlent functions from the mikroc library, or just write the registers directly.

https://download.mikroe.com/documents/compilers/mikroc/pic/help/i2c_library.htm
https://download.mikroe.com/documents/compilers/mikroc/pic/help/adc_library.htm
Logged
 

Offline khatusTopic starter

  • Regular Contributor
  • *
  • Posts: 147
  • Country: gl
Re: Help needed to convert a code from one compiler to another for PIC mcu
« Reply #4 on: March 27, 2019, 04:02:25 pm »
Code: [Select]
#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);
      }
   }

It shows the following error



Logged
 

Offline MarkF

  • Super Contributor
  • ***
  • Posts: 2647
  • Country: us
Re: Help needed to convert a code from one compiler to another for PIC mcu
« Reply #5 on: March 27, 2019, 04:04:30 pm »
I would need to study the datasheet to see how different the commands are since the the SSD1306 is B/W and the SSD1351 is color.
The SPI in my library is pretty confined and would need to be replaced with I2C commands.

In OLED.h:
   Change the PIC assignment pins
   Replace SSD1351 command definitions

See in OLED.c:
   oledCmd()
   oledDat()
   oledSetup()
   oledClear()
   oledHorizLine()
   oledVertLine()
   oledRectFill()

The SPI commands are basically repeated in each.  So, when you convert one to I2C, you just cut-and-paste all the others.
The oledSetup() would probably be hit the hardest.
I'm guessing the color to B/W could just be modifying the ORGB() function to do gray scale.

----------------------------

I wouldn't mind having a SSD1306 B/W library if you're not in a hurry and can wait for me to make the changes.
F.Y.I.  I have not done I2C but it's on my TODO list.

Edit-  I use MPLAB X and XC8

----------------------------

You can take a look at the Adafruit code but it's not for a PIC.  https://github.com/adafruit/Adafruit_SSD1306
« Last Edit: March 27, 2019, 04:08:42 pm by MarkF »
Logged
 
Pages: [1]   Go Up
« previous next »

Share me

Digg  Facebook  SlashDot  Delicious  Technorati  Twitter  Google  Yahoo
Smf

 


EEVblog Main Site EEVblog on Youtube EEVblog on Twitter EEVblog on Facebook EEVblog on Odysee