 |
 |
| View previous topic :: View next topic |
| Author |
Message |
srikrishna
Joined: 06 Sep 2017
Posts: 82
|
| Help needed to convert a code from one compiler to another |
 Posted: Fri Apr 19, 2019 10:03 am |
 |
|
Hello guys probably this is off topic 
| Code: | #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 which i have found in this forum, which works great!! But now i want to write the same code for mikroC pro for pic compiler. I am not a programming expert. I have posted this problem in another forum. One of the members corrected this code to this:
| Code: | // 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);
}
} |
Which compiled successfully. But the above code is not working. Is there anyone who can help me to write a code for Mikroc pro for pic?? |
|
 |
temtronic
Joined: 01 Jul 2010
Posts: 9125
Location: Greensville,Ontario
|
|
| Posted: Fri Apr 19, 2019 10:23 am |
|
|
Ok, do the easy step FIRST....
Download PCM P's 'I2C scanner' program from the code library, compile and run.
This program WILL confirm the PIC can 'see' the device.
What is the address it finds the OLED display at ?
I'm thinking the original code is using 7 bit I2C addresses while CCS uses 8 bit.
While this may not be the problem, it'll eliminate hardware and basic code problems.
Hmm, just reread your post, and you should goto the 'other' forum hto see if they'll convert the code.
After 20+ years, I'm sticking to easy to use CCS !
Jay |
|
|
Ttelmah
Joined: 11 Mar 2010
Posts: 19245
|
|
| Posted: Fri Apr 19, 2019 11:55 am |
|
|
I see one glaring problem.
Most OLED control chips are 3.3v devices.
These need pullups to 3.3v, and if using hardware I2C, the
'SMBUS' option otherwise the PIC will not be able to interface to the
device.
Then you do not setup your clock. Where is the 20MHz coming from?.
You have no clock fuises selected, and no settings to give the compiler
the clue where it is to get the clock from....
Assuming a 20MHz crystal.
You need either:
#use delay (clock=20,000000, crystal=20MHz)
Or explicitly set the fuses
#fuses CPUDIV1, PLL5, HS
#use delay (clock=20,000000)
Which will setup the oscillator to support USB, and run the CPU at
the crystal frequency.
Then the code is fundamentally wrong. The sequence when using
I2C, is always to send start, then the device address to talk to.
You are not doing this.... I suspect you have tried to copy code
from a device that automatically sends the device address. The PIC
does not.
There are at least two OLED drivers in the code forum. Look at them. |
|
|
temtronic
Joined: 01 Jul 2010
Posts: 9125
Location: Greensville,Ontario
|
|
| Posted: Fri Apr 19, 2019 1:28 pm |
|
|
this ...
| Quote: | | Is there anyone who can help me to write a code for Mikroc pro for pic?? |
says to me he wants us to convert working CCS code into running MikroC code.
I never considered the HW aspects, though the 5V PIC vs 3V LCD is kinda obvious...
Jay |
|
|
|
|
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
|
FAQ 
Search
Register
Profile 
Log in to check your private messages 
Log in
