ov7670 no fifo

Dependents:   OV7670_Nucleo

Files at this revision

API Documentation at this revision

Comitter:
rulla
Date:
Mon Apr 20 15:04:18 2020 +0000
Parent:
1:e216fd4e8d9c
Commit message:
new

Changed in this revision

OV6620.cpp Show diff for this revision Revisions of this file
OV6620.h Show diff for this revision Revisions of this file
OV6620reg.h Show diff for this revision Revisions of this file
OV7670.cpp Show annotated file Show diff for this revision Revisions of this file
OV7670.h Show annotated file Show diff for this revision Revisions of this file
OV7670reg.h Show annotated file Show diff for this revision Revisions of this file
diff -r e216fd4e8d9c -r 90b79650f69d OV6620.cpp
--- a/OV6620.cpp	Mon Nov 21 10:04:38 2016 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,179 +0,0 @@
-#include "mbed.h"
-#include "OV6620reg.h"
-#include "OV6620.h"
-
-    void OV6620::CaptureNext(void) {
-        CaptureReq = true ;
-        Busy = true ;
-    }
-
-    bool OV6620::CaptureDone(void) {
-        bool result ;
-        if (Busy) {
-            result = false ;
-        } else {
-            result = Done ;
-            Done = false ;
-        }
-        return result ;
-    }
-
-    void OV6620::WriteReg(int addr,int data) {
-        camera.start();
-        //camera.write(CAMERA_I2C_WRITE_ADDR);
-        camera.write(addr);
-        camera.write(data);
-        camera.stop();
-        wait_us(50);
-    }
-
-    int OV6620::ReadReg(int addr) {
-        int data ;
-        camera.start() ;
-        camera.write(OV6620_WRITE) ;
-        wait_us(OV6620_WRITEWAIT);
-        camera.write(addr) ;
-        camera.stop() ;
-        wait_us(OV6620_WRITEWAIT);
-        camera.start() ;
-        camera.write(OV6620_READ) ;
-        wait_us(OV6620_WRITEWAIT);
-        data = camera.read(OV6620_NOACK) ;
-        camera.stop() ;
-        return data ;
-    }
-
-    int OV6620::Rreg(int addr) {
-        int data ;
-        camera.start() ;
-        camera.write(OV6620_WRITE) ;
-        wait_us(OV6620_WRITEWAIT);
-        camera.write(addr) ;
-        camera.stop() ;
-        wait_us(OV6620_WRITEWAIT);
-        camera.start() ;
-        camera.write(OV6620_READ) ;
-        wait_us(OV6620_WRITEWAIT);
-        data = camera.read(OV6620_NOACK) ;
-        camera.stop() ;
-        return data ;
-    }
-
-    void OV6620::Reset(void) {
-        WriteReg(0x12,0xa4) ; // RESET CAMERA
-        wait_ms(200) ;
-    }
-
-    void OV6620::Wreg (int addr,int data) {
-        camera.start();
-        camera.write(CAMERA_I2C_WRITE_ADDR);
-        camera.write(addr);
-        camera.write(data);
-        camera.stop();
-        wait_us(50);
-    }
-
-    void OV6620::InitQQVGA(void) {
-
-        xclk..period(1/24000000.0);
-        xclk.write(.5);
-
-        Reset();
-        Reset();
-        WriteReg(CLKRC,0x00);
-        WriteReg(COM_A,0x24);
-        WriteReg(COM_C,0x20);
-
-        wait(0.1);
-    }
-
-    // vsync handler
-    void OV6620::VsyncHandler(void) {
-FrameCounter++;
-    }
-
-    // href handler
-    void OV6620::HrefHandler(void) {
-        LineCounter++ ;
-    }
-
-    // pclk handler
-    void OV6620::PclkHandler(void) {
-        PixCounter++ ;
-    }
-
-    void OV6620::wait_posedge(InterruptIn pin) {
-        while(pin);
-        while(!pin);
-    }
-
-    void OV6620::wait_negedge(InterruptIn pin) {
-        while(!pin);
-        while(pin) ;
-    }
-
-    // Data Read
-    int OV6620::ReadOneByte(void) {
-        int result = (((dataP&0x07800000)>>19)|((dataP&0x078000)>>15));
-        return result ;
-    }
-
-
-    void OV6620::shot(void) {
-     uint8_t b1,b2;
-        int x = 0,pix=0; // col
-        int y = 0,line=0; // row
-        int n = 0; //  px number
-        int r,g,b;
-    
-        while(vsync); 
-       while(!vsync); //   pc.printf("!vsync 1  %d  %d  %d\r\n", vsync& 0x1,href& 0x1,pclk& 0x1);
-          while(vsync); 
-       while(!vsync);
-       while(vsync);
-       
-       for ( y=0; y<SIZEY; y++){
-        while (!href);
-        for ( x=0; x<SIZEX; x++){
-           
-            while(!pclk);
-            if (line>0){
-               b1=dataP;
-             result=dataP.read();
-            }
-            while (pclk);
-        
-         while(!pclk);
-            if (line>0){
-               b2=dataP;
-             result=dataP.read();
-            }
-            while (pclk);
-               
-               r=((bank1 & 0x1f)) ;
-            g= ((bank1&0xe0)>>5 ) | ((bank0&0x7)<<3);
-                 b=((bank0 & 0xf8)>>3 );
-                 colour = (((r<<11)&0xF800)|((g<<5)&0x7E0)| (b&0x1f));
-          TFT.pixel(x,y,colour);
-        }
-        while(href);
-    }
-        
-        printf("x , y =  %d , %d      n= %d\r\n", x,y,FrameCounter);
-        printf("frame\n");
-        n=0;
-        y=0;
-        x=0;
-        /*
-        for(y=0; y<SIZEY; y++) {
-            for(x=0; x<SIZEX; x++) {
-//         pc.printf("%d %d\n",n,byt[n]);
-              //   pc.printf("%u\n",b1[n]);
-                //TFT.pixel(x,y,b1[n]);
-                n++;
-            }
-        }
-        */
-        printf("enddddddddd frame\n");
-    }// SHOT
-}
\ No newline at end of file
diff -r e216fd4e8d9c -r 90b79650f69d OV6620.h
--- a/OV6620.h	Mon Nov 21 10:04:38 2016 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,89 +0,0 @@
-#include "mbed.h"
-#include "OV6620reg.h"
-#include <FastPWM.h>
-#include "ST7735_TFT.h"
-
-#define OV6620_WRITE (0xa2)
-#define OV6620_READ  (0xa2)
-#define OV6620_WRITEWAIT (20)
-#define OV6620_NOACK (0)
-#define OV6620_REGMAX (201)
-#define OV6620_I2CFREQ (39000)
-
-#define SIZEX  176
-#define SIZEY 144
-#define SIZE 25344
-//
-// OV6620 + FIFO AL422B camera board test
-//
-ST7735_TFT TFT(p5, p6, p7, p8, p9, p10,"TFT");// SDA, nc, SCK,CS,A0,RESET
-int per=2;
-int pwi=1;
-
-class OV6620 
-{
-public:
-
-volatile int LineCounter ;
-    volatile int LastLines ;
-    volatile bool CaptureReq ;
-    volatile bool Busy ;
-    volatile bool Done ;  
-        void CaptureNext(void);
-        bool CaptureDone(void);
-            void WriteReg(int addr,char data);
-        void Reset(void);
-        void test(void);
-        void InitQQVGA(void);
-            char ReadReg(int addr);
-    int ReadOneByte(void);
-    int ReadOneWord(void);
-    void ReadStart(void);
-    void ReadStop(void);
-    void VsyncHandler(void);
-    void PclkHandler(void) ;
-    void wait_posedge(InterruptIn pin);
-    void wait_posedge(InterruptIn pin);
-    
-    OV6620(
-        PinName sda,// Camera I2C port
-        PinName scl,// Camera I2C port
-        PinName vs, // VSYNC
-        PinName hr, // HREF
-        PinName pic ,// /pclk
-        PortName port, // 8bit bus port
-        int mask, // 0b0000_0M65_4000_0321_L000_0000_0000_0000 = 0x07878000
-        PinName xk
-    ) : camera(sda,scl),vsync(vs),href(hr),pclk(pic),dataP(port,mask),xclk(xk)
-
-    {
-        pc.baud(115200) ;
-
-        xclk..period(1/24000000.0);
-        xclk.write(.5);
-        TFT.claim(stdout);                          // Send stdout to the TFT display
-        TFT.background(Black);                      // Set background to black
-        TFT.foreground(White);                      // Set chars to white
-        TFT.cls();                                  // Clear the screen
-        TFT.set_orientation(3);
-
-        camera.stop() ;
-       camera.frequency(OV6620_I2CFREQ) ;
-       // vsync.fall(this,&OV6620::VsyncHandler) ;
-     //   href.rise(this,&OV6620::HrefHandler) ;
-      // pclk.rise(this,&OV6620::PclkHandler) ; // ????????????? blocca tutto il programma
-        CaptureReq = false ;
-        Busy = false ;
-        Done = false ;
-        LineCounter = 0 ;
-        FrameCounter = 0 ;
-        PixCounter = 0 ;
-        camera.start();
-    }
-    protected:
-        I2C camera ;
-    //InterruptIn vsync,href,pclk;
-    DigitalIn vsync,href,pclk;
-    PortIn dataP ;
-    FastPWM xclk;
-        };
\ No newline at end of file
diff -r e216fd4e8d9c -r 90b79650f69d OV6620reg.h
--- a/OV6620reg.h	Mon Nov 21 10:04:38 2016 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,29 +0,0 @@
-#define CAMERA_I2C_FREQ 40000
-#define CAMERA_I2C_READ_ADDR 0x43
-#define CAMERA_I2C_WRITE_ADDR 0x42
-#define REG_GAIN        0x00    /* Gain lower 8 bits (rest in vref) */
-#define REG_BLUE        0x01    /* blue gain */
-#define REG_RED         0x02    /* red gain */
-#define REG_SAT         0x03    /* Pieces of GAIN, VSTART, VSTOP */
-#define COM_1        0x04    /* Control 1 */
-#define REG_CONTRAST        0x05    /* U/B Average level */
-#define REG_BRIGHTNESS       0x06    /* Y/Gb Average level */
-#define REG_SHARPNESS       0x07    /* AEC MS 5 bits */
-#define REG_AEC     0x10    /* Soft sleep mode */
-#define REG_AWB_B        0x0c    /* Control 3 */
-#define REG_AWB_R        0x0D    /* Control 3 */
-#define COM_R        0x0e    /* All "reserved" */
-#define COM_S       0x0f    /* Control 6 */
-#define CLKRC       0x11    /* Clocl control */
-#define COM_A       0x12    /* Mask for internal clock scale */
-#define COM_B      0x13    /* Register reset */
-#define COM_C   0x14
-#define COM_D    0x15
-#define HREFST    0x17    /* CIF format */
-#define PSHIFT   0x1B    /* QVGA format */
-#define COM_E   0x20    /* QCIF format */
-#define AEW        0x24    /* bits 0 and 2 - RGB format */
-#define AEB        0x25    /* YUV */
-#define COM_H      0X28    /* Bayer format */
-#define COM_K     0x38    /* "Processed bayer" */
-#define COM_L        0x39    /* Control 8 */
diff -r e216fd4e8d9c -r 90b79650f69d OV7670.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/OV7670.cpp	Mon Apr 20 15:04:18 2020 +0000
@@ -0,0 +1,547 @@
+#include "mbed.h"
+#include "OV7670reg.h"
+#include "OV7670.h"
+
+    void OV7670::CaptureNext(void) {
+        CaptureReq = true ;
+        Busy = true ;
+    }
+
+    bool OV7670::CaptureDone(void) {
+        bool result ;
+        if (Busy) {
+            result = false ;
+        } else {
+            result = Done ;
+            Done = false ;
+        }
+        return result ;
+    }
+
+    void OV7670::WriteReg(int addr,char data) {
+        camera.frequency(OV7670_I2CFREQ);
+        camera.start() ;
+        camera.write(OV7670_WRITE) ;
+        wait_us(OV7670_WRITEWAIT);
+        camera.write(addr) ;
+        wait_us(OV7670_WRITEWAIT);
+        camera.write(data) ;
+        camera.stop() ;
+        wait_us(10);
+    }
+
+    char OV7670::ReadReg(int addr) {
+        int data ;
+        camera.frequency(OV7670_I2CFREQ);
+        camera.start() ;
+        camera.write(OV7670_WRITE) ;
+        wait_us(OV7670_WRITEWAIT);
+        camera.write(addr) ;
+        camera.stop() ;
+        wait_us(OV7670_WRITEWAIT);
+        camera.start() ;
+        camera.write(OV7670_READ) ;
+        wait_us(OV7670_WRITEWAIT);
+        data = camera.read(OV7670_NOACK) ;
+        camera.stop() ;
+        wait_us(10);
+        return data ;
+    }
+
+    void OV7670::Reset(float frequ) {
+
+         wait_ms(200) ;
+        WriteReg(0x12,0xa4) ; // RESET CAMERA
+        wait_ms(200) ;
+    }
+
+void OV7670::Init2(void){
+        
+    int hstart = 456, hstop = 24, vstart = 14, vstop = 494;
+    unsigned char v;
+    
+    WriteReg(REG_COM7, COM7_RESET); /* reset to default values */
+    WriteReg(REG_CLKRC, 0x01);
+    WriteReg(REG_COM7, 0x10); /* output format: YUCV */
+
+    WriteReg(REG_HSTART, (hstart >> 3) & 0xff);
+    WriteReg(REG_HSTOP, (hstop >> 3) & 0xff);
+    v = ReadReg(REG_HREF);
+    v = (v & 0xc0) | ((hstop & 0x7) << 3) | (hstart & 0x7);
+    WriteReg(REG_HREF, v);
+
+    WriteReg(REG_VSTART, (vstart >> 2) & 0xff);
+    WriteReg(REG_VSTOP, (vstop >> 2) & 0xff);
+    v = ReadReg(REG_VREF);
+    v = (v & 0xf0) | ((vstop & 0x3) << 2) | (vstart & 0x3);
+    WriteReg(REG_VREF, v);
+
+    WriteReg(REG_COM3, COM3_SCALEEN | COM3_DCWEN);
+    WriteReg(REG_COM14, COM14_DCWEN | 0x01);
+    WriteReg(0x73, 0xf1);
+    WriteReg(0xa2, 0x52);
+    WriteReg(0x7b, 0x1c);
+    WriteReg(0x7c, 0x28);
+    WriteReg(0x7d, 0x3c);
+    WriteReg(0x7f, 0x69);
+    WriteReg(REG_COM9, 0x38);
+    WriteReg(0xa1, 0x0b);
+    WriteReg(0x74, 0x19);
+    WriteReg(0x9a, 0x80);
+    WriteReg(0x43, 0x14);
+    WriteReg(REG_COM13, 0xc0);
+    WriteReg(0x70, 0x3A);
+    WriteReg(0x71, 0x35);
+    WriteReg(0x72, 0x11);
+
+    /* Gamma curve values */
+    WriteReg(0x7a, 0x20);
+    WriteReg(0x7b, 0x10);
+    WriteReg(0x7c, 0x1e);
+    WriteReg(0x7d, 0x35);
+    WriteReg(0x7e, 0x5a);
+    WriteReg(0x7f, 0x69);
+    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);
+
+    /* AGC and AEC parameters.  Note we start by disabling those features,
+     then turn them only after tweaking the values. */
+    WriteReg(REG_COM8, COM8_FASTAEC | COM8_AECSTEP | COM8_BFILT);
+    WriteReg(REG_GAIN, 0);
+    WriteReg(REG_AECH, 0);
+    WriteReg(REG_COM4, 0x40); /* magic reserved bit */
+    WriteReg(REG_COM9, 0x18); /* 4x gain + magic rsvd bit */
+    WriteReg(REG_BD50MAX, 0x05);
+    WriteReg(REG_BD60MAX, 0x07);
+    WriteReg(REG_AEW, 0x95);
+    WriteReg(REG_AEB, 0x33);
+    WriteReg(REG_VPT, 0xe3);
+    WriteReg(REG_HAECC1, 0x78);
+    WriteReg(REG_HAECC2, 0x68);
+    WriteReg(0xa1, 0x03); /* magic */
+    WriteReg(REG_HAECC3, 0xd8);
+    WriteReg(REG_HAECC4, 0xd8);
+    WriteReg(REG_HAECC5, 0xf0);
+    WriteReg(REG_HAECC6, 0x90);
+    WriteReg(REG_HAECC7, 0x94);
+    WriteReg(REG_COM8,
+            COM8_FASTAEC | COM8_AECSTEP | COM8_BFILT | COM8_AGC | COM8_AEC);
+
+    /* Almost all of these are magic "reserved" values.  */
+    WriteReg(REG_COM5, 0x61);
+    WriteReg(REG_COM6, 0x4b);
+    WriteReg(0x16, 0x02);
+    WriteReg(REG_MVFP, 0x07);
+    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(REG_COM12, 0x78);
+    WriteReg(0x4d, 0x40);
+    WriteReg(0x4e, 0x20);
+    WriteReg(REG_GFIX, 0);
+    WriteReg(0x6b, 0x4a);
+    WriteReg(0x74, 0x10);
+    WriteReg(0x8d, 0x4f);
+    WriteReg(0x8e, 0);
+    WriteReg(0x8f, 0);
+    WriteReg(0x90, 0);
+    WriteReg(0x91, 0);
+    WriteReg(0x96, 0);
+    WriteReg(0x9a, 0);
+    WriteReg(0xb0, 0x84);
+    WriteReg(0xb1, 0x0c);
+    WriteReg(0xb2, 0x0e);
+    WriteReg(0xb3, 0x82);
+    WriteReg(0xb8, 0x0a);
+
+    /* Matrix coefficients */
+    WriteReg(0x4f, 0x80);
+    WriteReg(0x50, 0x80);
+    WriteReg(0x51, 0);
+    WriteReg(0x52, 0x22);
+    WriteReg(0x53, 0x5e);
+    WriteReg(0x54, 0x80);
+    WriteReg(0x58, 0x9e);
+
+    /* More reserved magic, some of which tweaks white balance */
+    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(0x6c, 0x0a);
+    WriteReg(0x6d, 0x55);
+    WriteReg(0x6e, 0x11);
+    WriteReg(0x6f, 0x9f); /* "9e for advance AWB" */
+    WriteReg(0x6a, 0x40);
+    WriteReg(REG_BLUE, 0x40);
+    WriteReg(REG_RED, 0x60);
+    WriteReg(REG_COM8,
+            COM8_FASTAEC | COM8_AECSTEP | COM8_BFILT | COM8_AGC | COM8_AEC
+                    | COM8_AWB);
+    }
+
+    void OV7670::Init(float frequ,int sizeX) {
+             sync.mode(OpenDrain);
+             dataP.mode(PullDown);
+           //  printf("point 3\n");
+    Reset(0.0);
+     Reset(0.0);
+    //if(sizeX==320) {
+  // WriteReg(DBLV, 0xaa);                    // bypass PLL
+    //WriteReg(REG_CLKRC,0x0c);//0x8c
+    WriteReg(REG_TSLB,0x0c);//0x80
+ 
+  /*
+    WriteReg(SCALING_XSC, 0x4a);
+    WriteReg(SCALING_YSC, 0x35);
+    WriteReg(REG_HREF, 0xa4);
+    WriteReg(REG_HSTART, 168);
+    WriteReg(REG_HSTOP, 24);
+    WriteReg(REG_VREF, 0x0a);
+    WriteReg(REG_VSTART,12);
+    WriteReg(REG_VSTOP, 492);
+  */
+  
+    //WriteReg(REG_HREF, 0xc0);    
+         WriteReg(REG_CLKRC,0x1c) ;//OCCHIO
+         WriteReg(REG_COM10,0x20) ;
+        WriteReg(REG_COM1,0x0) ;
+        WriteReg(REG_COM6,0xc3) ;
+        WriteReg(REG_COM7,0x14) ;
+        WriteReg(REG_COM9,0x48) ;
+        WriteReg(REG_RGB444,0x0) ;
+
+        WriteReg(REG_COM17,0x00) ;
+        WriteReg(REG_COM3,0x04) ;
+      //  WriteReg(REG_COM14, 0x19);//OCCHIO
+        WriteReg(REG_COM15, 0xc0);
+       WriteReg(REG_COM2, 0x03);
+   //     WriteReg(SCALING_DCWCTR,0x11);
+     //   WriteReg(SCALING_PCLK_DIV,0xf2);//OCCHIO
+       // WriteReg(SCALING_PCLK_DELAY,0x02);
+    WriteReg(REG_COM8,0xc7) ;
+    WriteReg(REG_COM11,0x0a) ;//1A //0x90
+    WriteReg(REG_COM13, 0xc1);//0x88
+    WriteReg(REG_EDGE,0x04) ;
+    WriteReg(REG_PSHFT,0x0) ;
+
+        
+        WriteReg(0x7a, 0x20);
+        WriteReg(0x7b, 0x1c);
+        WriteReg(0x7c, 0x28);
+        WriteReg(0x7d, 0x3c);
+        WriteReg(0x7e, 0x55);
+        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, 0x00);
+        WriteReg(0x14, 0x28);
+        WriteReg(0xa5, 0x05);
+        WriteReg(0xab, 0x07);
+        WriteReg(0x24, 0x75);
+        WriteReg(0x25, 0x63);
+        WriteReg(0x26, 0xA5);
+        WriteReg(0x9f, 0x78);
+        WriteReg(0xa0, 0x68);
+        WriteReg(0xa1, 0x03);
+        WriteReg(0xa6, 0xdf);
+        WriteReg(0xa7, 0xdf);
+        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(0x6b, 0x00);
+        WriteReg(0x74, 0x19);
+        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, 0x14);
+        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, 0xc2);  
+        WriteReg(0x4b, 0x09);
+        WriteReg(0xc9, 0x60);
+        WriteReg(0x41, 0x38);
+        WriteReg(0x56, 0x40);
+        WriteReg(0x34, 0x11);
+        WriteReg(0x3b, 0x02);
+        WriteReg(0xa4, 0x89);
+        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 */ 
+               
+       // printf("Init\n");
+    }
+
+    // vsync handler
+    void OV7670::VsyncHandler(void) {
+    }
+
+
+    // href handler
+    void OV7670::HrefHandler(void) {
+        LineCounter++;
+    }    
+    
+    // pclk handler
+    void OV7670::PclkHandler(void) {
+        PixCounter++ ;
+    }
+
+    void OV7670::wait_posedge(InterruptIn pin) {
+        while(pin);
+        while(!pin);
+        while(pin){
+}
+    }
+
+    void OV7670::wait_negedge(InterruptIn pin) {
+        while(!pin);
+        while(pin) ;
+    }
+
+    uint8_t OV7670::ReadOneByte(void) {
+       int data= dataP.read();
+       uint8_t result=(uint8_t)(((data&0x3E)>>1)|((data&0xE000)>>8));
+        return result ;
+    }
+
+//    void OV7670::shot(int sizeX, int sizeY, uint8_t *bank0) {
+    void OV7670::shot(int sizeX, int sizeY,uint8_t *bank0) {
+
+//uint8_t bank0[76800];
+
+     uint8_t b1,b2;
+        int x = 0,pix=0; // col
+        int y = 0,line=0; // row
+        int n = 0; //  px number
+        uint8_t r,g,b;
+        int colour;
+        int i=0,j;
+    int test=sync.read();
+
+uint8_t vsync=(test&0x80)>>7;
+uint8_t href=(test&0x40)>>6;
+uint8_t pclk=(test&0x20)>>5;
+ //printf("sync= %d,  v,h,p =  %d , %d, %d  sizeX= %d\n",test, vsync,href,pclk,sizeX);
+      
+      //  printf("FrameStart\n");
+        
+       while(vsync==0){
+            test=sync.read();
+            vsync=(test&0x80)>>7;
+            }        
+          while(vsync==1){
+            test=sync.read();
+            vsync=(test&0x80)>>7;
+            }  
+
+       n=0;
+            
+   for ( y=0; y<sizeY; y++){
+x=0;
+         
+        while (href==0){
+            test=sync.read();
+            href=(test&0x40)>>6;
+            }  
+
+        for ( x=0; x<sizeX; x++){           
+           
+            while (pclk==0){
+            test=sync.read();
+            pclk=(test&0x20)>>5;
+            } 
+                        
+                  b1=ReadOneByte(); 
+  
+            while(pclk==1){
+            test=sync.read();
+          pclk=(test&0x20)>>5;
+            } 
+                 
+     
+         while(pclk==0){
+            test=sync.read();
+            pclk=(test&0x20)>>5;
+            } 
+            
+                     b2=ReadOneByte();
+
+           while (pclk==1){
+            test=sync.read();
+            pclk=(test&0x20)>>5;
+            } 
+                            
+               r=((b1>>3) & 0x1f) ;
+            g= ((((b1&0x07)<<3) &0x3f) | ((b2&0xe0) >>5))<<2;
+             b=(b2 & 0xf8) >>3;
+       //colour=(((int)b1)<<8)|((int)b2);
+     //    printf("%u ",r); //ACTION!!!
+//         printf("%u_u ",b1,b2); //ACTION!!!
+            bank0[n] =b;
+                n++;
+               // x++;
+        }
+        
+   //     }
+       // y++;
+     //  printf("\n");
+/*
+   if (href==1){ 
+                while (href==1){
+            test=sync.read();
+            href=(test&0x40)>>6;
+            }  
+            }*/
+                        test=sync.read();
+            href=(test&0x40)>>6;
+}
+
+   //  printf("FrameEnd\n");
+//printf("            PIXELS= %d",n);
+
+i=0;
+int c=0;
+
+/*     for(j=0;j<sizeY;j++){
+               for(i=0;i<sizeX;i++)  {
+                    printf("%u ",bank0[c]);
+//                    wait_us(100);
+                    c++;
+                }
+                printf("\n");
+                }
+                printf("FrameEnd\n");
+ */
+                
+    }// SHOT
diff -r e216fd4e8d9c -r 90b79650f69d OV7670.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/OV7670.h	Mon Apr 20 15:04:18 2020 +0000
@@ -0,0 +1,75 @@
+#pragma once 
+#include "mbed.h"
+#include "OV7670reg.h"
+//
+// OV7670 
+
+class OV7670 
+{
+public:
+
+volatile int LineCounter ;
+    volatile int LastLines ;
+    volatile bool CaptureReq ;
+    volatile bool Busy ;
+    volatile bool Done ;  
+    volatile int PixCounter;
+        void CaptureNext(void);
+        bool CaptureDone(void);
+            void WriteReg(int addr,char data);
+        void Reset(float frequ);
+        void test(void);
+        void Init(float frequ,int sizeX);
+        void Init2(void);
+     char ReadReg(int addr);
+    uint8_t ReadOneByte(void);
+    int ReadOneWord(void);
+    void ReadStart(void);
+    void ReadStop(void);
+    void VsyncHandler(void);
+    void HrefHandler(void);
+    void PclkHandler(void) ;
+    void wait_posedge(InterruptIn pin);
+    void wait_negedge(InterruptIn pin);
+    void shot(int sizeX, int sizeY,uint8_t *bank0);
+    
+    OV7670(
+        PinName sda,// Camera I2C port
+        PinName scl,// Camera I2C port
+        /*
+        PinName vs, // VSYNC
+        PinName hr, // HREF
+        PinName pic ,// /pclk
+        */
+        PortName ports, // 8bit bus port
+        int masks,
+        PortName port, // 8bit bus port
+        int mask
+    ) : camera(sda,scl),sync(ports,masks),dataP(port,mask)
+
+    {
+
+
+       
+        camera.stop() ;
+       camera.frequency(OV7670_I2CFREQ) ;
+       // vsync.fall(this,&OV7670::VsyncHandler) ;
+       // href.rise(callback(this, &OV7670::HrefHandler)) ;
+      // pclk.rise(this,&OV7670::PclkHandler) ; // ????????????? blocca tutto il programma
+        CaptureReq = false ;
+        Busy = false ;
+        Done = false ;
+        LineCounter = 0 ;
+        camera.start();
+    }
+    protected:
+        I2C camera ;
+    //InterruptIn vsync,href,pclk;
+    PortIn sync;
+    /*
+    DigitalIn vsync;
+    DigitalIn href;
+     DigitalIn pclk;
+    */
+    PortIn dataP;
+        };
\ No newline at end of file
diff -r e216fd4e8d9c -r 90b79650f69d OV7670reg.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/OV7670reg.h	Mon Apr 20 15:04:18 2020 +0000
@@ -0,0 +1,155 @@
+
+#define SIZE SIZEX*SIZEY
+
+#define OV7670_WRITE (0x42)
+#define OV7670_READ  (0x43)
+#define OV7670_WRITEWAIT (20)
+#define OV7670_NOACK (0)
+#define OV7670_REGMAX (201)
+#define OV7670_I2CFREQ (100000)
+
+#define SCALING_XSC       0x70    /* Control 15 */
+#define SCALING_YSC       0x71
+#define SCALING_DCWCTR      0x72
+#define SCALING_PCLK_DIV    0x73
+#define SCALING_PCLK_DELAY  0xA2
+
+#define REG_GAIN        0x00    /* Gain lower 8 bits (rest in vref) */
+#define REG_BLUE        0x01    /* blue gain */
+#define REG_RED         0x02    /* red gain */
+#define REG_VREF        0x03    /* Pieces of GAIN, VSTART, VSTOP */
+#define REG_COM1        0x04    /* Control 1 */
+#define COM1_CCIR656    0x40    /* CCIR656 enable */
+#define REG_BAVE        0x05    /* U/B Average level */
+#define REG_GbAVE       0x06    /* Y/Gb Average level */
+#define REG_AECHH       0x07    /* AEC MS 5 bits */
+#define REG_RAVE        0x08    /* V/R Average level */
+#define REG_COM2        0x09    /* Control 2 */
+#define COM2_SSLEEP     0x10    /* Soft sleep mode */
+#define REG_PID         0x0a    /* Product ID MSB */
+#define REG_VER         0x0b    /* Product ID LSB */
+#define REG_COM3        0x0c    /* Control 3 */
+#define COM3_SWAP       0x40    /* Byte swap */
+#define COM3_SCALEEN    0x08    /* Enable scaling */
+#define COM3_DCWEN      0x04    /* Enable downsamp/crop/window */
+#define REG_COM4        0x0d    /* Control 4 */
+#define REG_COM5        0x0e    /* All "reserved" */
+#define REG_COM6        0x0f    /* Control 6 */
+#define REG_AECH        0x10    /* More bits of AEC value */
+#define REG_CLKRC       0x11    /* Clocl control */
+#define CLK_EXT         0x40    /* Use external clock directly */
+#define CLK_SCALE       0x3f    /* Mask for internal clock scale */
+#define REG_COM7        0x12    /* Control 7 */
+#define COM7_RESET      0x80    /* Register reset */
+#define COM7_FMT_MASK   0x38
+#define COM7_FMT_VGA    0x00
+#define COM7_FMT_CIF    0x20    /* CIF format */
+#define COM7_FMT_QVGA   0x10    /* QVGA format */
+#define COM7_FMT_QCIF   0x08    /* QCIF format */
+#define COM7_RGB        0x04    /* bits 0 and 2 - RGB format */
+#define COM7_YUV        0x00    /* YUV */
+#define COM7_BAYER      0x01    /* Bayer format */
+#define COM7_PBAYER     0x05    /* "Processed bayer" */
+#define REG_COM8        0x13    /* Control 8 */
+#define COM8_FASTAEC    0x80    /* Enable fast AGC/AEC */
+#define COM8_AECSTEP    0x40    /* Unlimited AEC step size */
+#define COM8_BFILT      0x20    /* Band filter enable */
+#define COM8_AGC        0x04    /* Auto gain enable */
+#define COM8_AWB        0x02    /* White balance enable */
+#define COM8_AEC        0x01    /* Auto exposure enable */
+#define REG_COM9        0x14    /* Control 9  - gain ceiling */
+#define REG_COM10       0x15    /* Control 10 */
+#define COM10_HSYNC     0x40    /* HSYNC instead of HREF */
+#define COM10_PCLK_HB   0x20    /* Suppress PCLK on horiz blank */
+#define COM10_HREF_REV  0x08    /* Reverse HREF */
+#define COM10_VS_LEAD   0x04    /* VSYNC on clock leading edge */
+#define COM10_VS_NEG    0x02    /* VSYNC negative */
+#define COM10_HS_NEG    0x01    /* HSYNC negative */
+#define REG_HSTART      0x17    /* Horiz start high bits */
+#define REG_HSTOP       0x18    /* Horiz stop high bits */
+#define REG_VSTART      0x19    /* Vert start high bits */
+#define REG_VSTOP       0x1a    /* Vert stop high bits */
+#define REG_PSHFT       0x1b    /* Pixel delay after HREF */
+#define REG_MIDH        0x1c    /* Manuf. ID high */
+#define REG_MIDL        0x1d    /* Manuf. ID low */
+#define REG_MVFP        0x1e    /* Mirror / vflip */
+#define MVFP_MIRROR     0x20    /* Mirror image */
+#define MVFP_FLIP       0x10    /* Vertical flip */
+#define REG_AEW         0x24    /* AGC upper limit */
+#define REG_AEB         0x25    /* AGC lower limit */
+#define REG_VPT         0x26    /* AGC/AEC fast mode op region */
+#define REG_HSYST       0x30    /* HSYNC rising edge delay */
+#define REG_HSYEN       0x31    /* HSYNC falling edge delay */
+#define REG_HREF        0x32    /* HREF pieces */
+#define REG_TSLB        0x3a    /* lots of stuff */
+#define TSLB_YLAST      0x04    /* UYVY or VYUY - see com13 */
+#define REG_COM11       0x3b    /* Control 11 */
+#define COM11_NIGHT     0x80    /* NIght mode enable */
+#define COM11_NMFR      0x60    /* Two bit NM frame rate */
+#define COM11_HZAUTO    0x10    /* Auto detect 50/60 Hz */
+#define COM11_50HZ      0x08    /* Manual 50Hz select */
+#define COM11_EXP       0x02
+#define REG_COM12       0x3c    /* Control 12 */
+#define COM12_HREF      0x80    /* HREF always */
+#define REG_COM13       0x3d    /* Control 13 */
+#define COM13_GAMMA     0x80    /* Gamma enable */
+#define COM13_UVSAT     0x40    /* UV saturation auto adjustment */
+#define COM13_UVSWAP    0x01    /* V before U - w/TSLB */
+#define REG_COM14       0x3e    /* Control 14 */
+#define COM14_DCWEN     0x10    /* DCW/PCLK-scale enable */
+#define REG_EDGE        0x3f    /* Edge enhancement factor */
+#define REG_COM15       0x40    /* Control 15 */
+#define COM15_R10F0     0x00    /* Data range 10 to F0 */
+#define COM15_R01FE     0x80    /*            01 to FE */
+#define COM15_R00FF     0xc0    /*            00 to FF */
+#define COM15_RGB565    0x10    /* RGB565 output */
+#define COM15_RGB555    0x30    /* RGB555 output */
+#define REG_COM16       0x41    /* Control 16 */
+#define COM16_AWBGAIN   0x08    /* AWB gain enable */
+#define REG_COM17       0x42    /* Control 17 */
+#define COM17_AECWIN    0xc0    /* AEC window - must match COM4 */
+#define COM17_CBAR      0x08    /* DSP Color bar */
+#define REG_CMATRIX_BASE 0x4f
+#define CMATRIX_LEN 6
+#define REG_CMATRIX_SIGN 0x58
+#define REG_BRIGHT      0x55    /* Brightness */
+#define REG_CONTRAS     0x56    /* Contrast control */
+#define REG_GFIX        0x69    /* Fix gain control */
+#define REG_REG76       0x76    /* OV's name */
+#define R76_BLKPCOR     0x80    /* Black pixel correction enable */
+#define R76_WHTPCOR     0x40    /* White pixel correction enable */
+#define REG_RGB444      0x8c    /* RGB 444 control */
+#define R444_ENABLE     0x02    /* Turn on RGB444, overrides 5x5 */
+#define R444_RGBX       0x01    /* Empty nibble at end */
+#define REG_HAECC1      0x9f    /* Hist AEC/AGC control 1 */
+#define REG_HAECC2      0xa0    /* Hist AEC/AGC control 2 */
+#define REG_BD50MAX     0xa5    /* 50hz banding step limit */
+#define REG_HAECC3      0xa6    /* Hist AEC/AGC control 3 */
+#define REG_HAECC4      0xa7    /* Hist AEC/AGC control 4 */
+#define REG_HAECC5      0xa8    /* Hist AEC/AGC control 5 */
+#define REG_HAECC6      0xa9    /* Hist AEC/AGC control 6 */
+#define REG_HAECC7      0xaa    /* Hist AEC/AGC control 7 */
+#define REG_BD60MAX     0xab    /* 60hz banding step limit */
+
+
+#define MTX1            0x4f    /* Matrix Coefficient 1 */
+#define MTX2            0x50    /* Matrix Coefficient 2 */
+#define MTX3            0x51    /* Matrix Coefficient 3 */
+#define MTX4            0x52    /* Matrix Coefficient 4 */
+#define MTX5            0x53    /* Matrix Coefficient 5 */
+#define MTX6            0x54    /* Matrix Coefficient 6 */
+#define REG_CONTRAS     0x56    /* Contrast control */
+#define MTXS            0x58    /* Matrix Coefficient Sign */
+#define AWBC7           0x59    /* AWB Control 7 */
+#define AWBC8           0x5a    /* AWB Control 8 */
+#define AWBC9           0x5b    /* AWB Control 9 */
+#define AWBC10          0x5c    /* AWB Control 10 */
+#define AWBC11          0x5d    /* AWB Control 11 */
+#define AWBC12          0x5e    /* AWB Control 12 */
+#define REG_GFIX        0x69    /* Fix gain control */
+#define GGAIN           0x6a    /* G Channel AWB Gain */
+#define DBLV            0x6b    
+#define AWBCTR3         0x6c    /* AWB Control 3 */
+#define AWBCTR2         0x6d    /* AWB Control 2 */
+#define AWBCTR1         0x6e    /* AWB Control 1 */
+#define AWBCTR0         0x6f    /* AWB Control 0 */
\ No newline at end of file