Global shutter - oddities during capture

Joe100A · September 13, 2022, 9:17pm

1 out of 50 times I make snapshots for 5 seconds the following happens from the start or during the capture:

interference which seems like static noise . Typically like a curve of pixels that just take in random values
1 frame actually looks like two half frames . Half of the current frame and half of the last frame .
They are side by side horizontally.

———

QQQVGA greyscale with fixed exposure time (5000us)
Wait 200ms before I start while loop.
Recording to SDRAM and snapshots with copy to fb =true

Happens with and without windowing on a certain roi.

Openmv h7 plus

After every video capture run of about 5 seconds the openmv is reset through its reset pin by another device.

kwagyeman · September 13, 2022, 9:38pm

Hi, could be power or signal integrity issues.

A quick fix is to disable triple buffering.

Do set_framebuffers(1) right before your main loop and you call snapshot.

…

Two buffers being merged means that lines are being dropped by the dcmi code. This code has been well debugged however. So, this won’t happen unless there’s some issue with the system stability.

kwagyeman · September 13, 2022, 9:41pm

Looks like you are running at a low res with a short exposure….

The timing configs on those smaller resolutions are tricky and they might be too fast.

A better fix will be to edit the about of horizontal line time the camera has for that resolution. I can give you the register write command in a bit for that.

kwagyeman · September 13, 2022, 10:44pm

So, here’s how horizontal line time is calculated:

github.com

openmv/openmv/blob/master/src/omv/sensors/ov5640.c#L737


      
          {
              return cambus_writeb2(&sensor->bus, sensor->slv_addr, reg_addr, reg_data);
          }
          
          
// HTS (Horizontal Time) is the readout width plus the HSYNC_TIME time. However, if this value gets
          // too low the OV5640 will crash. The minimum was determined empirically with testing...
          // Additionally, when the image width gets too large we need to slow down the line transfer rate by
          // increasing HTS so that DCMI_DMAConvCpltUser() can keep up with the data rate.
          //
          // WARNING! IF YOU CHANGE ANYTHING HERE RETEST WITH **ALL** RESOLUTIONS FOR THE AFFECTED MODE!
          static int calculate_hts(sensor_t *sensor, uint16_t width)
          {
              uint16_t hts = hts_target;
          
          
    if ((sensor->pixformat == PIXFORMAT_GRAYSCALE) || (sensor->pixformat == PIXFORMAT_BAYER) || (sensor->pixformat == PIXFORMAT_JPEG)) {
                  if (width <= 1280) hts = IM_MAX((width * 2) + 8, hts_target);
              } else {
                  if (width > 640) hts = IM_MAX((width * 2) + 8, hts_target);
              }
          
          
    if (width <= 640) hts += 160; // Fix image quality at low resolutions.

And vertical time:

github.com

openmv/openmv/blob/master/src/omv/sensors/ov5640.c#L756


      
          
          
    if (width <= 640) hts += 160; // Fix image quality at low resolutions.
          
          
    return IM_MAX(hts + HSYNC_TIME, (SENSOR_WIDTH + HSYNC_TIME) / 2); // Fix to prevent crashing.
          }
          
          
// VTS (Vertical Time) is the readout height plus the VYSNC_TIME time. However, if this value gets
          // too low the OV5640 will crash. The minimum was determined empirically with testing...
          //
          // WARNING! IF YOU CHANGE ANYTHING HERE RETEST WITH **ALL** RESOLUTIONS FOR THE AFFECTED MODE!
          static int calculate_vts(sensor_t *sensor, uint16_t readout_height)
          {
              return IM_MAX(readout_height + VYSNC_TIME, (SENSOR_HEIGHT + VYSNC_TIME) / 8); // Fix to prevent crashing.
          }
          
          
static int set_pixformat(sensor_t *sensor, pixformat_t pixformat)
          {
              uint8_t reg;
              int ret = 0;
          
          
    // Not a multiple of 8. The JPEG encoder on the OV5640 can't handle this.

And then they are written to these registers:

github.com

openmv/openmv/blob/master/src/omv/sensors/ov5640.c#L935


      
          
          
ret |= cambus_writeb2(&sensor->bus, sensor->slv_addr, TIMING_VH_H, sensor_he >> 8);
          ret |= cambus_writeb2(&sensor->bus, sensor->slv_addr, TIMING_VH_L, sensor_he);
          
          
ret |= cambus_writeb2(&sensor->bus, sensor->slv_addr, TIMING_DVPHO_H, w >> 8);
          ret |= cambus_writeb2(&sensor->bus, sensor->slv_addr, TIMING_DVPHO_L, w);
          
          
ret |= cambus_writeb2(&sensor->bus, sensor->slv_addr, TIMING_DVPVO_H, h >> 8);
          ret |= cambus_writeb2(&sensor->bus, sensor->slv_addr, TIMING_DVPVO_L, h);
          
          
ret |= cambus_writeb2(&sensor->bus, sensor->slv_addr, TIMING_HTS_H, sensor_hts >> 8);
          ret |= cambus_writeb2(&sensor->bus, sensor->slv_addr, TIMING_HTS_L, sensor_hts);
          
          
ret |= cambus_writeb2(&sensor->bus, sensor->slv_addr, TIMING_VTS_H, sensor_vts >> 8);
          ret |= cambus_writeb2(&sensor->bus, sensor->slv_addr, TIMING_VTS_L, sensor_vts);
          
          
ret |= cambus_writeb2(&sensor->bus, sensor->slv_addr, TIMING_HOFFSET_H, x_off >> 8);
          ret |= cambus_writeb2(&sensor->bus, sensor->slv_addr, TIMING_HOFFSET_L, x_off);
          
          
ret |= cambus_writeb2(&sensor->bus, sensor->slv_addr, TIMING_VOFFSET_H, y_off >> 8);
          ret |= cambus_writeb2(&sensor->bus, sensor->slv_addr, TIMING_VOFFSET_L, y_off);

Addresses

github.com

openmv/openmv/blob/master/src/omv/sensors/ov5640_regs.h#L72


      
          
          
#define TIMING_VH_H         0x3806
          #define TIMING_VH_L         0x3807
          
          
#define TIMING_DVPHO_H      0x3808
          #define TIMING_DVPHO_L      0x3809
          
          
#define TIMING_DVPVO_H      0x380A
          #define TIMING_DVPVO_L      0x380B
          
          
#define TIMING_HTS_H        0x380C
          #define TIMING_HTS_L        0x380D
          
          
#define TIMING_VTS_H        0x380E
          #define TIMING_VTS_L        0x380F
          
          
#define TIMING_HOFFSET_H    0x3810
          #define TIMING_HOFFSET_L    0x3811
          
          
#define TIMING_VOFFSET_H    0x3812
          #define TIMING_VOFFSET_L    0x3813

So…

If you just read back those registers using the sensor.__reg_read(), then build up what was written and then write back a larger time value (using sensor.__write_reg(, ) your error should go away.

It’s entirely possible that at the QQQVGA resolution the camera is outputting data too fast for the H7 Plus to keepup.

kwagyeman · September 13, 2022, 10:47pm

Ahh…

Wait, you asked about the global shutter sensor. Not the OV5640.

The global shutter sensor is slow compared to the OV5640. There should be no problems with it.

My initial comment about voltage/current and signal quality stands. How is the camera connected to the board? Does the board have good power input?

Joe100A · September 14, 2022, 10:49am

I have the issue both with flex pcb adaptor and when the sensor is directly on the board. I scoped the power supply (input to board) but didn’t manage to have a scope on in the rare occurrence of the issues I mentioned in my post. The voltage is very stable.

Topic		Replies	Views
Snapshot() - h7plus randomly hangs firmware 4.5.5 OpenMV Boards	7	70	June 22, 2024
Frame capture randomly timing out OpenMV Boards	9	224	April 17, 2024
RAW Image Capture - Higher Frame Rate OpenMV Boards	14	1081	August 7, 2023
Sensor snapshot takes 0.02s, can't achieve >50 FPS OpenMV Boards	1	520	November 10, 2020
Why is Grayscale image so grainy OpenMV Boards	6	449	August 16, 2023

Global shutter - oddities during capture

Related topics