Revision 2:e98408458d2b, committed 2019-08-12

Comitter:

kangmingyo

Date:

Mon Aug 12 07:12:38 2019 +0000

Parent:

1:509676f3be32

Child:

3:2a3664dc6634

Commit message:

al422b;

Changed in this revision

--- a/main.cpp	Fri Feb 17 15:06:15 2012 +0000
+++ b/main.cpp	Mon Aug 12 07:12:38 2019 +0000
@@ -2,25 +2,22 @@
 // OV7670 + FIFO AL422B camera board test
 //
 #include "mbed.h"
-#include "spilcd_qvga.h"
 #include "ov7670.h"
-#include <stdlib.h>
+
+
 
-//
-// SPILCD LG 
-//
-SPILCD_QVGA lcd(p29, p30, p5, p6, p7) ;
 OV7670 camera(
-    p28,p27,       // SDA,SCL(I2C / SCCB)
-    p21,p22,p20,   // VSYNC,HREF,WEN(FIFO)
+    D14,D15,       // SDA,SCL(I2C / SCCB)
+    D9,D14,D11,   // VSYNC,HREF,WEN(FIFO)
     //p18,p17,p16,p15,p11,p12,p14,p13, // D7-D0
-    Port0,0x07878000,
-    p23,p24,p25) ; // RRST,OE,RCLK
+    PortB,0xFF,
+    D13,D12,D6) ; // RRST,OE,RCLK
 
-Serial pc(USBTX,USBRX) ;
+Serial pc(USBTX,USBRX,115200) ;
 Timer t;
 
-#undef QQVGA
+//#undef QQVGA
+#define QQVGA
 
 #ifdef QQVGA
 # define SIZEX (160)
@@ -30,42 +27,51 @@
 # define SIZEY (240)
 #endif
 
+uint16_t fdata[SIZEX*SIZEY];
+
 int main() {
     int last ;
     pc.baud(115200) ;
     camera.Reset() ;
 
 #ifdef QQVGA
-    camera.InitQQVGA565(true,false) ;
-#else
-    camera.InitQVGA565(true,false) ;
+//    camera.InitQQVGA565(true,false) ;
+    camera.InitQVGAYUV(true,false);
+
+#else 
+    //camera.InitQVGA565(true,false) ;
 #endif
 
     // CAPTURE and SEND LOOP
     t.start();
     last = t.read_ms() ;
-    while(1)
-    {
+//    while(1)
+//    {
         camera.CaptureNext() ;
         while(camera.CaptureDone() == false) ;
         printf("Caputure %d(ms)\r\n", t.read_ms() - last) ;
         last = t.read_ms() ;
         camera.ReadStart() ;
-        lcd.Lcd_SetCursor(0,0);
-        lcd.Lcd_WR_Start();
-        lcd.rsout(1) ;
-        for (int y = 0;y < SIZEY;y++) {
-            lcd.Lcd_SetCursor(y,0);
-            lcd.Lcd_WR_Start();
+//        lcd.Lcd_SetCursor(0,0);
+//        lcd.Lcd_WR_Start();
+//        lcd.rsout(1) ;
+        for (int y = 0; y < SIZEY*SIZEX;y++) {
+//            pc.printf("\r\n");
+ //           lcd.Lcd_SetCursor(y,0);
+ 
+//            lcd.Lcd_WR_Start();
             for (int x = 0;x < SIZEX;x++) {
-                lcd.csout(0) ;
-                lcd.DataToWrite(camera.ReadOneWord());
-                lcd.csout(1) ;
+//             pc.printf("%x ",camera.ReadOneWord());
+              //  lcd.csout(0) ;
+//                lcd.DataToWrite(camera.ReadOneWord());
+//                lcd.csout(1) ;
+            fdata[SIZEX*SIZEY]=camera.ReadOneWord();
             }
         }
+   
         camera.ReadStop() ; 
-        lcd.rsout(0) ;
+        printf("%d\n", sizeof(fdata));
         printf("FIFO Read & Lcd Out %d(ms)\r\n", t.read_ms() - last) ;
         last = t.read_ms() ;
-    }
+ //   }
 }

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mbed-os.lib	Mon Aug 12 07:12:38 2019 +0000
@@ -0,0 +1,1 @@
+https://github.com/ARMmbed/mbed-os/#51d55508e8400b60af467005646c4e2164738d48

--- a/mbed.bld	Fri Feb 17 15:06:15 2012 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,1 +0,0 @@
-http://mbed.org/users/mbed_official/code/mbed/builds/14f4805c468c

--- a/ov7670.h	Fri Feb 17 15:06:15 2012 +0000
+++ b/ov7670.h	Mon Aug 12 07:12:38 2019 +0000
@@ -11,7 +11,7 @@
 //
 // OV7670 + FIFO AL422B camera board test
 //
-class OV7670 : public Base
+class OV7670
 {
 public:
     I2C camera ;
@@ -35,8 +35,8 @@
         int mask, // 0b0000_0M65_4000_0321_L000_0000_0000_0000 = 0x07878000
         PinName rt, // /RRST
         PinName o,  // /OE
-        PinName rc  // RCLK      
-        ) : camera(sda,scl),vsync(vs),href(hr),wen(we),data(port,mask),rrst(rt),oe(o),rclk(rc)
+        PinName rc  // RCLK
+    ) : camera(sda,scl),vsync(vs),href(hr),wen(we),data(port,mask),rrst(rt),oe(o),rclk(rc)
     {
         camera.stop() ;
         camera.frequency(OV7670_I2CFREQ) ;
@@ -58,7 +58,7 @@
         CaptureReq = true ;
         Busy = true ;
     }
-    
+
     // capture done? (with clear)
     bool CaptureDone(void)
     {
@@ -96,7 +96,7 @@
         wait_us(OV7670_WRITEWAIT);
         camera.write(addr) ;
         camera.stop() ;
-        wait_us(OV7670_WRITEWAIT);    
+        wait_us(OV7670_WRITEWAIT);
 
         // WRITE 0x43,READ
         camera.start() ;
@@ -104,19 +104,21 @@
         wait_us(OV7670_WRITEWAIT);
         data = camera.read(OV7670_NOACK) ;
         camera.stop() ;
-    
+
         return data ;
     }
 
-    void Reset(void) {    
+    void Reset(void)
+    {
         WriteReg(0x12,0x80) ; // RESET CAMERA
         wait_ms(200) ;
     }
-    
-    void InitQQVGA565(bool flipv,bool fliph) {
+
+    void InitQQVGA565(bool flipv,bool fliph)
+    {
         // QQVGA RGB565
         WriteReg(REG_CLKRC,0x80);
-        WriteReg(REG_COM11,0x0A) ;
+        WriteReg(REG_COM11,0x0A) ;          
         WriteReg(REG_TSLB,0x04);
         WriteReg(REG_COM7,0x04) ;
         WriteReg(REG_RGB444, 0x00);
@@ -158,9 +160,10 @@
         WriteReg(0x6f,0x9f);
 
         WriteReg(0xb0,0x84);
-    }    
+    }
 
-    void InitQVGA565(bool flipv,bool fliph) {
+    void InitQVGA565(bool flipv,bool fliph)
+    {
         // QVGA RGB565
         WriteReg(REG_CLKRC,0x80);
         WriteReg(REG_COM11,0x0A) ;
@@ -205,7 +208,190 @@
         WriteReg(0x6f,0x9f);
 
         WriteReg(0xb0,0x84);
-    }    
+    }
+    void  InitQVGAYUV(bool flipv,bool fliph)
+    { 
+        WriteReg(REG_COM7, 0x00);           // YUV
+        WriteReg(REG_COM17, 0x00);          // color bar disable
+        WriteReg(REG_COM3, 0x0C);
+        WriteReg(0x12, 0x00);//COM7
+        WriteReg(0x8C, 0x00);//RGB444
+        WriteReg(0x04, 0x00);//COM1
+        WriteReg(0x40, 0xC0);//COM15
+        WriteReg(0x14, 0x1A);//COM9
+        WriteReg(0x3D, 0x40);//COM13
+        
+        WriteReg(REG_COM15, 0xC0);
+        WriteReg(REG_COM14, 0x1a);          // divide by 4
+        WriteReg(0x72, 0x22);               // downsample by 4
+        WriteReg(0x73, 0xf2);               // divide by 4
+        WriteReg(REG_HREF, 0xa4);
+        WriteReg(REG_HSTART, 0x16);
+        WriteReg(REG_HSTOP, 0x04);
+        WriteReg(REG_VREF, 0x0a);   
+        WriteReg(REG_VSTART, 0x02);
+        WriteReg(REG_VSTOP, 0x7a);        
+             
+        WriteReg(0x7a, 0x20);
+        WriteReg(0x7b, 0x1c);
+        WriteReg(0x7c, 0x28);
+        WriteReg(0x7d, 0x3c);
+        WriteReg(0x7e, 0x5a);
+        WriteReg(0x7f, 0x68);
+        WriteReg(0x80, 0x76);
+        WriteReg(0x81, 0x80);
+        WriteReg(0x82, 0x88);
+        WriteReg(0x83, 0x8f);
+        WriteReg(0x84, 0x96);
+        WriteReg(0x85, 0xa3);
+        WriteReg(0x86, 0xaf);
+        WriteReg(0x87, 0xc4);
+        WriteReg(0x88, 0xd7);
+        WriteReg(0x89, 0xe8);
+        
+        WriteReg(0x13, 0xe0);
+        WriteReg(0x00, 0x00);
+        WriteReg(0x10, 0x00);
+        WriteReg(0x0d, 0x40);
+        WriteReg(0x14, 0x18);
+        WriteReg(0xa5, 0x05);
+        WriteReg(0xab, 0x07);
+        WriteReg(0x24, 0x95);
+        WriteReg(0x25, 0x33);
+        WriteReg(0x26, 0xe3);
+        WriteReg(0x9f, 0x78);
+        WriteReg(0xa0, 0x68);
+        WriteReg(0xa1, 0x03);
+        WriteReg(0xa6, 0xd8);
+        WriteReg(0xa7, 0xd8);
+        WriteReg(0xa8, 0xf0);
+        WriteReg(0xa9, 0x90);
+        WriteReg(0xaa, 0x94);
+        WriteReg(0x13, 0xe5);
+        
+        WriteReg(0x0e, 0x61);
+        WriteReg(0x0f, 0x4b);
+        WriteReg(0x16, 0x02);
+
+        WriteReg(0x21, 0x02);
+        WriteReg(0x22, 0x91);
+        WriteReg(0x29, 0x07);
+        WriteReg(0x33, 0x0b);
+        WriteReg(0x35, 0x0b);
+        WriteReg(0x37, 0x1d);
+        WriteReg(0x38, 0x71);
+        WriteReg(0x39, 0x2a);
+        WriteReg(0x3c, 0x78);
+        WriteReg(0x4d, 0x40);
+        WriteReg(0x4e, 0x20);
+        WriteReg(0x69, 0x00);
+
+        WriteReg(0x74, 0x10);
+        WriteReg(0x8d, 0x4f);
+        WriteReg(0x8e, 0x00);
+        WriteReg(0x8f, 0x00);
+        WriteReg(0x90, 0x00);
+        WriteReg(0x91, 0x00);
+        WriteReg(0x92, 0x00);
+
+        WriteReg(0x96, 0x00);
+        WriteReg(0x9a, 0x80);
+        WriteReg(0xb0, 0x84);
+        WriteReg(0xb1, 0x0c);
+        WriteReg(0xb2, 0x0e);
+        WriteReg(0xb3, 0x82);
+        WriteReg(0xb8, 0x0a);
+        
+        WriteReg(0x43, 0x0a);
+        WriteReg(0x44, 0xf0);
+        WriteReg(0x45, 0x34);
+        WriteReg(0x46, 0x58);
+        WriteReg(0x47, 0x28);
+        WriteReg(0x48, 0x3a);
+        WriteReg(0x59, 0x88);
+        WriteReg(0x5a, 0x88);
+        WriteReg(0x5b, 0x44);
+        WriteReg(0x5c, 0x67);
+        WriteReg(0x5d, 0x49);
+        WriteReg(0x5e, 0x0e);
+        WriteReg(0x64, 0x04);
+        WriteReg(0x65, 0x20);
+        WriteReg(0x66, 0x05);
+        WriteReg(0x94, 0x04);
+        WriteReg(0x95, 0x08);
+
+        WriteReg(0x6c, 0x0a);
+        WriteReg(0x6d, 0x55);
+        WriteReg(0x6e, 0x11);
+        WriteReg(0x6f, 0x9f);
+        WriteReg(0x6a, 0x40);
+        WriteReg(0x01, 0x40);
+        WriteReg(0x02, 0x40);
+        WriteReg(0x13, 0xe7);
+        WriteReg(0x15, 0x02);
+
+        WriteReg(0x4f, 0x80);
+        WriteReg(0x50, 0x80);
+        WriteReg(0x51, 0x00);
+        WriteReg(0x52, 0x22);
+        WriteReg(0x53, 0x5e);
+        WriteReg(0x54, 0x80);
+        WriteReg(0x58, 0x9e);
+        
+        WriteReg(0x41, 0x08);
+        WriteReg(0x3f, 0x00);
+        WriteReg(0x75, 0x05);
+        WriteReg(0x76, 0xe1);
+        WriteReg(0x4c, 0x00);
+        WriteReg(0x77, 0x01);
+        WriteReg(0x3d, 0xc1);
+        WriteReg(0x4b, 0x09);
+        WriteReg(0xc9, 0x60);
+        WriteReg(0x41, 0x38);
+        WriteReg(0x56, 0x40);
+        
+        WriteReg(0x34, 0x11);
+        WriteReg(0x3b, 0x02);
+        WriteReg(0xa4, 0x88);
+        WriteReg(0x96, 0x00);
+        WriteReg(0x97, 0x30);
+        WriteReg(0x98, 0x20);
+        WriteReg(0x99, 0x30);
+        WriteReg(0x9a, 0x84);
+        WriteReg(0x9b, 0x29);
+        WriteReg(0x9c, 0x03);
+        WriteReg(0x9d, 0x4c);
+        WriteReg(0x9e, 0x3f);
+        WriteReg(0x78, 0x04);
+        
+        WriteReg(0x79, 0x01);
+        WriteReg(0xc8, 0xf0);
+        WriteReg(0x79, 0x0f);
+        WriteReg(0xc8, 0x00);
+        WriteReg(0x79, 0x10);
+        WriteReg(0xc8, 0x7e);
+        WriteReg(0x79, 0x0a);
+        WriteReg(0xc8, 0x80);
+        WriteReg(0x79, 0x0b);
+        WriteReg(0xc8, 0x01);
+        WriteReg(0x79, 0x0c);
+        WriteReg(0xc8, 0x0f);
+        WriteReg(0x79, 0x0d);
+        WriteReg(0xc8, 0x20);
+        WriteReg(0x79, 0x09);
+        WriteReg(0xc8, 0x80);
+        WriteReg(0x79, 0x02);
+        WriteReg(0xc8, 0xc0);
+        WriteReg(0x79, 0x03);
+        WriteReg(0xc8, 0x40);
+        WriteReg(0x79, 0x05);
+        WriteReg(0xc8, 0x30);
+        WriteReg(0x79, 0x26);
+        WriteReg(0x09, 0x03);
+        WriteReg(0x3b, 0x42);
+        
+        WriteReg(0xff, 0xff);   /* END MARKER */    
+    }
 
 
     // vsync handler
@@ -228,13 +414,13 @@
         LastLines = LineCounter ;
         LineCounter = 0 ;
     }
-    
+
     // href handler
     void HrefHandler(void)
     {
         LineCounter++ ;
     }
-    
+
     // Data Read
     int ReadOneByte(void)
     {
@@ -249,37 +435,49 @@
     // Data Read (PortIn)
     int ReadOneWord(void)
     {
-        int r,r1,r2,r3,r4 ;
-        rclk = 1 ;
-        r = data ;
-        rclk = 0 ;
-        r1 = r & 0x07800000 ;
-        r1 = r1 >> (26-7-0) ; // bit26 to bit7
-        r2 = r & 0x00078000 ;
-        r2 = r2 >> (18-3-0) ; // bit18 to bit3        
-        rclk = 1 ;
-        r = data ;        
-        rclk = 0 ;
-        r3 = r & 0x07800000 ;
-        r3 = r3 >> (26-7-8) ; // bit26 to bit7
-        r4 = r & 0x00078000 ;
-        r4 = r4 >> (18-3-8) ; // bit18 to bit3
-        return r4+r3+r2+r1 ;
+        //  int r,r1,r2,r3,r4 ;
+//        rclk = 1 ;
+//        r = data ;
+//        rclk = 0 ;
+//        r1 = r & 0x07800000 ;
+//        r1 = r1 >> (26-7-0) ; // bit26 to bit7
+//        r2 = r & 0x00078000 ;
+//        r2 = r2 >> (18-3-0) ; // bit18 to bit3
+//        rclk = 1 ;
+//        r = data ;
+//        rclk = 0 ;
+//        r3 = r & 0x07800000 ;
+//        r3 = r3 >> (26-7-8) ; // bit26 to bit7
+//        r4 = r & 0x00078000 ;
+//        r4 = r4 >> (18-3-8) ; // bit18 to bit3
+
+        int r,r1,r2;
+        rclk=1;
+        r = data;
+        rclk=0;
+        r1 = r<<8;
+        rclk=1;
+        r= data;
+        rclk=0;
+        r2 = r;
+
+
+        return r2+r1 ;
     }
-    
+
     // Data Start
     void ReadStart(void)
-    {        
+    {
         rrst = 0 ;
         oe = 0 ;
         wait_us(1) ;
         rclk = 0 ;
         wait_us(1) ;
         rclk = 1 ;
-        wait_us(1) ;        
+        wait_us(1) ;
         rrst = 1 ;
     }
-    
+
     // Data Stop
     void ReadStop(void)
     {

--- a/spilcd_qvga.h	Fri Feb 17 15:06:15 2012 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,226 +0,0 @@
-//
-// SPILCD_QVGA -- mio
-// This code is based on http://mbed.org/users/Sim/programs/SPILCDsample
-//
-// 2010/06/16 - Now Supports only "LGDP4531" and screen fill test "filltest()" command only (Alpha level).
-//
-
-#ifndef __SPILCD_QVGA_H__
-#define __SPILCD_QVGA_H__
-
-#include "mbed.h"
-
-typedef unsigned int u32 ;
-typedef unsigned short u16 ;
-typedef unsigned char u8 ;
-
-class SPILCD_QVGA {
-private:
-    int rs,rw;
-
-    DigitalOut cs, rst;
-    SPI spi;
-public:
-
-    void reset(u16 data) {
-        rst = data ;
-    }
-
-    void DataToWriteBegin(void) {
-        u8 d ;
-        d = (0x70 | (rs ? 0x02 : 0x00) | (rw ? 0x01 : 0x00)) ;
-        spi.write(d) ;
-// debug
-//        pc.printf("%02X",d) ;
-    }
-
-    u16 DataToWrite16(u16 data) {
-        u8 hiout,loout ;
-        u8 hi,lo ;
-        hiout = (u8)((data & 0xFF00) >> 8) ;
-        hi = spi.write(hiout);
-// debug
-//         pc.printf("%02X",hi) ;
-        loout = ((u8)(data & 0x00FF)) ;
-        lo = spi.write(loout);
-// debug
-//        pc.printf("%02X",lo) ;
-        return (u16)((hi << 8) + lo) ;
-    }
-
-    void DataToWrite(u16 data) {
-        DataToWriteBegin() ;
-        DataToWrite16(data) ;
-    }
-
-    u16 DataToRead(u16 dummy) {
-        rw = 1 ;
-        DataToWriteBegin() ;
-        rw = 0 ;
-        // spi.write(0x00) ; // dummy 1 byte read ??
-        return DataToWrite16(dummy) ;
-    }
-
-    void LCD_WR_REG(u16 Index,u16 CongfigTemp) {
-        csout(0) ;
-        rs = 0 ;
-        DataToWrite(Index);
-        csout(1) ;
-        wait_us(1);
-        csout(0) ;
-        rs = 1 ;
-        DataToWrite(CongfigTemp);
-        csout(1) ;
-    }
-
-    u16 LCD_RD_REG(u16 Index) {
-        u16 result ;
-        csout(0) ;
-        rs = 0 ;
-        DataToWrite(Index);
-        csout(1) ;
-        wait_us(1);
-        csout(0) ;
-        rs = 1 ;
-        result = DataToRead(0x0000);
-        csout(1) ;
-        return result ;
-    }
-
-
-    void Lcd_WR_Start(void) {
-        csout(0) ;
-        rs = 0 ;
-        DataToWrite(0x0022);
-        csout(1) ;
-        wait_us(1);
-        csout(0) ;
-        rs = 1 ;
-    }
-
-    void Lcd_SetCursor(u16 x,u16 y) {
-        LCD_WR_REG(0x20,x);
-        LCD_WR_REG(0x21,y);
-    }
-
-    // boot up sequence
-    void init() {
-        spi.format(8,3); // SPI mode = 3
-        spi.frequency(20000000);
-
-        // reset
-        reset(1);
-        wait_ms(200);
-        reset(0);
-        wait_ms(200);
-        reset(1);
-
-        // initialize sequence
-        DataToWrite16(0xffff);
-        wait_ms(10);
-        LCD_WR_REG(0x0000,0x0001);
-        wait_ms(10);
-
-        u16 id = LCD_RD_REG(0x0000) ;           // CHECK LCD TYPE (ID READ)
-        printf("CHIP ID=%04X\r\n",id) ;
-
-        if (id == 0x4531) {
-            csout(0);
-            DataToWrite16(0x0);
-            DataToWrite16(0x0);
-            csout(1);
-            wait_ms(10);
-            
-            // Setup display
-            LCD_WR_REG(0x10,0x0628);
-            LCD_WR_REG(0x12,0x0006);
-            LCD_WR_REG(0x13,0x0A32);
-            LCD_WR_REG(0x11,0x0040);
-            LCD_WR_REG(0x15,0x0050);
-            LCD_WR_REG(0x12,0x0016);
-            wait_ms(15);
-            LCD_WR_REG(0x10,0x5660);
-            wait_ms(15);
-            LCD_WR_REG(0x13,0x2A4E);
-
-            LCD_WR_REG(0x01,0x0100);
-            LCD_WR_REG(0x02,0x0300);
-            LCD_WR_REG(0x03,0x1038);
-
-            LCD_WR_REG(0x08,0x0202);
-            LCD_WR_REG(0x09,0x0000);
-            LCD_WR_REG(0x0A,0x0000);
-            LCD_WR_REG(0x0C,0x0001); // 16bit , Internal
-
-            LCD_WR_REG(0x30,0x0000);
-            LCD_WR_REG(0x31,0x0402);
-            LCD_WR_REG(0x32,0x0106);
-            LCD_WR_REG(0x33,0x0700);
-            LCD_WR_REG(0x34,0x0104);
-            LCD_WR_REG(0x35,0x0301);
-            LCD_WR_REG(0x36,0x0707);
-            LCD_WR_REG(0x37,0x0305);
-            LCD_WR_REG(0x38,0x0208);
-            LCD_WR_REG(0x39,0x0F0B);
-            wait_ms(15);
-            LCD_WR_REG(0x41,0x0002);
-            LCD_WR_REG(0x60,0x2700);
-            LCD_WR_REG(0x61,0x0001);
-            LCD_WR_REG(0x90,0x0119);
-            LCD_WR_REG(0x92,0x010A);
-            LCD_WR_REG(0x93,0x0004);
-            LCD_WR_REG(0xA0,0x0100);
-            LCD_WR_REG(0x07,0x0001);
-            wait_ms(15);
-            LCD_WR_REG(0x07,0x0021);
-            wait_ms(15);
-            LCD_WR_REG(0x07,0x0023);
-            wait_ms(15);
-            LCD_WR_REG(0x07,0x0033);
-            wait_ms(15);
-            LCD_WR_REG(0x07,0x0133);
-            wait_ms(20);
-            LCD_WR_REG(0xA0,0x0000);
-            wait_ms(20);
-        } else {
-            printf("UNKNOWN LCD\r\n") ;
-        }
-    }
-
-    // constructor
-    SPILCD_QVGA(PinName cs_pin, PinName rst_pin, PinName mosi_pin, PinName miso_pin, PinName sclk_pin)
-            : cs(cs_pin), rst(rst_pin), spi(mosi_pin, miso_pin, sclk_pin) {
-        rw = 0 ;
-        rs = 0 ;
-        init() ;
-    }
-
-    void rsout(u16 data) {
-        rs = data ;
-    }
-
-    void csout(u16 data) {
-        cs = data ;
-    }
-
-    // wipe all screen
-    void filltest(u16 Color) {
-        u16 x,y ;
-        Lcd_SetCursor(0,0);
-        Lcd_WR_Start();
-        rs = 1 ;
-        for (x = 0;x < 240;x++) {
-            for (y = 0;y < 320;y++) {
-//                Lcd_SetCursor(x,y);
-//                LCD_WR_REG(0x22,Color);            
-                csout(0) ;
-                DataToWrite(Color);
-                csout(1) ;
-                Color++ ;
-            }
-        }
-        rs = 0 ;
-    }
-};
-
-#endif