FAQ

Our goal with the OpenMV Cam is to provide you with an Arduino like experience when dealing with computer vision. So, we made the OpenMV Cam a low power module so you could run it from your computer's USB port. We made it require no configuration so you could get up and running in minutes. And, we made it small so you could put it anywhere.

If you're just looking for raw performance, where power consumption, ease-of-use, and size are not a factor, then Single Board Computers (SBCs) like the Raspberry Pi are what you want to buy. We're not trying to win the performance race. But, when power consumption, simplicity, and size matter then you want an OpenMV Cam.

When you buy an OpenMV Cam you're helping to support the development of easy-to-use machine vision for the masses. Ultimately we want to offer super-small ultra-low cost OpenMV Cams that can easily be embedded in products like you'd do with PIR motion detector sensors. We're trying to make the future where you can easily put a camera in everything possible.

The OpenMV Cam consumes about 100 mA while idle and 140 mA when processing images. This means your OpenMV Cam can easily run off of your USB port. No power brick needed.

Since we're using MicroPython you have total control over power consumption so you can deploy OpenMV Cams easily in power sensitive applications. Need to draw less than 1mA? Simply add a sleep command to your script. Your OpenMV Cam can then be woken up by either a level-sensitive interrupt or the on-chip RTC.

How long does it take to blink an LED on a brand new Arduino? Well, you install the Arduino IDE on your computer, plug in your Arduino, open an example script, and you're done. So, less than 5 minutes.

How long does it take to track a colored object on a brand new OpenMV Cam? Well, you install the OpenMV IDE on your computer, plug in your OpenMV Cam, open an example script, and you're done. So, less than 5 minutes.

How long does it take to track a colored object on a brand new single board computer (SBC)? Well, first you need to install your OS on an SD card. Then boot up and login to your SBC which may be difficult if you don't have a screen for it. Then you need to connect it to the internet and install OpenCV... and ... and ... and ... etc.

I might have left out some steps above, but, the point is that with an OpenMV Cam you're getting an Arduino like experience for working with machine vision. That is, we're focused on making it super simple for you to get machine vision applications up and running that can easily interact with the real-world.

That's a good question. If MicroPython didn't exist before OpenMV was started it may have been developed so you'd have to program it in C/C++. If you programmed your OpenMV Cam in C/C++ we would have been able to use the Arduino Core, unused library calls would have been optimized out, and your code would run faster.

However, one problem, one big problem would remain - dynamic memory management. In C/C++ this has to be done explicitly. So, deleting complex data structures would not be as easy as in Python. Of course, we could have created complex classes to get around these issues. But, MicroPython was available and solves this problem so we built upon it instead.

It's important to understand that most machine vision functions/methods return a list of data structures. Some of these data structures may be lists too themselves. Iterating through lists, sorting, filtering, etc. are all taken care of by MicroPython somewhat magically whereas in C/C++ the user must get very involved in making sure their code is right and that they don't leak memory, dereference a bad pointer, or etc. As we've said previously we have a goal of making the system easy-to-use and C/C++ definitely would not be easy for beginner programmers.

Yes, Python is slow compared to C/C++, but, all of our algorithms are written in C. Python is just used as the top level interface to make coding easy. Additionally, all peripheral control is written in C too. So, Python again is just used as the top level interface to make coding easy.

Note that the MicroPython operating system compiles your Python script into byte code before executing it (like on your PC). So your OpenMV Cam isn't wasting tons of time parsing the same script over and over.

Anyway, if you want to access memory directly or if you need more speed for a custom algorithm then MicroPython has you covered. First, MicroPython allows you to directly access any memory location in the OpenMV Cam at any time if you need to play with register settings. Second, MicroPython allows you to write native ARM assembly code that can be executed in your Python script like a function call. Third, the OpenMV Cam's firmware is Open Source and you can freely modify and extend it with new custom functionality in C and then flash the new firmware onto your OpenMV Cam using OpenMV IDE.

No, we wrote all of our machine vision algorithms ourselves. While powerful, OpenCV is designed for a computer running Windows/OSX/Linux. But, your OpenMV Cam isn't running any OS and instead gives you bare-metal control with MicroPython - so, OpenCV isn't compatible in various ways.

Anyway, we're fine with this situation. Implementing machine vision algorithms is fun and interesting. Moreover, we're building a new computer vision library without all the memory and operating system constraints imposed on you by OpenCV.

One final note, if you're looking to write your own custom algorithms in C on the OpenMV Cam you'll find our code is very easy to modify and extend. And, if you want to share your work you can send us a pull request with your changes and we may incorporate it into the main firmware.

Yes, open is in our name. All of our source code is published online on our GitHub and you can find our board schematics on the product pages. As for re-programming your OpenMV Cam's firmware, you can do this via OpenMV IDE.

Additionally, all of our code is MIT licensed. So, do whatever you feel like with it. We'd love for a community to build up around the OpenMV code base to help make it better than it currently is.

Our goal is to make cheap, low-power, and easy-to-use machine vision modules. And... surprisingly enough, for most machine vision applications more resolution doesn't actually help but in fact hurts. A 640x480 image takes 4X more processing power to work on at the same frame rate than a 320x240 image. So, unless there's a specific reason you need the increased resolution then you're just slowing your frame rate down. For example, Face Detection is implemented using an algorithm that will generate multiple matches for the location of a face in an image that all overlap each other like a person repeatedly drawing a box many times around someone's face. We then average all the detected overlapping boxes together before returning the result. So in this case additional resolution is more or less worthless for precision since the algorithm outputs a noisy result that has to be filtered. Thus, after you have enough resolution more doesn't really help unless you need to resolve additional detail at farther distances which can easily be accomplished by just using a telephoto lens.

Anyway, for the TL;DR folks more resolution would have meant using a more expensive camera module and a more expensive power hungry processor without actually giving you substantially better machine vision results. Now, you could take higher quality pictures and video though, but, as stated previously our goal is to make cheap, low-power, and easy-to-use machine vision modules.

All the above said, your OpenMV Cam can take decent enough pictures and video for security camera purposes. Ultra high definition video is nice but not a necessity if you just need to quickly record something happening. Best of all, with the OpenMV Cam you have total control over taking pictures and recording video so you can easily run machine vision algorithms on snapshots and then markup the snapshots before saving them.

As we sell more and more units and grow the company we will be able to do this. Please buy some of our products today to make that a reality.

The OpenMV Cam M7 is about half as fast as the Raspberry Pi Zero while the OpenMV Cam H7 is slightly faster than the Raspberry Pi 2 in CPU bound machine vision performance (you can of course get more performance from single-board-computers with application processors when you use their GPU and SIMD instructions - but of course, you get more power consumption too).

The OpenMV Cam is able to achieve application processor level performance while running at a lower clock-frequency (and thus lower power consumption) thanks to ARM's Cortex-M7 architecture which gets about 2.5X more instructions per clock than the ARM11 and Cortex-A7 architectures that the Raspberry Pi zero and Raspberry Pi 2 use.

Checkout the coremark performance page for CPU comparison scores or the summary below:

Cortex-M7

• OpenMV Cam M7 @ 216 MHz -> 1082.41 (5.01 per MHz)
• OpenMV Cam H7 @ 480 MHz -> 2424 (5.05 per MHz)
• OpenMV Cam RT0162 @ 600 MHz -> 3015 (5.025 per MHz)

ARM1176JZF-S

• Raspberry Pi 1 @ 700 MHz -> 1303.78 (1.86 per MHz)
• Raspberry Pi 0 @ 1 GHz -> 2060.98 (2.06 per MHz)

Cortex-A7

• Raspberry Pi 2 @ 900 MHz -> 2340 (2.6 per MHz)

Cortex-A53

• Raspberry Pi 3 @ 900 MHz -> 2700 (3.0 per MHz)
• Raspberry Pi 3 @ 1.2 GHz -> 3600 (3.0 per MHz)

Coremark is more realistic performance measurement than Dhrystone where compilers often optimize out most of the work the benchmark does.

Now, what about memory? The OpenMV Cam M7 has about 384 KB of RAM for computer vision algorithms while the OpenMV Cam H7 has 512 KB of RAM for computer vision algorithms. The memory bus on the OpenMV Cam M7 is 32-bits wide and runs at 216 MHz for 864 MB/s of memory bandwidth. The memory bus on the OpenMV Cam H7 is 64-bits wide and runs at 480 MHz for 3.84 GB/s of memory bandwidth. Compare this with the original Raspberry Pi and Raspberry Pi 2 whose 32-bit memory buses run at 400 MHz in DDR mode for a performance of 3.2 GB/s (the Raspberry Pi 3 and Zero 32-bit memory buses run at 450 MHz in DDR mode for a performance of 3.6 GB/s).

So, while the OpenMV Cams don't have a lot of RAM to allow for high resolution computer vision (which you don't really want to do anyway for real-time applications) they are able to offer competitive performance while at a low-power consumption.

Now, newer OpenMV Cam models like the OpenMV Cam H7 Plus and OpenMV Cam RT1062 have 32 MBs of external SDRAM running at 400 MB/s and 320 MB/s respectively. The added SDRAM allows for processing much higher resolution images than possible before with the OpenMV Cam M4/M7/H7. We overcome the slower performance of the SDRAM by caching as many data structures in internal SRAM which runs at 3.84 GB/s and 1.2GB/s on the OpenMV Cam H7 Plus and OpenMV Cam RT1062 respectively.