Using direct buffer reads will at least make this 8 times faster if not 16 timesI know. But that's not the bottleneck at the moment. I also posted the version with direct buffer reads.
Now try to use a color screen :)Haha :D custom upgrade to a 83+C
#include <T6963.h>
#include <T6963_Commands.h>
#define CLK 13
#define DAT 12
T6963 lcd(240,128,6);
void setup() {
lcd.Initialize();
lcd.clearCG(); // Clear character generator area
lcd.clearGraphic(); // Clear graphic area
lcd.clearText();
pinMode(CLK,INPUT);
pinMode(DAT,INPUT);
}
void loop() {
for (byte y = 0; y < 128; y +=2){
for (byte x = 0; x < 192; x+=16){
for (byte b = 0; b < 8; b++){
//Grab a byte of pixels. Ideally you would alter the axe side to make this a single read.
while (!digitalRead(CLK));{
byte c;
c = digitalRead(DAT);
c << 1; // shifts the pixel to the next slot.
//The necessary clock delay
while (digitalRead(CLK));
delayMicroseconds(1); //Needed for a stable connection, you could also use some asm("nop");
}
}
//This scales it to 2 bytes.
byte write0 = (c & 0b10000000);
byte write0 = (c & 0b10000000) >> 1;
byte write0 = (c & 0b01000000);
byte write0 = (c & 0b01000000) >> 1;
byte write0 = (c & 0b00100000);
byte write0 = (c & 0b00100000) >> 1;
byte write0 = (c & 0b00010000);
byte write0 = (c & 0b00010000) >> 1;
byte write1 = (c & 0b00001000);
byte write1 = (c & 0b00001000) >> 1;
byte write1 = (c & 0b00000100);
byte write1 = (c & 0b00000100) >> 1;
byte write1 = (c & 0b00000010);
byte write1 = (c & 0b00000010) >> 1;
byte write1 = (c & 0b00000001);
byte write1 = (c & 0b00000001) >> 1;
//This section writes all the bytes, hopefully in the right places.
lcd.GraphicGoTo(x,y);
lcd.WriteData(write0);
lcd.GraphicGoTo(x,y+1);
lcd.WriteData(write0);
lcd.GraphicGoTo(x+8,y);
lcd.WriteData(write1);
lcd.GraphicGoTo(x+8,y+1);
lcd.WriteData(write1);
//lcd.setPixel(x,y,c);
//lcd.setPixel(x+1,y,c);
//lcd.setPixel(x+1,y+1,c);
//lcd.setPixel(x,y+1,c);
}
}
}
u_int16 c = 0;
for (byte b = 0; b < 8; b++){
while (!digitalRead(CLK));
c = c << 2;
c |= digitalRead(DAT);
while (digitalRead(CLK));
delayMicroseconds(1);
}
c *= 3; //the arduino features an "On-chip 2-cycle multiplier" :)
//now the high byte of c is write0 and the low byte is write1
It would be slow as heck if it was sending data over the I/O port though. My custom link protocol can send max 2k every second. A color LCD of 320x240 with a color depth of 8 bits would be 76800 bytes. It would take 38.4 seconds to draw the entire screen. (add the time it would take for the arduino to that)Of course you could never do all the calculations on the calc and display the screen every time. If one had an easy to use graphics library (on the arduino!) for this screen with all the important functions a game needs (sprites, bitmaps, pixel, rectangles, circles, lines, scrolling, text, ...), it could be done I guess :)
Well, we're still talking about a 96*64 screen here. That's only 768 bytes.Well who needed a color display that is that small :P the one I showed in an earlier post is 640*480.... when we go even further - what about an HDMI adapter :D :D
3->port
StoreGDB
FnOff
For(I,L6,L6+767)
{I}->B
For(8)
B . 128?0,1
->port
B*2->B
3->port
End
End
LnReg#include <T6963due.h>
#include <T6963due_Commands.h>
#define CLK 13
#define DAT 12
T6963 lcd(240,128,8,24);
byte pic[3840] = {0};
unsigned long start;
int t;
bool taken;
void setup() {
lcd.Initialize();
lcd.clearCG(); // Clear character generator area
lcd.clearGraphic(); // Clear graphic area
lcd.clearText();
pinMode(CLK,INPUT);
pinMode(DAT,INPUT);
}
void loop() {
taken = false;
while (digitalRead(CLK));
for (int y = 0; y<64; y++){
for (int n = 0; n < 12; n++){
int c = 0;
for (byte b = 0; b < 8; b++){
while (!digitalRead(CLK));
if (!taken) {start = millis(); taken = true;}
c = c << 2;
c |= digitalRead(DAT);
lcd.n_delay();
while (digitalRead(CLK));
lcd.n_delay();
}
c *= 3;
pic[n*2+y*60] = c>>8;
pic[n*2+y*60+30] = c>>8;
pic[n*2+y*60+1] = c&0xFF;
pic[n*2+y*60+31] = c&0xFF;
}
}
lcd.DispBuff(pic);
t = millis()-start;
lcd.TextGoTo(25,15);
lcd.WriteChar(t/100+'0');
lcd.WriteChar((t%100)/10+'0');
lcd.WriteChar(t%10+'0');
lcd.WriteChar('m');
lcd.WriteChar('s');
}
For any advanced color display (be it VGA or the the Sharp screen I posted) you need an extremely fast MCU to refresh the screen all along. You would need a graphics chip to handle this, even the arduino due (which finally works with the display! I will post the library later) wouldn't be fast enough too get a decent picture. The Sharp screen came with a graphics card which outputs Digital or VGA, I just don't know how to use it (it's 20 years old :P). It's a VAMP535 V1.00.
Look what benryves made: http://benryves.com/products/tvdemonstrator. It outputs composite instead of vga though.Wow, that's cool. It's interesting that he uses the screenshot function. I know that there is one, but I don't know how to use it...